pkg/api/api.gen.go - master - Andromeda141/Adventure-service

pkg/api/api.gen.go
9 081 строка284 KB
andrewvnukov
Realese 1.2
08 июн 2026, 11:35
08 июн 2026, 11:35948add3
// Package api 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 api

import (
	"bytes"
	"compress/gzip"
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"path"
	"strings"
	"time"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/go-chi/chi/v5"
	"github.com/oapi-codegen/runtime"
	strictnethttp "github.com/oapi-codegen/runtime/strictmiddleware/nethttp"
	openapi_types "github.com/oapi-codegen/runtime/types"
)

const (
	CookieAuthScopes = "cookieAuth.Scopes"
)

// Defines values for ActivityPollStatus.
const (
	ActivityPollStatusActive   ActivityPollStatus = "active"
	ActivityPollStatusExpired  ActivityPollStatus = "expired"
	ActivityPollStatusPassed   ActivityPollStatus = "passed"
	ActivityPollStatusRejected ActivityPollStatus = "rejected"
)

// Valid indicates whether the value is a known member of the ActivityPollStatus enum.
func (e ActivityPollStatus) Valid() bool {
	switch e {
	case ActivityPollStatusActive:
		return true
	case ActivityPollStatusExpired:
		return true
	case ActivityPollStatusPassed:
		return true
	case ActivityPollStatusRejected:
		return true
	default:
		return false
	}
}

// Defines values for ActivityType.
const (
	ActivityTypeHotel       ActivityType = "hotel"
	ActivityTypeOther       ActivityType = "other"
	ActivityTypeRestaurant  ActivityType = "restaurant"
	ActivityTypeShopping    ActivityType = "shopping"
	ActivityTypeSightseeing ActivityType = "sightseeing"
	ActivityTypeTransport   ActivityType = "transport"
)

// Valid indicates whether the value is a known member of the ActivityType enum.
func (e ActivityType) Valid() bool {
	switch e {
	case ActivityTypeHotel:
		return true
	case ActivityTypeOther:
		return true
	case ActivityTypeRestaurant:
		return true
	case ActivityTypeShopping:
		return true
	case ActivityTypeSightseeing:
		return true
	case ActivityTypeTransport:
		return true
	default:
		return false
	}
}

// Defines values for RegisterRequestGender.
const (
	RegisterRequestGenderFemale RegisterRequestGender = "female"
	RegisterRequestGenderMale   RegisterRequestGender = "male"
	RegisterRequestGenderOther  RegisterRequestGender = "other"
)

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

// Defines values for TripStatus.
const (
	TripStatusActive    TripStatus = "active"
	TripStatusArchived  TripStatus = "archived"
	TripStatusCancelled TripStatus = "cancelled"
	TripStatusCompleted TripStatus = "completed"
	TripStatusDrafting  TripStatus = "drafting"
	TripStatusPlanning  TripStatus = "planning"
	TripStatusReady     TripStatus = "ready"
)

// Valid indicates whether the value is a known member of the TripStatus enum.
func (e TripStatus) Valid() bool {
	switch e {
	case TripStatusActive:
		return true
	case TripStatusArchived:
		return true
	case TripStatusCancelled:
		return true
	case TripStatusCompleted:
		return true
	case TripStatusDrafting:
		return true
	case TripStatusPlanning:
		return true
	case TripStatusReady:
		return true
	default:
		return false
	}
}

// Defines values for UpdateUserRequestGender.
const (
	UpdateUserRequestGenderFemale UpdateUserRequestGender = "female"
	UpdateUserRequestGenderMale   UpdateUserRequestGender = "male"
	UpdateUserRequestGenderOther  UpdateUserRequestGender = "other"
)

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

// Defines values for UserGender.
const (
	UserGenderFemale UserGender = "female"
	UserGenderMale   UserGender = "male"
	UserGenderOther  UserGender = "other"
)

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

// Defines values for VoteActivityPollRequestChoice.
const (
	Against VoteActivityPollRequestChoice = "against"
	For     VoteActivityPollRequestChoice = "for"
)

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

// Activity defines model for Activity.
type Activity struct {
	AssignedTo *[]openapi_types.UUID `json:"assigned_to,omitempty"`
	Cost       *float32              `json:"cost,omitempty"`

	// CreatedBy ID пользователя создавшего активность True when this activity is awaiting the result of a poll vote. Pending activities are not shown in the regular trip activity list — they become visible only after the poll passes.
	CreatedBy *openapi_types.UUID `json:"created_by,omitempty"`
	Currency  *string             `json:"currency,omitempty"`
	DayNumber *int                `json:"day_number,omitempty"`
	EndTime   *time.Time          `json:"end_time,omitempty"`
	Id        *openapi_types.UUID `json:"id,omitempty"`
	IsPending *bool               `json:"is_pending,omitempty"`
	Location  *Location           `json:"location,omitempty"`
	Notes     *string             `json:"notes,omitempty"`
	StartTime *time.Time          `json:"start_time,omitempty"`
	Title     *string             `json:"title,omitempty"`
	Type      *ActivityType       `json:"type,omitempty"`
}

// ActivityPoll defines model for ActivityPoll.
type ActivityPoll struct {
	ActivityToAdd *Activity  `json:"activity_to_add,omitempty"`
	CreatedAt     *time.Time `json:"created_at,omitempty"`

	// CreatedBy ID пользователя создавшего голосование
	CreatedBy    *openapi_types.UUID   `json:"created_by,omitempty"`
	Description  *string               `json:"description,omitempty"`
	ExpiresAt    *time.Time            `json:"expires_at,omitempty"`
	Id           *openapi_types.UUID   `json:"id,omitempty"`
	Status       *ActivityPollStatus   `json:"status,omitempty"`
	Title        *string               `json:"title,omitempty"`
	TripId       *openapi_types.UUID   `json:"trip_id,omitempty"`
	VoterCount   *int                  `json:"voter_count,omitempty"`
	Voters       *[]openapi_types.UUID `json:"voters,omitempty"`
	VotesAgainst *int                  `json:"votes_against,omitempty"`
	VotesFor     *int                  `json:"votes_for,omitempty"`
}

// ActivityPollStatus defines model for ActivityPollStatus.
type ActivityPollStatus string

// ActivityType defines model for ActivityType.
type ActivityType string

// CreateActivityPollRequest defines model for CreateActivityPollRequest.
type CreateActivityPollRequest struct {
	ActivityToAdd Activity `json:"activity_to_add"`

	// CreatedBy Заполняется сервером — ID создателя голосования
	CreatedBy   *openapi_types.UUID `json:"created_by,omitempty"`
	Description *string             `json:"description,omitempty"`
	ExpiresAt   time.Time           `json:"expires_at"`
	Title       string              `json:"title"`
}

// CreateInviteLinkRequest defines model for CreateInviteLinkRequest.
type CreateInviteLinkRequest struct {
	ExpiresAt time.Time `json:"expires_at"`
}

// CreateTripRequest defines model for CreateTripRequest.
type CreateTripRequest struct {
	Description *string             `json:"description,omitempty"`
	EndDate     *openapi_types.Date `json:"end_date,omitempty"`
	StartDate   *openapi_types.Date `json:"start_date,omitempty"`
	Status      *TripStatus         `json:"status,omitempty"`
	Title       string              `json:"title"`
}

// DirectInviteRequest defines model for DirectInviteRequest.
type DirectInviteRequest struct {
	UserId openapi_types.UUID `json:"user_id"`
}

// Error defines model for Error.
type Error struct {
	ErrorCode *string `json:"errorCode,omitempty"`
	ErrorText *string `json:"errorText,omitempty"`
}

// InviteCodeResponse defines model for InviteCodeResponse.
type InviteCodeResponse struct {
	Code *string `json:"code,omitempty"`
	Link *string `json:"link,omitempty"`
}

// InviteLink defines model for InviteLink.
type InviteLink struct {
	// Code Short alphanumeric code to share with invitees
	Code      *string             `json:"code,omitempty"`
	CreatedAt *time.Time          `json:"created_at,omitempty"`
	CreatedBy *openapi_types.UUID `json:"created_by,omitempty"`
	ExpiresAt *time.Time          `json:"expires_at,omitempty"`
	Id        *openapi_types.UUID `json:"id,omitempty"`
	IsActive  *bool               `json:"is_active,omitempty"`
	TripId    *openapi_types.UUID `json:"trip_id,omitempty"`
}

// Location defines model for Location.
type Location struct {
	Address *string  `json:"address,omitempty"`
	Lat     *float64 `json:"lat,omitempty"`
	Lng     *float64 `json:"lng,omitempty"`
	Name    *string  `json:"name,omitempty"`
	PlaceId *string  `json:"place_id,omitempty"`
}

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

// NewsItem defines model for NewsItem.
type NewsItem struct {
	Description *string    `json:"description,omitempty"`
	Link        *string    `json:"link,omitempty"`
	PubDate     *time.Time `json:"pub_date,omitempty"`
	Title       *string    `json:"title,omitempty"`
}

// Notification defines model for Notification.
type Notification struct {
	CreatedAt *time.Time          `json:"created_at,omitempty"`
	Id        *openapi_types.UUID `json:"id,omitempty"`
	Link      *string             `json:"link,omitempty"`
	Message   *string             `json:"message,omitempty"`
	Read      *bool               `json:"read,omitempty"`
	Title     *string             `json:"title,omitempty"`
	TripId    *openapi_types.UUID `json:"trip_id,omitempty"`
	Type      *string             `json:"type,omitempty"`
}

// RegisterRequest defines model for RegisterRequest.
type RegisterRequest struct {
	Age      int                   `json:"age"`
	Email    openapi_types.Email   `json:"email"`
	Gender   RegisterRequestGender `json:"gender"`
	Login    string                `json:"login"`
	Name     string                `json:"name"`
	Password string                `json:"password"`
	PhotoUrl *string               `json:"photo_url,omitempty"`
	Surname  string                `json:"surname"`
}

// RegisterRequestGender defines model for RegisterRequest.Gender.
type RegisterRequestGender string

// Trip defines model for Trip.
type Trip struct {
	Description *string               `json:"description,omitempty"`
	EndDate     *openapi_types.Date   `json:"end_date,omitempty"`
	Id          *openapi_types.UUID   `json:"id,omitempty"`
	Members     *[]openapi_types.UUID `json:"members,omitempty"`
	OwnerId     *openapi_types.UUID   `json:"owner_id,omitempty"`
	StartDate   *openapi_types.Date   `json:"start_date,omitempty"`
	Status      *TripStatus           `json:"status,omitempty"`
	Title       *string               `json:"title,omitempty"`
}

// TripMember defines model for TripMember.
type TripMember struct {
	Id       *openapi_types.UUID `json:"id,omitempty"`
	Login    *string             `json:"login,omitempty"`
	Name     *string             `json:"name,omitempty"`
	PhotoUrl *string             `json:"photo_url,omitempty"`
	Surname  *string             `json:"surname,omitempty"`
}

// TripStatus defines model for TripStatus.
type TripStatus string

// UpdateTripRequest defines model for UpdateTripRequest.
type UpdateTripRequest struct {
	Description *string             `json:"description,omitempty"`
	EndDate     *openapi_types.Date `json:"end_date,omitempty"`
	StartDate   *openapi_types.Date `json:"start_date,omitempty"`
	Title       *string             `json:"title,omitempty"`
}

// UpdateUserRequest Fields the authenticated user can update on their own profile. All fields are optional — only provided fields are updated.
type UpdateUserRequest struct {
	// Age Age (must be 13 or older)
	Age *int `json:"age,omitempty"`

	// Gender Gender
	Gender *UpdateUserRequestGender `json:"gender,omitempty"`

	// Name First name
	Name *string `json:"name,omitempty"`

	// PhotoUrl Profile photo URL
	PhotoUrl *string `json:"photo_url,omitempty"`

	// Surname Last name
	Surname *string `json:"surname,omitempty"`
}

// UpdateUserRequestGender Gender
type UpdateUserRequestGender string

// User defines model for User.
type User struct {
	Age       *int                 `json:"age,omitempty"`
	CreatedAt *time.Time           `json:"created_at,omitempty"`
	Email     *openapi_types.Email `json:"email,omitempty"`
	Gender    *UserGender          `json:"gender,omitempty"`
	Id        *openapi_types.UUID  `json:"id,omitempty"`
	Login     *string              `json:"login,omitempty"`
	Name      *string              `json:"name,omitempty"`
	PhotoUrl  *string              `json:"photo_url,omitempty"`
	Surname   *string              `json:"surname,omitempty"`
}

// UserGender defines model for User.Gender.
type UserGender string

// VoteActivityPollRequest defines model for VoteActivityPollRequest.
type VoteActivityPollRequest struct {
	Choice VoteActivityPollRequestChoice `json:"choice"`
}

// VoteActivityPollRequestChoice defines model for VoteActivityPollRequest.Choice.
type VoteActivityPollRequestChoice string

// GetNewsParams defines parameters for GetNews.
type GetNewsParams struct {
	// Q Search query (city, country, or topic)
	Q *string `form:"q,omitempty" json:"q,omitempty"`
}

// GetAllTripsParams defines parameters for GetAllTrips.
type GetAllTripsParams struct {
	// Owner If true — return only trips owned by the current user
	Owner  *bool       `form:"owner,omitempty" json:"owner,omitempty"`
	Status *TripStatus `form:"status,omitempty" json:"status,omitempty"`
}

// GetTripActivityParams defines parameters for GetTripActivity.
type GetTripActivityParams struct {
	// AId Activity UUID
	AId *openapi_types.UUID `form:"aId,omitempty" json:"aId,omitempty"`
}

// GetTripActivityPollsParams defines parameters for GetTripActivityPolls.
type GetTripActivityPollsParams struct {
	Status *ActivityPollStatus `form:"status,omitempty" json:"status,omitempty"`
}

// UpdateTripStatusByIdParams defines parameters for UpdateTripStatusById.
type UpdateTripStatusByIdParams struct {
	Status TripStatus `form:"status" json:"status"`
}

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

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

// CreateTripJSONRequestBody defines body for CreateTrip for application/json ContentType.
type CreateTripJSONRequestBody = CreateTripRequest

// UpdateTripByIdJSONRequestBody defines body for UpdateTripById for application/json ContentType.
type UpdateTripByIdJSONRequestBody = UpdateTripRequest

// CreateActivityJSONRequestBody defines body for CreateActivity for application/json ContentType.
type CreateActivityJSONRequestBody = Activity

// UpdateActivityJSONRequestBody defines body for UpdateActivity for application/json ContentType.
type UpdateActivityJSONRequestBody = Activity

// CreateInviteLinkJSONRequestBody defines body for CreateInviteLink for application/json ContentType.
type CreateInviteLinkJSONRequestBody = CreateInviteLinkRequest

// DirectInviteUserJSONRequestBody defines body for DirectInviteUser for application/json ContentType.
type DirectInviteUserJSONRequestBody = DirectInviteRequest

// CreateActivityPollJSONRequestBody defines body for CreateActivityPoll for application/json ContentType.
type CreateActivityPollJSONRequestBody = CreateActivityPollRequest

// VoteOnActivityPollJSONRequestBody defines body for VoteOnActivityPoll for application/json ContentType.
type VoteOnActivityPollJSONRequestBody = VoteActivityPollRequest

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

// RequestEditorFn  is the function signature for the RequestEditor callback function
type RequestEditorFn func(ctx context.Context, req *http.Request) error

// Doer performs HTTP requests.
//
// The standard http.Client implements this interface.
type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

// Client which conforms to the OpenAPI3 specification for this service.
type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

// ClientOption allows setting custom parameters during construction
type ClientOption func(*Client) error

// Creates a new Client, with reasonable defaults
func NewClient(server string, opts ...ClientOption) (*Client, error) {
	// create a client with sane default values
	client := Client{
		Server: server,
	}
	// mutate client and add all optional params
	for _, o := range opts {
		if err := o(&client); err != nil {
			return nil, err
		}
	}
	// ensure the server URL always has a trailing slash
	if !strings.HasSuffix(client.Server, "/") {
		client.Server += "/"
	}
	// create httpClient, if not already present
	if client.Client == nil {
		client.Client = &http.Client{}
	}
	return &client, nil
}

// WithHTTPClient allows overriding the default Doer, which is
// automatically created using http.Client. This is useful for tests.
func WithHTTPClient(doer HttpRequestDoer) ClientOption {
	return func(c *Client) error {
		c.Client = doer
		return nil
	}
}

// WithRequestEditorFn allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
	return func(c *Client) error {
		c.RequestEditors = append(c.RequestEditors, fn)
		return nil
	}
}

// The interface specification for the client above.
type ClientInterface interface {
	// LoginWithBody request with any body
	LoginWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	Login(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Logout request
	Logout(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RegisterWithBody request with any body
	RegisterWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	Register(ctx context.Context, body RegisterJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// JoinTripByInvite request
	JoinTripByInvite(ctx context.Context, code string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetNews request
	GetNews(ctx context.Context, params *GetNewsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetNotifications request
	GetNotifications(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkAllNotificationsRead request
	MarkAllNotificationsRead(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkNotificationRead request
	MarkNotificationRead(ctx context.Context, notificationId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAllTrips request
	GetAllTrips(ctx context.Context, params *GetAllTripsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateTripWithBody request with any body
	CreateTripWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreateTrip(ctx context.Context, body CreateTripJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteTripById request
	DeleteTripById(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTripById request
	GetTripById(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateTripByIdWithBody request with any body
	UpdateTripByIdWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateTripById(ctx context.Context, tripId openapi_types.UUID, body UpdateTripByIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTripActivity request
	GetTripActivity(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateActivityWithBody request with any body
	CreateActivityWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreateActivity(ctx context.Context, tripId openapi_types.UUID, body CreateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateActivityWithBody request with any body
	UpdateActivityWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateActivity(ctx context.Context, tripId openapi_types.UUID, body UpdateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteActivityById request
	DeleteActivityById(ctx context.Context, tripId openapi_types.UUID, activityId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteInviteLink request
	DeleteInviteLink(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetInviteLink request
	GetInviteLink(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateInviteLinkWithBody request with any body
	CreateInviteLinkWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreateInviteLink(ctx context.Context, tripId openapi_types.UUID, body CreateInviteLinkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DirectInviteUserWithBody request with any body
	DirectInviteUserWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DirectInviteUser(ctx context.Context, tripId openapi_types.UUID, body DirectInviteUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTripActivityPolls request
	GetTripActivityPolls(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityPollsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateActivityPollWithBody request with any body
	CreateActivityPollWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreateActivityPoll(ctx context.Context, tripId openapi_types.UUID, body CreateActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteActivityPollById request
	DeleteActivityPollById(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetActivityPollById request
	GetActivityPollById(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// VoteOnActivityPollWithBody request with any body
	VoteOnActivityPollWithBody(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	VoteOnActivityPoll(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, body VoteOnActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTripStatusById request
	GetTripStatusById(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateTripStatusById request
	UpdateTripStatusById(ctx context.Context, tripId openapi_types.UUID, params *UpdateTripStatusByIdParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMe request
	GetMe(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateMeWithBody request with any body
	UpdateMeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateMe(ctx context.Context, body UpdateMeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTripMembers request
	GetTripMembers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetUserById request
	GetUserById(ctx context.Context, userId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) LoginWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewLoginRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) Login(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewLoginRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) Logout(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewLogoutRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) RegisterWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRegisterRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) Register(ctx context.Context, body RegisterJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRegisterRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) JoinTripByInvite(ctx context.Context, code string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewJoinTripByInviteRequest(c.Server, code)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetNews(ctx context.Context, params *GetNewsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetNewsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetNotifications(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetNotificationsRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) MarkAllNotificationsRead(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMarkAllNotificationsReadRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) MarkNotificationRead(ctx context.Context, notificationId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMarkNotificationReadRequest(c.Server, notificationId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetAllTrips(ctx context.Context, params *GetAllTripsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetAllTripsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateTripWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateTripRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateTrip(ctx context.Context, body CreateTripJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateTripRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteTripById(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteTripByIdRequest(c.Server, tripId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetTripById(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetTripByIdRequest(c.Server, tripId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateTripByIdWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTripByIdRequestWithBody(c.Server, tripId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateTripById(ctx context.Context, tripId openapi_types.UUID, body UpdateTripByIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTripByIdRequest(c.Server, tripId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetTripActivity(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetTripActivityRequest(c.Server, tripId, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateActivityWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateActivityRequestWithBody(c.Server, tripId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateActivity(ctx context.Context, tripId openapi_types.UUID, body CreateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateActivityRequest(c.Server, tripId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateActivityWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateActivityRequestWithBody(c.Server, tripId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateActivity(ctx context.Context, tripId openapi_types.UUID, body UpdateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateActivityRequest(c.Server, tripId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteActivityById(ctx context.Context, tripId openapi_types.UUID, activityId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteActivityByIdRequest(c.Server, tripId, activityId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteInviteLink(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteInviteLinkRequest(c.Server, tripId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetInviteLink(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetInviteLinkRequest(c.Server, tripId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateInviteLinkWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateInviteLinkRequestWithBody(c.Server, tripId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateInviteLink(ctx context.Context, tripId openapi_types.UUID, body CreateInviteLinkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateInviteLinkRequest(c.Server, tripId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DirectInviteUserWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDirectInviteUserRequestWithBody(c.Server, tripId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DirectInviteUser(ctx context.Context, tripId openapi_types.UUID, body DirectInviteUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDirectInviteUserRequest(c.Server, tripId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetTripActivityPolls(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityPollsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetTripActivityPollsRequest(c.Server, tripId, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateActivityPollWithBody(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateActivityPollRequestWithBody(c.Server, tripId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateActivityPoll(ctx context.Context, tripId openapi_types.UUID, body CreateActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateActivityPollRequest(c.Server, tripId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteActivityPollById(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteActivityPollByIdRequest(c.Server, tripId, pollId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetActivityPollById(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetActivityPollByIdRequest(c.Server, tripId, pollId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) VoteOnActivityPollWithBody(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewVoteOnActivityPollRequestWithBody(c.Server, tripId, pollId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) VoteOnActivityPoll(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, body VoteOnActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewVoteOnActivityPollRequest(c.Server, tripId, pollId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetTripStatusById(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetTripStatusByIdRequest(c.Server, tripId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateTripStatusById(ctx context.Context, tripId openapi_types.UUID, params *UpdateTripStatusByIdParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTripStatusByIdRequest(c.Server, tripId, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetMe(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetMeRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateMeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateMeRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateMe(ctx context.Context, body UpdateMeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateMeRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetTripMembers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetTripMembersRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetUserById(ctx context.Context, userId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetUserByIdRequest(c.Server, userId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

// NewLoginRequest calls the generic Login builder with application/json body
func NewLoginRequest(server string, body LoginJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewLoginRequestWithBody(server, "application/json", bodyReader)
}

// NewLoginRequestWithBody generates requests for Login with any type of body
func NewLoginRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/auth/login")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewLogoutRequest generates requests for Logout
func NewLogoutRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/auth/logout")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewRegisterRequest calls the generic Register builder with application/json body
func NewRegisterRequest(server string, body RegisterJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewRegisterRequestWithBody(server, "application/json", bodyReader)
}

// NewRegisterRequestWithBody generates requests for Register with any type of body
func NewRegisterRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/auth/register")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewJoinTripByInviteRequest generates requests for JoinTripByInvite
func NewJoinTripByInviteRequest(server string, code string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "code", code, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/invite/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetNewsRequest generates requests for GetNews
func NewGetNewsRequest(server string, params *GetNewsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/news")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Q != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "q", *params.Q, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetNotificationsRequest generates requests for GetNotifications
func NewGetNotificationsRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/notifications")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMarkAllNotificationsReadRequest generates requests for MarkAllNotificationsRead
func NewMarkAllNotificationsReadRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/notifications/read-all")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMarkNotificationReadRequest generates requests for MarkNotificationRead
func NewMarkNotificationReadRequest(server string, notificationId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "notificationId", notificationId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/notifications/%s/read", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetAllTripsRequest generates requests for GetAllTrips
func NewGetAllTripsRequest(server string, params *GetAllTripsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Owner != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "owner", *params.Owner, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "boolean", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Status != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "status", *params.Status, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewCreateTripRequest calls the generic CreateTrip builder with application/json body
func NewCreateTripRequest(server string, body CreateTripJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewCreateTripRequestWithBody(server, "application/json", bodyReader)
}

// NewCreateTripRequestWithBody generates requests for CreateTrip with any type of body
func NewCreateTripRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteTripByIdRequest generates requests for DeleteTripById
func NewDeleteTripByIdRequest(server string, tripId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetTripByIdRequest generates requests for GetTripById
func NewGetTripByIdRequest(server string, tripId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateTripByIdRequest calls the generic UpdateTripById builder with application/json body
func NewUpdateTripByIdRequest(server string, tripId openapi_types.UUID, body UpdateTripByIdJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateTripByIdRequestWithBody(server, tripId, "application/json", bodyReader)
}

// NewUpdateTripByIdRequestWithBody generates requests for UpdateTripById with any type of body
func NewUpdateTripByIdRequestWithBody(server string, tripId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewGetTripActivityRequest generates requests for GetTripActivity
func NewGetTripActivityRequest(server string, tripId openapi_types.UUID, params *GetTripActivityParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/activity", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.AId != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "aId", *params.AId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: "uuid"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewCreateActivityRequest calls the generic CreateActivity builder with application/json body
func NewCreateActivityRequest(server string, tripId openapi_types.UUID, body CreateActivityJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewCreateActivityRequestWithBody(server, tripId, "application/json", bodyReader)
}

// NewCreateActivityRequestWithBody generates requests for CreateActivity with any type of body
func NewCreateActivityRequestWithBody(server string, tripId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/activity", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewUpdateActivityRequest calls the generic UpdateActivity builder with application/json body
func NewUpdateActivityRequest(server string, tripId openapi_types.UUID, body UpdateActivityJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateActivityRequestWithBody(server, tripId, "application/json", bodyReader)
}

// NewUpdateActivityRequestWithBody generates requests for UpdateActivity with any type of body
func NewUpdateActivityRequestWithBody(server string, tripId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/activity", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteActivityByIdRequest generates requests for DeleteActivityById
func NewDeleteActivityByIdRequest(server string, tripId openapi_types.UUID, activityId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "activityId", activityId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/activity/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDeleteInviteLinkRequest generates requests for DeleteInviteLink
func NewDeleteInviteLinkRequest(server string, tripId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/invite", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetInviteLinkRequest generates requests for GetInviteLink
func NewGetInviteLinkRequest(server string, tripId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/invite", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewCreateInviteLinkRequest calls the generic CreateInviteLink builder with application/json body
func NewCreateInviteLinkRequest(server string, tripId openapi_types.UUID, body CreateInviteLinkJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewCreateInviteLinkRequestWithBody(server, tripId, "application/json", bodyReader)
}

// NewCreateInviteLinkRequestWithBody generates requests for CreateInviteLink with any type of body
func NewCreateInviteLinkRequestWithBody(server string, tripId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/invite", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDirectInviteUserRequest calls the generic DirectInviteUser builder with application/json body
func NewDirectInviteUserRequest(server string, tripId openapi_types.UUID, body DirectInviteUserJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDirectInviteUserRequestWithBody(server, tripId, "application/json", bodyReader)
}

// NewDirectInviteUserRequestWithBody generates requests for DirectInviteUser with any type of body
func NewDirectInviteUserRequestWithBody(server string, tripId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/invite-direct", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewGetTripActivityPollsRequest generates requests for GetTripActivityPolls
func NewGetTripActivityPollsRequest(server string, tripId openapi_types.UUID, params *GetTripActivityPollsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/polls/activity", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Status != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "status", *params.Status, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewCreateActivityPollRequest calls the generic CreateActivityPoll builder with application/json body
func NewCreateActivityPollRequest(server string, tripId openapi_types.UUID, body CreateActivityPollJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewCreateActivityPollRequestWithBody(server, tripId, "application/json", bodyReader)
}

// NewCreateActivityPollRequestWithBody generates requests for CreateActivityPoll with any type of body
func NewCreateActivityPollRequestWithBody(server string, tripId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/polls/activity", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteActivityPollByIdRequest generates requests for DeleteActivityPollById
func NewDeleteActivityPollByIdRequest(server string, tripId openapi_types.UUID, pollId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "pollId", pollId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/polls/activity/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetActivityPollByIdRequest generates requests for GetActivityPollById
func NewGetActivityPollByIdRequest(server string, tripId openapi_types.UUID, pollId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "pollId", pollId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/polls/activity/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewVoteOnActivityPollRequest calls the generic VoteOnActivityPoll builder with application/json body
func NewVoteOnActivityPollRequest(server string, tripId openapi_types.UUID, pollId openapi_types.UUID, body VoteOnActivityPollJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewVoteOnActivityPollRequestWithBody(server, tripId, pollId, "application/json", bodyReader)
}

// NewVoteOnActivityPollRequestWithBody generates requests for VoteOnActivityPoll with any type of body
func NewVoteOnActivityPollRequestWithBody(server string, tripId openapi_types.UUID, pollId openapi_types.UUID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "pollId", pollId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/polls/activity/%s/vote", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewGetTripStatusByIdRequest generates requests for GetTripStatusById
func NewGetTripStatusByIdRequest(server string, tripId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/status", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateTripStatusByIdRequest generates requests for UpdateTripStatusById
func NewUpdateTripStatusByIdRequest(server string, tripId openapi_types.UUID, params *UpdateTripStatusByIdParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "tripId", tripId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/trip/%s/status", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "status", params.Status, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetMeRequest generates requests for GetMe
func NewGetMeRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/users/me")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateMeRequest calls the generic UpdateMe builder with application/json body
func NewUpdateMeRequest(server string, body UpdateMeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateMeRequestWithBody(server, "application/json", bodyReader)
}

// NewUpdateMeRequestWithBody generates requests for UpdateMe with any type of body
func NewUpdateMeRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/users/me")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewGetTripMembersRequest generates requests for GetTripMembers
func NewGetTripMembersRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/users/trip-members")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetUserByIdRequest generates requests for GetUserById
func NewGetUserByIdRequest(server string, userId openapi_types.UUID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "userId", userId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: "uuid"})
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/users/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
	for _, r := range c.RequestEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	for _, r := range additionalEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	return nil
}

// ClientWithResponses builds on ClientInterface to offer response payloads
type ClientWithResponses struct {
	ClientInterface
}

// NewClientWithResponses creates a new ClientWithResponses, which wraps
// Client with return type handling
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
	client, err := NewClient(server, opts...)
	if err != nil {
		return nil, err
	}
	return &ClientWithResponses{client}, nil
}

// WithBaseURL overrides the baseURL.
func WithBaseURL(baseURL string) ClientOption {
	return func(c *Client) error {
		newBaseURL, err := url.Parse(baseURL)
		if err != nil {
			return err
		}
		c.Server = newBaseURL.String()
		return nil
	}
}

// ClientWithResponsesInterface is the interface specification for the client with responses above.
type ClientWithResponsesInterface interface {
	// LoginWithBodyWithResponse request with any body
	LoginWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginResponse, error)

	LoginWithResponse(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginResponse, error)

	// LogoutWithResponse request
	LogoutWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutResponse, error)

	// RegisterWithBodyWithResponse request with any body
	RegisterWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterResponse, error)

	RegisterWithResponse(ctx context.Context, body RegisterJSONRequestBody, reqEditors ...RequestEditorFn) (*RegisterResponse, error)

	// JoinTripByInviteWithResponse request
	JoinTripByInviteWithResponse(ctx context.Context, code string, reqEditors ...RequestEditorFn) (*JoinTripByInviteResponse, error)

	// GetNewsWithResponse request
	GetNewsWithResponse(ctx context.Context, params *GetNewsParams, reqEditors ...RequestEditorFn) (*GetNewsResponse, error)

	// GetNotificationsWithResponse request
	GetNotificationsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetNotificationsResponse, error)

	// MarkAllNotificationsReadWithResponse request
	MarkAllNotificationsReadWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*MarkAllNotificationsReadResponse, error)

	// MarkNotificationReadWithResponse request
	MarkNotificationReadWithResponse(ctx context.Context, notificationId openapi_types.UUID, reqEditors ...RequestEditorFn) (*MarkNotificationReadResponse, error)

	// GetAllTripsWithResponse request
	GetAllTripsWithResponse(ctx context.Context, params *GetAllTripsParams, reqEditors ...RequestEditorFn) (*GetAllTripsResponse, error)

	// CreateTripWithBodyWithResponse request with any body
	CreateTripWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateTripResponse, error)

	CreateTripWithResponse(ctx context.Context, body CreateTripJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateTripResponse, error)

	// DeleteTripByIdWithResponse request
	DeleteTripByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteTripByIdResponse, error)

	// GetTripByIdWithResponse request
	GetTripByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetTripByIdResponse, error)

	// UpdateTripByIdWithBodyWithResponse request with any body
	UpdateTripByIdWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateTripByIdResponse, error)

	UpdateTripByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, body UpdateTripByIdJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateTripByIdResponse, error)

	// GetTripActivityWithResponse request
	GetTripActivityWithResponse(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityParams, reqEditors ...RequestEditorFn) (*GetTripActivityResponse, error)

	// CreateActivityWithBodyWithResponse request with any body
	CreateActivityWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateActivityResponse, error)

	CreateActivityWithResponse(ctx context.Context, tripId openapi_types.UUID, body CreateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateActivityResponse, error)

	// UpdateActivityWithBodyWithResponse request with any body
	UpdateActivityWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateActivityResponse, error)

	UpdateActivityWithResponse(ctx context.Context, tripId openapi_types.UUID, body UpdateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateActivityResponse, error)

	// DeleteActivityByIdWithResponse request
	DeleteActivityByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, activityId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteActivityByIdResponse, error)

	// DeleteInviteLinkWithResponse request
	DeleteInviteLinkWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteInviteLinkResponse, error)

	// GetInviteLinkWithResponse request
	GetInviteLinkWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetInviteLinkResponse, error)

	// CreateInviteLinkWithBodyWithResponse request with any body
	CreateInviteLinkWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateInviteLinkResponse, error)

	CreateInviteLinkWithResponse(ctx context.Context, tripId openapi_types.UUID, body CreateInviteLinkJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateInviteLinkResponse, error)

	// DirectInviteUserWithBodyWithResponse request with any body
	DirectInviteUserWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DirectInviteUserResponse, error)

	DirectInviteUserWithResponse(ctx context.Context, tripId openapi_types.UUID, body DirectInviteUserJSONRequestBody, reqEditors ...RequestEditorFn) (*DirectInviteUserResponse, error)

	// GetTripActivityPollsWithResponse request
	GetTripActivityPollsWithResponse(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityPollsParams, reqEditors ...RequestEditorFn) (*GetTripActivityPollsResponse, error)

	// CreateActivityPollWithBodyWithResponse request with any body
	CreateActivityPollWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateActivityPollResponse, error)

	CreateActivityPollWithResponse(ctx context.Context, tripId openapi_types.UUID, body CreateActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateActivityPollResponse, error)

	// DeleteActivityPollByIdWithResponse request
	DeleteActivityPollByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteActivityPollByIdResponse, error)

	// GetActivityPollByIdWithResponse request
	GetActivityPollByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetActivityPollByIdResponse, error)

	// VoteOnActivityPollWithBodyWithResponse request with any body
	VoteOnActivityPollWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*VoteOnActivityPollResponse, error)

	VoteOnActivityPollWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, body VoteOnActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*VoteOnActivityPollResponse, error)

	// GetTripStatusByIdWithResponse request
	GetTripStatusByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetTripStatusByIdResponse, error)

	// UpdateTripStatusByIdWithResponse request
	UpdateTripStatusByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, params *UpdateTripStatusByIdParams, reqEditors ...RequestEditorFn) (*UpdateTripStatusByIdResponse, error)

	// GetMeWithResponse request
	GetMeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMeResponse, error)

	// UpdateMeWithBodyWithResponse request with any body
	UpdateMeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateMeResponse, error)

	UpdateMeWithResponse(ctx context.Context, body UpdateMeJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateMeResponse, error)

	// GetTripMembersWithResponse request
	GetTripMembersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetTripMembersResponse, error)

	// GetUserByIdWithResponse request
	GetUserByIdWithResponse(ctx context.Context, userId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetUserByIdResponse, error)
}

type LoginResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r LoginResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r LoginResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type LogoutResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r LogoutResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r LogoutResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type RegisterResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *User
	JSON400      *Error
	JSON409      *Error
}

// Status returns HTTPResponse.Status
func (r RegisterResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r RegisterResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type JoinTripByInviteResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Trip
	JSON401      *Error
	JSON404      *Error
	JSON409      *Error
}

// Status returns HTTPResponse.Status
func (r JoinTripByInviteResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r JoinTripByInviteResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetNewsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]NewsItem
	JSON500      *Error
}

// Status returns HTTPResponse.Status
func (r GetNewsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetNewsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetNotificationsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Notification
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r GetNotificationsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetNotificationsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type MarkAllNotificationsReadResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r MarkAllNotificationsReadResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r MarkAllNotificationsReadResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type MarkNotificationReadResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r MarkNotificationReadResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r MarkNotificationReadResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetAllTripsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Trip
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r GetAllTripsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetAllTripsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type CreateTripResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Trip
	JSON401      *Error
	JSON500      *Error
}

// Status returns HTTPResponse.Status
func (r CreateTripResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r CreateTripResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteTripByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r DeleteTripByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteTripByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetTripByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Trip
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r GetTripByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetTripByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateTripByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Trip
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
	JSON500      *Error
}

// Status returns HTTPResponse.Status
func (r UpdateTripByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateTripByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetTripActivityResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Activity
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r GetTripActivityResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetTripActivityResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type CreateActivityResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Activity
	JSON401      *Error
	JSON403      *Error
	JSON500      *Error
}

// Status returns HTTPResponse.Status
func (r CreateActivityResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r CreateActivityResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateActivityResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Activity
	JSON401      *Error
	JSON403      *Error
	JSON500      *Error
}

// Status returns HTTPResponse.Status
func (r UpdateActivityResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateActivityResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteActivityByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r DeleteActivityByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteActivityByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteInviteLinkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r DeleteInviteLinkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteInviteLinkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetInviteLinkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *InviteLink
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r GetInviteLinkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetInviteLinkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type CreateInviteLinkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *InviteLink
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r CreateInviteLinkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r CreateInviteLinkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DirectInviteUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *InviteCodeResponse
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
	JSON409      *Error
}

// Status returns HTTPResponse.Status
func (r DirectInviteUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DirectInviteUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetTripActivityPollsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]ActivityPoll
	JSON401      *Error
	JSON403      *Error
}

// Status returns HTTPResponse.Status
func (r GetTripActivityPollsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetTripActivityPollsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type CreateActivityPollResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *ActivityPoll
	JSON400      *Error
	JSON401      *Error
	JSON403      *Error
}

// Status returns HTTPResponse.Status
func (r CreateActivityPollResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r CreateActivityPollResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteActivityPollByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
	JSON500      *Error
}

// Status returns HTTPResponse.Status
func (r DeleteActivityPollByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteActivityPollByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetActivityPollByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActivityPoll
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r GetActivityPollByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetActivityPollByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type VoteOnActivityPollResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Message *string `json:"message,omitempty"`
	}
	JSON400 *Error
	JSON401 *Error
	JSON403 *Error
	JSON404 *Error
}

// Status returns HTTPResponse.Status
func (r VoteOnActivityPollResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r VoteOnActivityPollResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetTripStatusByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TripStatus
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r GetTripStatusByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetTripStatusByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateTripStatusByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Trip
	JSON400      *Error
	JSON401      *Error
	JSON403      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r UpdateTripStatusByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateTripStatusByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetMeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r GetMeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetMeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateMeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON400      *Error
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r UpdateMeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateMeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetTripMembersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]TripMember
	JSON401      *Error
}

// Status returns HTTPResponse.Status
func (r GetTripMembersResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetTripMembersResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetUserByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
	JSON401      *Error
	JSON404      *Error
}

// Status returns HTTPResponse.Status
func (r GetUserByIdResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetUserByIdResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// LoginWithBodyWithResponse request with arbitrary body returning *LoginResponse
func (c *ClientWithResponses) LoginWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginResponse, error) {
	rsp, err := c.LoginWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseLoginResponse(rsp)
}

func (c *ClientWithResponses) LoginWithResponse(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginResponse, error) {
	rsp, err := c.Login(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseLoginResponse(rsp)
}

// LogoutWithResponse request returning *LogoutResponse
func (c *ClientWithResponses) LogoutWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutResponse, error) {
	rsp, err := c.Logout(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseLogoutResponse(rsp)
}

// RegisterWithBodyWithResponse request with arbitrary body returning *RegisterResponse
func (c *ClientWithResponses) RegisterWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterResponse, error) {
	rsp, err := c.RegisterWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRegisterResponse(rsp)
}

func (c *ClientWithResponses) RegisterWithResponse(ctx context.Context, body RegisterJSONRequestBody, reqEditors ...RequestEditorFn) (*RegisterResponse, error) {
	rsp, err := c.Register(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRegisterResponse(rsp)
}

// JoinTripByInviteWithResponse request returning *JoinTripByInviteResponse
func (c *ClientWithResponses) JoinTripByInviteWithResponse(ctx context.Context, code string, reqEditors ...RequestEditorFn) (*JoinTripByInviteResponse, error) {
	rsp, err := c.JoinTripByInvite(ctx, code, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseJoinTripByInviteResponse(rsp)
}

// GetNewsWithResponse request returning *GetNewsResponse
func (c *ClientWithResponses) GetNewsWithResponse(ctx context.Context, params *GetNewsParams, reqEditors ...RequestEditorFn) (*GetNewsResponse, error) {
	rsp, err := c.GetNews(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetNewsResponse(rsp)
}

// GetNotificationsWithResponse request returning *GetNotificationsResponse
func (c *ClientWithResponses) GetNotificationsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetNotificationsResponse, error) {
	rsp, err := c.GetNotifications(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetNotificationsResponse(rsp)
}

// MarkAllNotificationsReadWithResponse request returning *MarkAllNotificationsReadResponse
func (c *ClientWithResponses) MarkAllNotificationsReadWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*MarkAllNotificationsReadResponse, error) {
	rsp, err := c.MarkAllNotificationsRead(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMarkAllNotificationsReadResponse(rsp)
}

// MarkNotificationReadWithResponse request returning *MarkNotificationReadResponse
func (c *ClientWithResponses) MarkNotificationReadWithResponse(ctx context.Context, notificationId openapi_types.UUID, reqEditors ...RequestEditorFn) (*MarkNotificationReadResponse, error) {
	rsp, err := c.MarkNotificationRead(ctx, notificationId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMarkNotificationReadResponse(rsp)
}

// GetAllTripsWithResponse request returning *GetAllTripsResponse
func (c *ClientWithResponses) GetAllTripsWithResponse(ctx context.Context, params *GetAllTripsParams, reqEditors ...RequestEditorFn) (*GetAllTripsResponse, error) {
	rsp, err := c.GetAllTrips(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetAllTripsResponse(rsp)
}

// CreateTripWithBodyWithResponse request with arbitrary body returning *CreateTripResponse
func (c *ClientWithResponses) CreateTripWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateTripResponse, error) {
	rsp, err := c.CreateTripWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateTripResponse(rsp)
}

func (c *ClientWithResponses) CreateTripWithResponse(ctx context.Context, body CreateTripJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateTripResponse, error) {
	rsp, err := c.CreateTrip(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateTripResponse(rsp)
}

// DeleteTripByIdWithResponse request returning *DeleteTripByIdResponse
func (c *ClientWithResponses) DeleteTripByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteTripByIdResponse, error) {
	rsp, err := c.DeleteTripById(ctx, tripId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteTripByIdResponse(rsp)
}

// GetTripByIdWithResponse request returning *GetTripByIdResponse
func (c *ClientWithResponses) GetTripByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetTripByIdResponse, error) {
	rsp, err := c.GetTripById(ctx, tripId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetTripByIdResponse(rsp)
}

// UpdateTripByIdWithBodyWithResponse request with arbitrary body returning *UpdateTripByIdResponse
func (c *ClientWithResponses) UpdateTripByIdWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateTripByIdResponse, error) {
	rsp, err := c.UpdateTripByIdWithBody(ctx, tripId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTripByIdResponse(rsp)
}

func (c *ClientWithResponses) UpdateTripByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, body UpdateTripByIdJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateTripByIdResponse, error) {
	rsp, err := c.UpdateTripById(ctx, tripId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTripByIdResponse(rsp)
}

// GetTripActivityWithResponse request returning *GetTripActivityResponse
func (c *ClientWithResponses) GetTripActivityWithResponse(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityParams, reqEditors ...RequestEditorFn) (*GetTripActivityResponse, error) {
	rsp, err := c.GetTripActivity(ctx, tripId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetTripActivityResponse(rsp)
}

// CreateActivityWithBodyWithResponse request with arbitrary body returning *CreateActivityResponse
func (c *ClientWithResponses) CreateActivityWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateActivityResponse, error) {
	rsp, err := c.CreateActivityWithBody(ctx, tripId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateActivityResponse(rsp)
}

func (c *ClientWithResponses) CreateActivityWithResponse(ctx context.Context, tripId openapi_types.UUID, body CreateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateActivityResponse, error) {
	rsp, err := c.CreateActivity(ctx, tripId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateActivityResponse(rsp)
}

// UpdateActivityWithBodyWithResponse request with arbitrary body returning *UpdateActivityResponse
func (c *ClientWithResponses) UpdateActivityWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateActivityResponse, error) {
	rsp, err := c.UpdateActivityWithBody(ctx, tripId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateActivityResponse(rsp)
}

func (c *ClientWithResponses) UpdateActivityWithResponse(ctx context.Context, tripId openapi_types.UUID, body UpdateActivityJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateActivityResponse, error) {
	rsp, err := c.UpdateActivity(ctx, tripId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateActivityResponse(rsp)
}

// DeleteActivityByIdWithResponse request returning *DeleteActivityByIdResponse
func (c *ClientWithResponses) DeleteActivityByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, activityId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteActivityByIdResponse, error) {
	rsp, err := c.DeleteActivityById(ctx, tripId, activityId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteActivityByIdResponse(rsp)
}

// DeleteInviteLinkWithResponse request returning *DeleteInviteLinkResponse
func (c *ClientWithResponses) DeleteInviteLinkWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteInviteLinkResponse, error) {
	rsp, err := c.DeleteInviteLink(ctx, tripId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteInviteLinkResponse(rsp)
}

// GetInviteLinkWithResponse request returning *GetInviteLinkResponse
func (c *ClientWithResponses) GetInviteLinkWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetInviteLinkResponse, error) {
	rsp, err := c.GetInviteLink(ctx, tripId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetInviteLinkResponse(rsp)
}

// CreateInviteLinkWithBodyWithResponse request with arbitrary body returning *CreateInviteLinkResponse
func (c *ClientWithResponses) CreateInviteLinkWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateInviteLinkResponse, error) {
	rsp, err := c.CreateInviteLinkWithBody(ctx, tripId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateInviteLinkResponse(rsp)
}

func (c *ClientWithResponses) CreateInviteLinkWithResponse(ctx context.Context, tripId openapi_types.UUID, body CreateInviteLinkJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateInviteLinkResponse, error) {
	rsp, err := c.CreateInviteLink(ctx, tripId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateInviteLinkResponse(rsp)
}

// DirectInviteUserWithBodyWithResponse request with arbitrary body returning *DirectInviteUserResponse
func (c *ClientWithResponses) DirectInviteUserWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DirectInviteUserResponse, error) {
	rsp, err := c.DirectInviteUserWithBody(ctx, tripId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDirectInviteUserResponse(rsp)
}

func (c *ClientWithResponses) DirectInviteUserWithResponse(ctx context.Context, tripId openapi_types.UUID, body DirectInviteUserJSONRequestBody, reqEditors ...RequestEditorFn) (*DirectInviteUserResponse, error) {
	rsp, err := c.DirectInviteUser(ctx, tripId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDirectInviteUserResponse(rsp)
}

// GetTripActivityPollsWithResponse request returning *GetTripActivityPollsResponse
func (c *ClientWithResponses) GetTripActivityPollsWithResponse(ctx context.Context, tripId openapi_types.UUID, params *GetTripActivityPollsParams, reqEditors ...RequestEditorFn) (*GetTripActivityPollsResponse, error) {
	rsp, err := c.GetTripActivityPolls(ctx, tripId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetTripActivityPollsResponse(rsp)
}

// CreateActivityPollWithBodyWithResponse request with arbitrary body returning *CreateActivityPollResponse
func (c *ClientWithResponses) CreateActivityPollWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateActivityPollResponse, error) {
	rsp, err := c.CreateActivityPollWithBody(ctx, tripId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateActivityPollResponse(rsp)
}

func (c *ClientWithResponses) CreateActivityPollWithResponse(ctx context.Context, tripId openapi_types.UUID, body CreateActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateActivityPollResponse, error) {
	rsp, err := c.CreateActivityPoll(ctx, tripId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateActivityPollResponse(rsp)
}

// DeleteActivityPollByIdWithResponse request returning *DeleteActivityPollByIdResponse
func (c *ClientWithResponses) DeleteActivityPollByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteActivityPollByIdResponse, error) {
	rsp, err := c.DeleteActivityPollById(ctx, tripId, pollId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteActivityPollByIdResponse(rsp)
}

// GetActivityPollByIdWithResponse request returning *GetActivityPollByIdResponse
func (c *ClientWithResponses) GetActivityPollByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetActivityPollByIdResponse, error) {
	rsp, err := c.GetActivityPollById(ctx, tripId, pollId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetActivityPollByIdResponse(rsp)
}

// VoteOnActivityPollWithBodyWithResponse request with arbitrary body returning *VoteOnActivityPollResponse
func (c *ClientWithResponses) VoteOnActivityPollWithBodyWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*VoteOnActivityPollResponse, error) {
	rsp, err := c.VoteOnActivityPollWithBody(ctx, tripId, pollId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseVoteOnActivityPollResponse(rsp)
}

func (c *ClientWithResponses) VoteOnActivityPollWithResponse(ctx context.Context, tripId openapi_types.UUID, pollId openapi_types.UUID, body VoteOnActivityPollJSONRequestBody, reqEditors ...RequestEditorFn) (*VoteOnActivityPollResponse, error) {
	rsp, err := c.VoteOnActivityPoll(ctx, tripId, pollId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseVoteOnActivityPollResponse(rsp)
}

// GetTripStatusByIdWithResponse request returning *GetTripStatusByIdResponse
func (c *ClientWithResponses) GetTripStatusByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetTripStatusByIdResponse, error) {
	rsp, err := c.GetTripStatusById(ctx, tripId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetTripStatusByIdResponse(rsp)
}

// UpdateTripStatusByIdWithResponse request returning *UpdateTripStatusByIdResponse
func (c *ClientWithResponses) UpdateTripStatusByIdWithResponse(ctx context.Context, tripId openapi_types.UUID, params *UpdateTripStatusByIdParams, reqEditors ...RequestEditorFn) (*UpdateTripStatusByIdResponse, error) {
	rsp, err := c.UpdateTripStatusById(ctx, tripId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTripStatusByIdResponse(rsp)
}

// GetMeWithResponse request returning *GetMeResponse
func (c *ClientWithResponses) GetMeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMeResponse, error) {
	rsp, err := c.GetMe(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetMeResponse(rsp)
}

// UpdateMeWithBodyWithResponse request with arbitrary body returning *UpdateMeResponse
func (c *ClientWithResponses) UpdateMeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateMeResponse, error) {
	rsp, err := c.UpdateMeWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateMeResponse(rsp)
}

func (c *ClientWithResponses) UpdateMeWithResponse(ctx context.Context, body UpdateMeJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateMeResponse, error) {
	rsp, err := c.UpdateMe(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateMeResponse(rsp)
}

// GetTripMembersWithResponse request returning *GetTripMembersResponse
func (c *ClientWithResponses) GetTripMembersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetTripMembersResponse, error) {
	rsp, err := c.GetTripMembers(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetTripMembersResponse(rsp)
}

// GetUserByIdWithResponse request returning *GetUserByIdResponse
func (c *ClientWithResponses) GetUserByIdWithResponse(ctx context.Context, userId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetUserByIdResponse, error) {
	rsp, err := c.GetUserById(ctx, userId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetUserByIdResponse(rsp)
}

// ParseLoginResponse parses an HTTP response from a LoginWithResponse call
func ParseLoginResponse(rsp *http.Response) (*LoginResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &LoginResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseLogoutResponse parses an HTTP response from a LogoutWithResponse call
func ParseLogoutResponse(rsp *http.Response) (*LogoutResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &LogoutResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseRegisterResponse parses an HTTP response from a RegisterWithResponse call
func ParseRegisterResponse(rsp *http.Response) (*RegisterResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RegisterResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON409 = &dest

	}

	return response, nil
}

// ParseJoinTripByInviteResponse parses an HTTP response from a JoinTripByInviteWithResponse call
func ParseJoinTripByInviteResponse(rsp *http.Response) (*JoinTripByInviteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &JoinTripByInviteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Trip
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON409 = &dest

	}

	return response, nil
}

// ParseGetNewsResponse parses an HTTP response from a GetNewsWithResponse call
func ParseGetNewsResponse(rsp *http.Response) (*GetNewsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetNewsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []NewsItem
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON500 = &dest

	}

	return response, nil
}

// ParseGetNotificationsResponse parses an HTTP response from a GetNotificationsWithResponse call
func ParseGetNotificationsResponse(rsp *http.Response) (*GetNotificationsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetNotificationsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Notification
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseMarkAllNotificationsReadResponse parses an HTTP response from a MarkAllNotificationsReadWithResponse call
func ParseMarkAllNotificationsReadResponse(rsp *http.Response) (*MarkAllNotificationsReadResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &MarkAllNotificationsReadResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseMarkNotificationReadResponse parses an HTTP response from a MarkNotificationReadWithResponse call
func ParseMarkNotificationReadResponse(rsp *http.Response) (*MarkNotificationReadResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &MarkNotificationReadResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetAllTripsResponse parses an HTTP response from a GetAllTripsWithResponse call
func ParseGetAllTripsResponse(rsp *http.Response) (*GetAllTripsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetAllTripsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Trip
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseCreateTripResponse parses an HTTP response from a CreateTripWithResponse call
func ParseCreateTripResponse(rsp *http.Response) (*CreateTripResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateTripResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Trip
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON500 = &dest

	}

	return response, nil
}

// ParseDeleteTripByIdResponse parses an HTTP response from a DeleteTripByIdWithResponse call
func ParseDeleteTripByIdResponse(rsp *http.Response) (*DeleteTripByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteTripByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetTripByIdResponse parses an HTTP response from a GetTripByIdWithResponse call
func ParseGetTripByIdResponse(rsp *http.Response) (*GetTripByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetTripByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Trip
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpdateTripByIdResponse parses an HTTP response from a UpdateTripByIdWithResponse call
func ParseUpdateTripByIdResponse(rsp *http.Response) (*UpdateTripByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateTripByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Trip
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON500 = &dest

	}

	return response, nil
}

// ParseGetTripActivityResponse parses an HTTP response from a GetTripActivityWithResponse call
func ParseGetTripActivityResponse(rsp *http.Response) (*GetTripActivityResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetTripActivityResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Activity
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseCreateActivityResponse parses an HTTP response from a CreateActivityWithResponse call
func ParseCreateActivityResponse(rsp *http.Response) (*CreateActivityResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateActivityResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Activity
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON500 = &dest

	}

	return response, nil
}

// ParseUpdateActivityResponse parses an HTTP response from a UpdateActivityWithResponse call
func ParseUpdateActivityResponse(rsp *http.Response) (*UpdateActivityResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateActivityResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Activity
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON500 = &dest

	}

	return response, nil
}

// ParseDeleteActivityByIdResponse parses an HTTP response from a DeleteActivityByIdWithResponse call
func ParseDeleteActivityByIdResponse(rsp *http.Response) (*DeleteActivityByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteActivityByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseDeleteInviteLinkResponse parses an HTTP response from a DeleteInviteLinkWithResponse call
func ParseDeleteInviteLinkResponse(rsp *http.Response) (*DeleteInviteLinkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteInviteLinkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetInviteLinkResponse parses an HTTP response from a GetInviteLinkWithResponse call
func ParseGetInviteLinkResponse(rsp *http.Response) (*GetInviteLinkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetInviteLinkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest InviteLink
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseCreateInviteLinkResponse parses an HTTP response from a CreateInviteLinkWithResponse call
func ParseCreateInviteLinkResponse(rsp *http.Response) (*CreateInviteLinkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateInviteLinkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest InviteLink
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseDirectInviteUserResponse parses an HTTP response from a DirectInviteUserWithResponse call
func ParseDirectInviteUserResponse(rsp *http.Response) (*DirectInviteUserResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DirectInviteUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest InviteCodeResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON409 = &dest

	}

	return response, nil
}

// ParseGetTripActivityPollsResponse parses an HTTP response from a GetTripActivityPollsWithResponse call
func ParseGetTripActivityPollsResponse(rsp *http.Response) (*GetTripActivityPollsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetTripActivityPollsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []ActivityPoll
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	}

	return response, nil
}

// ParseCreateActivityPollResponse parses an HTTP response from a CreateActivityPollWithResponse call
func ParseCreateActivityPollResponse(rsp *http.Response) (*CreateActivityPollResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateActivityPollResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest ActivityPoll
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	}

	return response, nil
}

// ParseDeleteActivityPollByIdResponse parses an HTTP response from a DeleteActivityPollByIdWithResponse call
func ParseDeleteActivityPollByIdResponse(rsp *http.Response) (*DeleteActivityPollByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteActivityPollByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON500 = &dest

	}

	return response, nil
}

// ParseGetActivityPollByIdResponse parses an HTTP response from a GetActivityPollByIdWithResponse call
func ParseGetActivityPollByIdResponse(rsp *http.Response) (*GetActivityPollByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetActivityPollByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActivityPoll
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseVoteOnActivityPollResponse parses an HTTP response from a VoteOnActivityPollWithResponse call
func ParseVoteOnActivityPollResponse(rsp *http.Response) (*VoteOnActivityPollResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &VoteOnActivityPollResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Message *string `json:"message,omitempty"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetTripStatusByIdResponse parses an HTTP response from a GetTripStatusByIdWithResponse call
func ParseGetTripStatusByIdResponse(rsp *http.Response) (*GetTripStatusByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetTripStatusByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TripStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpdateTripStatusByIdResponse parses an HTTP response from a UpdateTripStatusByIdWithResponse call
func ParseUpdateTripStatusByIdResponse(rsp *http.Response) (*UpdateTripStatusByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateTripStatusByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Trip
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON403 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetMeResponse parses an HTTP response from a GetMeWithResponse call
func ParseGetMeResponse(rsp *http.Response) (*GetMeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetMeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseUpdateMeResponse parses an HTTP response from a UpdateMeWithResponse call
func ParseUpdateMeResponse(rsp *http.Response) (*UpdateMeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateMeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseGetTripMembersResponse parses an HTTP response from a GetTripMembersWithResponse call
func ParseGetTripMembersResponse(rsp *http.Response) (*GetTripMembersResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetTripMembersResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []TripMember
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseGetUserByIdResponse parses an HTTP response from a GetUserByIdWithResponse call
func ParseGetUserByIdResponse(rsp *http.Response) (*GetUserByIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetUserByIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Login and get a session cookie
	// (POST /api/auth/login)
	Login(w http.ResponseWriter, r *http.Request)
	// Logout and invalidate the session cookie
	// (POST /api/auth/logout)
	Logout(w http.ResponseWriter, r *http.Request)
	// Register a new user
	// (POST /api/auth/register)
	Register(w http.ResponseWriter, r *http.Request)
	// Join a trip via invite link
	// (GET /api/invite/{code})
	JoinTripByInvite(w http.ResponseWriter, r *http.Request, code string)
	// Get latest news from Google News
	// (GET /api/news)
	GetNews(w http.ResponseWriter, r *http.Request, params GetNewsParams)
	// Get notifications for the current user
	// (GET /api/notifications)
	GetNotifications(w http.ResponseWriter, r *http.Request)
	// Mark all notifications as read
	// (POST /api/notifications/read-all)
	MarkAllNotificationsRead(w http.ResponseWriter, r *http.Request)
	// Mark a single notification as read
	// (PATCH /api/notifications/{notificationId}/read)
	MarkNotificationRead(w http.ResponseWriter, r *http.Request, notificationId openapi_types.UUID)
	// Get all trips for the current user
	// (GET /api/trip)
	GetAllTrips(w http.ResponseWriter, r *http.Request, params GetAllTripsParams)
	// Create a new trip
	// (POST /api/trip)
	CreateTrip(w http.ResponseWriter, r *http.Request)
	// Delete trip
	// (DELETE /api/trip/{tripId})
	DeleteTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Get trip by ID
	// (GET /api/trip/{tripId})
	GetTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Update trip
	// (PUT /api/trip/{tripId})
	UpdateTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Get a single activity by ID
	// (GET /api/trip/{tripId}/activity)
	GetTripActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params GetTripActivityParams)
	// Create activity
	// (POST /api/trip/{tripId}/activity)
	CreateActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Update activity (activity ID must be in the body)
	// (PUT /api/trip/{tripId}/activity)
	UpdateActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Delete activity by ID
	// (DELETE /api/trip/{tripId}/activity/{activityId})
	DeleteActivityById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, activityId openapi_types.UUID)
	// Delete the active invite link for a trip
	// (DELETE /api/trip/{tripId}/invite)
	DeleteInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Get active invite link for a trip
	// (GET /api/trip/{tripId}/invite)
	GetInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Create an invite link for the trip
	// (POST /api/trip/{tripId}/invite)
	CreateInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Send a direct invite to a user
	// (POST /api/trip/{tripId}/invite-direct)
	DirectInviteUser(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Get all activity polls for a trip
	// (GET /api/trip/{tripId}/polls/activity)
	GetTripActivityPolls(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params GetTripActivityPollsParams)
	// Create activity poll
	// (POST /api/trip/{tripId}/polls/activity)
	CreateActivityPoll(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Delete an activity poll
	// (DELETE /api/trip/{tripId}/polls/activity/{pollId})
	DeleteActivityPollById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID)
	// Get activity poll details
	// (GET /api/trip/{tripId}/polls/activity/{pollId})
	GetActivityPollById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID)
	// Vote for or against an activity
	// (POST /api/trip/{tripId}/polls/activity/{pollId}/vote)
	VoteOnActivityPoll(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID)
	// Get trip status
	// (GET /api/trip/{tripId}/status)
	GetTripStatusById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID)
	// Change trip status
	// (PATCH /api/trip/{tripId}/status)
	UpdateTripStatusById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params UpdateTripStatusByIdParams)
	// Get current authenticated user info
	// (GET /api/users/me)
	GetMe(w http.ResponseWriter, r *http.Request)
	// Update current authenticated user profile
	// (PATCH /api/users/me)
	UpdateMe(w http.ResponseWriter, r *http.Request)
	// Get all co-travelers from user's trips
	// (GET /api/users/trip-members)
	GetTripMembers(w http.ResponseWriter, r *http.Request)
	// Get user by ID
	// (GET /api/users/{userId})
	GetUserById(w http.ResponseWriter, r *http.Request, userId openapi_types.UUID)
}

// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.

type Unimplemented struct{}

// Login and get a session cookie
// (POST /api/auth/login)
func (_ Unimplemented) Login(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Logout and invalidate the session cookie
// (POST /api/auth/logout)
func (_ Unimplemented) Logout(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Register a new user
// (POST /api/auth/register)
func (_ Unimplemented) Register(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Join a trip via invite link
// (GET /api/invite/{code})
func (_ Unimplemented) JoinTripByInvite(w http.ResponseWriter, r *http.Request, code string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get latest news from Google News
// (GET /api/news)
func (_ Unimplemented) GetNews(w http.ResponseWriter, r *http.Request, params GetNewsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get notifications for the current user
// (GET /api/notifications)
func (_ Unimplemented) GetNotifications(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Mark all notifications as read
// (POST /api/notifications/read-all)
func (_ Unimplemented) MarkAllNotificationsRead(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Mark a single notification as read
// (PATCH /api/notifications/{notificationId}/read)
func (_ Unimplemented) MarkNotificationRead(w http.ResponseWriter, r *http.Request, notificationId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get all trips for the current user
// (GET /api/trip)
func (_ Unimplemented) GetAllTrips(w http.ResponseWriter, r *http.Request, params GetAllTripsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Create a new trip
// (POST /api/trip)
func (_ Unimplemented) CreateTrip(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete trip
// (DELETE /api/trip/{tripId})
func (_ Unimplemented) DeleteTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get trip by ID
// (GET /api/trip/{tripId})
func (_ Unimplemented) GetTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Update trip
// (PUT /api/trip/{tripId})
func (_ Unimplemented) UpdateTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get a single activity by ID
// (GET /api/trip/{tripId}/activity)
func (_ Unimplemented) GetTripActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params GetTripActivityParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Create activity
// (POST /api/trip/{tripId}/activity)
func (_ Unimplemented) CreateActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Update activity (activity ID must be in the body)
// (PUT /api/trip/{tripId}/activity)
func (_ Unimplemented) UpdateActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete activity by ID
// (DELETE /api/trip/{tripId}/activity/{activityId})
func (_ Unimplemented) DeleteActivityById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, activityId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete the active invite link for a trip
// (DELETE /api/trip/{tripId}/invite)
func (_ Unimplemented) DeleteInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get active invite link for a trip
// (GET /api/trip/{tripId}/invite)
func (_ Unimplemented) GetInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Create an invite link for the trip
// (POST /api/trip/{tripId}/invite)
func (_ Unimplemented) CreateInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Send a direct invite to a user
// (POST /api/trip/{tripId}/invite-direct)
func (_ Unimplemented) DirectInviteUser(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get all activity polls for a trip
// (GET /api/trip/{tripId}/polls/activity)
func (_ Unimplemented) GetTripActivityPolls(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params GetTripActivityPollsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Create activity poll
// (POST /api/trip/{tripId}/polls/activity)
func (_ Unimplemented) CreateActivityPoll(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete an activity poll
// (DELETE /api/trip/{tripId}/polls/activity/{pollId})
func (_ Unimplemented) DeleteActivityPollById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get activity poll details
// (GET /api/trip/{tripId}/polls/activity/{pollId})
func (_ Unimplemented) GetActivityPollById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Vote for or against an activity
// (POST /api/trip/{tripId}/polls/activity/{pollId}/vote)
func (_ Unimplemented) VoteOnActivityPoll(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get trip status
// (GET /api/trip/{tripId}/status)
func (_ Unimplemented) GetTripStatusById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Change trip status
// (PATCH /api/trip/{tripId}/status)
func (_ Unimplemented) UpdateTripStatusById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params UpdateTripStatusByIdParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get current authenticated user info
// (GET /api/users/me)
func (_ Unimplemented) GetMe(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Update current authenticated user profile
// (PATCH /api/users/me)
func (_ Unimplemented) UpdateMe(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get all co-travelers from user's trips
// (GET /api/users/trip-members)
func (_ Unimplemented) GetTripMembers(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get user by ID
// (GET /api/users/{userId})
func (_ Unimplemented) GetUserById(w http.ResponseWriter, r *http.Request, userId openapi_types.UUID) {
	w.WriteHeader(http.StatusNotImplemented)
}

// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type MiddlewareFunc func(http.Handler) http.Handler

// 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, CookieAuthScopes, []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)
}

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

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

	var err error

	// ------------- Path parameter "code" -------------
	var code string

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "q" -------------

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

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "notificationId" -------------
	var notificationId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "owner" -------------

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

	// ------------- Optional query parameter "status" -------------

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

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "aId" -------------

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	// ------------- Path parameter "activityId" -------------
	var activityId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "status" -------------

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	// ------------- Path parameter "pollId" -------------
	var pollId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	// ------------- Path parameter "pollId" -------------
	var pollId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	// ------------- Path parameter "pollId" -------------
	var pollId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "tripId" -------------
	var tripId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

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

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

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

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

	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, CookieAuthScopes, []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)
}

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "userId" -------------
	var userId openapi_types.UUID

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

	ctx := r.Context()

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

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

func (e *UnescapedCookieParamError) Error() string {
	return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
}

func (e *UnescapedCookieParamError) Unwrap() error {
	return e.Err
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

func (e *UnmarshalingParamError) Error() string {
	return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
}

func (e *UnmarshalingParamError) Unwrap() error {
	return e.Err
}

type RequiredParamError struct {
	ParamName string
}

func (e *RequiredParamError) Error() string {
	return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

func (e *RequiredHeaderError) Error() string {
	return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
}

func (e *RequiredHeaderError) Unwrap() error {
	return e.Err
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

func (e *InvalidParamFormatError) Error() string {
	return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
}

func (e *InvalidParamFormatError) Unwrap() error {
	return e.Err
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

func (e *TooManyValuesForParamError) Error() string {
	return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
}

// Handler creates http.Handler with routing matching OpenAPI spec.
func Handler(si ServerInterface) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{})
}

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{
		BaseRouter: r,
	})
}

func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{
		BaseURL:    baseURL,
		BaseRouter: r,
	})
}

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

	if r == nil {
		r = chi.NewRouter()
	}
	if options.ErrorHandlerFunc == nil {
		options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}
	wrapper := ServerInterfaceWrapper{
		Handler:            si,
		HandlerMiddlewares: options.Middlewares,
		ErrorHandlerFunc:   options.ErrorHandlerFunc,
	}

	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/auth/login", wrapper.Login)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/auth/logout", wrapper.Logout)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/auth/register", wrapper.Register)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/invite/{code}", wrapper.JoinTripByInvite)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/news", wrapper.GetNews)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/notifications", wrapper.GetNotifications)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/notifications/read-all", wrapper.MarkAllNotificationsRead)
	})
	r.Group(func(r chi.Router) {
		r.Patch(options.BaseURL+"/api/notifications/{notificationId}/read", wrapper.MarkNotificationRead)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip", wrapper.GetAllTrips)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/trip", wrapper.CreateTrip)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/api/trip/{tripId}", wrapper.DeleteTripById)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip/{tripId}", wrapper.GetTripById)
	})
	r.Group(func(r chi.Router) {
		r.Put(options.BaseURL+"/api/trip/{tripId}", wrapper.UpdateTripById)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip/{tripId}/activity", wrapper.GetTripActivity)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/trip/{tripId}/activity", wrapper.CreateActivity)
	})
	r.Group(func(r chi.Router) {
		r.Put(options.BaseURL+"/api/trip/{tripId}/activity", wrapper.UpdateActivity)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/api/trip/{tripId}/activity/{activityId}", wrapper.DeleteActivityById)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/api/trip/{tripId}/invite", wrapper.DeleteInviteLink)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip/{tripId}/invite", wrapper.GetInviteLink)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/trip/{tripId}/invite", wrapper.CreateInviteLink)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/trip/{tripId}/invite-direct", wrapper.DirectInviteUser)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip/{tripId}/polls/activity", wrapper.GetTripActivityPolls)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/trip/{tripId}/polls/activity", wrapper.CreateActivityPoll)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/api/trip/{tripId}/polls/activity/{pollId}", wrapper.DeleteActivityPollById)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip/{tripId}/polls/activity/{pollId}", wrapper.GetActivityPollById)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/api/trip/{tripId}/polls/activity/{pollId}/vote", wrapper.VoteOnActivityPoll)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/trip/{tripId}/status", wrapper.GetTripStatusById)
	})
	r.Group(func(r chi.Router) {
		r.Patch(options.BaseURL+"/api/trip/{tripId}/status", wrapper.UpdateTripStatusById)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/users/me", wrapper.GetMe)
	})
	r.Group(func(r chi.Router) {
		r.Patch(options.BaseURL+"/api/users/me", wrapper.UpdateMe)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/users/trip-members", wrapper.GetTripMembers)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/api/users/{userId}", wrapper.GetUserById)
	})

	return r
}

type LoginRequestObject struct {
	Body *LoginJSONRequestBody
}

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

type Login200ResponseHeaders struct {
	SetCookie string
}

type Login200JSONResponse struct {
	Body    User
	Headers Login200ResponseHeaders
}

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

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

type Login401JSONResponse Error

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 LogoutRequestObject struct {
}

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

type Logout204Response struct {
}

func (response Logout204Response) VisitLogoutResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type Logout401JSONResponse Error

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 RegisterRequestObject struct {
	Body *RegisterJSONRequestBody
}

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

type Register201JSONResponse User

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 Error

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 Register409JSONResponse Error

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

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

type JoinTripByInviteRequestObject struct {
	Code string `json:"code"`
}

type JoinTripByInviteResponseObject interface {
	VisitJoinTripByInviteResponse(w http.ResponseWriter) error
}

type JoinTripByInvite200JSONResponse Trip

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

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

type JoinTripByInvite401JSONResponse Error

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

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

type JoinTripByInvite404JSONResponse Error

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

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

type JoinTripByInvite409JSONResponse Error

func (response JoinTripByInvite409JSONResponse) VisitJoinTripByInviteResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(409)

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

type GetNewsRequestObject struct {
	Params GetNewsParams
}

type GetNewsResponseObject interface {
	VisitGetNewsResponse(w http.ResponseWriter) error
}

type GetNews200JSONResponse []NewsItem

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

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

type GetNews500JSONResponse Error

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

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

type GetNotificationsRequestObject struct {
}

type GetNotificationsResponseObject interface {
	VisitGetNotificationsResponse(w http.ResponseWriter) error
}

type GetNotifications200JSONResponse []Notification

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

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

type GetNotifications401JSONResponse Error

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

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

type MarkAllNotificationsReadRequestObject struct {
}

type MarkAllNotificationsReadResponseObject interface {
	VisitMarkAllNotificationsReadResponse(w http.ResponseWriter) error
}

type MarkAllNotificationsRead204Response struct {
}

func (response MarkAllNotificationsRead204Response) VisitMarkAllNotificationsReadResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type MarkAllNotificationsRead401JSONResponse Error

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

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

type MarkNotificationReadRequestObject struct {
	NotificationId openapi_types.UUID `json:"notificationId"`
}

type MarkNotificationReadResponseObject interface {
	VisitMarkNotificationReadResponse(w http.ResponseWriter) error
}

type MarkNotificationRead204Response struct {
}

func (response MarkNotificationRead204Response) VisitMarkNotificationReadResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type MarkNotificationRead401JSONResponse Error

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

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

type MarkNotificationRead404JSONResponse Error

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

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

type GetAllTripsRequestObject struct {
	Params GetAllTripsParams
}

type GetAllTripsResponseObject interface {
	VisitGetAllTripsResponse(w http.ResponseWriter) error
}

type GetAllTrips200JSONResponse []Trip

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

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

type GetAllTrips401JSONResponse Error

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

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

type CreateTripRequestObject struct {
	Body *CreateTripJSONRequestBody
}

type CreateTripResponseObject interface {
	VisitCreateTripResponse(w http.ResponseWriter) error
}

type CreateTrip201JSONResponse Trip

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

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

type CreateTrip401JSONResponse Error

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

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

type CreateTrip500JSONResponse Error

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

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

type DeleteTripByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
}

type DeleteTripByIdResponseObject interface {
	VisitDeleteTripByIdResponse(w http.ResponseWriter) error
}

type DeleteTripById204Response struct {
}

func (response DeleteTripById204Response) VisitDeleteTripByIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeleteTripById401JSONResponse Error

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

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

type DeleteTripById403JSONResponse Error

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

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

type DeleteTripById404JSONResponse Error

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

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

type GetTripByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
}

type GetTripByIdResponseObject interface {
	VisitGetTripByIdResponse(w http.ResponseWriter) error
}

type GetTripById200JSONResponse Trip

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

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

type GetTripById401JSONResponse Error

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

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

type GetTripById403JSONResponse Error

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

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

type GetTripById404JSONResponse Error

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

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

type UpdateTripByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Body   *UpdateTripByIdJSONRequestBody
}

type UpdateTripByIdResponseObject interface {
	VisitUpdateTripByIdResponse(w http.ResponseWriter) error
}

type UpdateTripById200JSONResponse Trip

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

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

type UpdateTripById401JSONResponse Error

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

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

type UpdateTripById403JSONResponse Error

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

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

type UpdateTripById404JSONResponse Error

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

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

type UpdateTripById500JSONResponse Error

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

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

type GetTripActivityRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Params GetTripActivityParams
}

type GetTripActivityResponseObject interface {
	VisitGetTripActivityResponse(w http.ResponseWriter) error
}

type GetTripActivity200JSONResponse []Activity

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

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

type GetTripActivity401JSONResponse Error

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

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

type GetTripActivity403JSONResponse Error

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

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

type GetTripActivity404JSONResponse Error

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

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

type CreateActivityRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Body   *CreateActivityJSONRequestBody
}

type CreateActivityResponseObject interface {
	VisitCreateActivityResponse(w http.ResponseWriter) error
}

type CreateActivity200JSONResponse Activity

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

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

type CreateActivity401JSONResponse Error

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

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

type CreateActivity403JSONResponse Error

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

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

type CreateActivity500JSONResponse Error

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

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

type UpdateActivityRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Body   *UpdateActivityJSONRequestBody
}

type UpdateActivityResponseObject interface {
	VisitUpdateActivityResponse(w http.ResponseWriter) error
}

type UpdateActivity200JSONResponse Activity

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

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

type UpdateActivity401JSONResponse Error

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

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

type UpdateActivity403JSONResponse Error

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

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

type UpdateActivity500JSONResponse Error

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

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

type DeleteActivityByIdRequestObject struct {
	TripId     openapi_types.UUID `json:"tripId"`
	ActivityId openapi_types.UUID `json:"activityId"`
}

type DeleteActivityByIdResponseObject interface {
	VisitDeleteActivityByIdResponse(w http.ResponseWriter) error
}

type DeleteActivityById204Response struct {
}

func (response DeleteActivityById204Response) VisitDeleteActivityByIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeleteActivityById401JSONResponse Error

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

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

type DeleteActivityById403JSONResponse Error

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

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

type DeleteActivityById404JSONResponse Error

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

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

type DeleteInviteLinkRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
}

type DeleteInviteLinkResponseObject interface {
	VisitDeleteInviteLinkResponse(w http.ResponseWriter) error
}

type DeleteInviteLink204Response struct {
}

func (response DeleteInviteLink204Response) VisitDeleteInviteLinkResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeleteInviteLink401JSONResponse Error

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

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

type DeleteInviteLink403JSONResponse Error

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

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

type DeleteInviteLink404JSONResponse Error

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

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

type GetInviteLinkRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
}

type GetInviteLinkResponseObject interface {
	VisitGetInviteLinkResponse(w http.ResponseWriter) error
}

type GetInviteLink200JSONResponse InviteLink

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

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

type GetInviteLink401JSONResponse Error

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

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

type GetInviteLink403JSONResponse Error

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

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

type GetInviteLink404JSONResponse Error

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

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

type CreateInviteLinkRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Body   *CreateInviteLinkJSONRequestBody
}

type CreateInviteLinkResponseObject interface {
	VisitCreateInviteLinkResponse(w http.ResponseWriter) error
}

type CreateInviteLink201JSONResponse InviteLink

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

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

type CreateInviteLink401JSONResponse Error

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

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

type CreateInviteLink403JSONResponse Error

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

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

type CreateInviteLink404JSONResponse Error

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

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

type DirectInviteUserRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Body   *DirectInviteUserJSONRequestBody
}

type DirectInviteUserResponseObject interface {
	VisitDirectInviteUserResponse(w http.ResponseWriter) error
}

type DirectInviteUser200JSONResponse InviteCodeResponse

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

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

type DirectInviteUser401JSONResponse Error

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

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

type DirectInviteUser403JSONResponse Error

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

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

type DirectInviteUser404JSONResponse Error

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

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

type DirectInviteUser409JSONResponse Error

func (response DirectInviteUser409JSONResponse) VisitDirectInviteUserResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(409)

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

type GetTripActivityPollsRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Params GetTripActivityPollsParams
}

type GetTripActivityPollsResponseObject interface {
	VisitGetTripActivityPollsResponse(w http.ResponseWriter) error
}

type GetTripActivityPolls200JSONResponse []ActivityPoll

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

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

type GetTripActivityPolls401JSONResponse Error

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

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

type GetTripActivityPolls403JSONResponse Error

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

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

type CreateActivityPollRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Body   *CreateActivityPollJSONRequestBody
}

type CreateActivityPollResponseObject interface {
	VisitCreateActivityPollResponse(w http.ResponseWriter) error
}

type CreateActivityPoll201JSONResponse ActivityPoll

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

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

type CreateActivityPoll400JSONResponse Error

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

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

type CreateActivityPoll401JSONResponse Error

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

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

type CreateActivityPoll403JSONResponse Error

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

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

type DeleteActivityPollByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	PollId openapi_types.UUID `json:"pollId"`
}

type DeleteActivityPollByIdResponseObject interface {
	VisitDeleteActivityPollByIdResponse(w http.ResponseWriter) error
}

type DeleteActivityPollById204Response struct {
}

func (response DeleteActivityPollById204Response) VisitDeleteActivityPollByIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeleteActivityPollById401JSONResponse Error

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

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

type DeleteActivityPollById403JSONResponse Error

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

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

type DeleteActivityPollById404JSONResponse Error

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

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

type DeleteActivityPollById500JSONResponse Error

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

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

type GetActivityPollByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	PollId openapi_types.UUID `json:"pollId"`
}

type GetActivityPollByIdResponseObject interface {
	VisitGetActivityPollByIdResponse(w http.ResponseWriter) error
}

type GetActivityPollById200JSONResponse ActivityPoll

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

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

type GetActivityPollById401JSONResponse Error

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

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

type GetActivityPollById403JSONResponse Error

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

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

type GetActivityPollById404JSONResponse Error

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

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

type VoteOnActivityPollRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	PollId openapi_types.UUID `json:"pollId"`
	Body   *VoteOnActivityPollJSONRequestBody
}

type VoteOnActivityPollResponseObject interface {
	VisitVoteOnActivityPollResponse(w http.ResponseWriter) error
}

type VoteOnActivityPoll200JSONResponse struct {
	Message *string `json:"message,omitempty"`
}

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

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

type VoteOnActivityPoll400JSONResponse Error

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

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

type VoteOnActivityPoll401JSONResponse Error

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

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

type VoteOnActivityPoll403JSONResponse Error

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

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

type VoteOnActivityPoll404JSONResponse Error

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

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

type GetTripStatusByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
}

type GetTripStatusByIdResponseObject interface {
	VisitGetTripStatusByIdResponse(w http.ResponseWriter) error
}

type GetTripStatusById200JSONResponse TripStatus

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

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

type GetTripStatusById401JSONResponse Error

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

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

type GetTripStatusById403JSONResponse Error

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

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

type GetTripStatusById404JSONResponse Error

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

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

type UpdateTripStatusByIdRequestObject struct {
	TripId openapi_types.UUID `json:"tripId"`
	Params UpdateTripStatusByIdParams
}

type UpdateTripStatusByIdResponseObject interface {
	VisitUpdateTripStatusByIdResponse(w http.ResponseWriter) error
}

type UpdateTripStatusById200JSONResponse Trip

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

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

type UpdateTripStatusById400JSONResponse Error

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

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

type UpdateTripStatusById401JSONResponse Error

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

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

type UpdateTripStatusById403JSONResponse Error

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

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

type UpdateTripStatusById404JSONResponse Error

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

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

type GetMeRequestObject struct {
}

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

type GetMe200JSONResponse User

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 Error

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 UpdateMeRequestObject struct {
	Body *UpdateMeJSONRequestBody
}

type UpdateMeResponseObject interface {
	VisitUpdateMeResponse(w http.ResponseWriter) error
}

type UpdateMe200JSONResponse User

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

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

type UpdateMe400JSONResponse Error

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

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

type UpdateMe401JSONResponse Error

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

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

type GetTripMembersRequestObject struct {
}

type GetTripMembersResponseObject interface {
	VisitGetTripMembersResponse(w http.ResponseWriter) error
}

type GetTripMembers200JSONResponse []TripMember

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

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

type GetTripMembers401JSONResponse Error

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

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

type GetUserByIdRequestObject struct {
	UserId openapi_types.UUID `json:"userId"`
}

type GetUserByIdResponseObject interface {
	VisitGetUserByIdResponse(w http.ResponseWriter) error
}

type GetUserById200JSONResponse User

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

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

type GetUserById401JSONResponse Error

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

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

type GetUserById404JSONResponse Error

func (response GetUserById404JSONResponse) VisitGetUserByIdResponse(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 {
	// Login and get a session cookie
	// (POST /api/auth/login)
	Login(ctx context.Context, request LoginRequestObject) (LoginResponseObject, error)
	// Logout and invalidate the session cookie
	// (POST /api/auth/logout)
	Logout(ctx context.Context, request LogoutRequestObject) (LogoutResponseObject, error)
	// Register a new user
	// (POST /api/auth/register)
	Register(ctx context.Context, request RegisterRequestObject) (RegisterResponseObject, error)
	// Join a trip via invite link
	// (GET /api/invite/{code})
	JoinTripByInvite(ctx context.Context, request JoinTripByInviteRequestObject) (JoinTripByInviteResponseObject, error)
	// Get latest news from Google News
	// (GET /api/news)
	GetNews(ctx context.Context, request GetNewsRequestObject) (GetNewsResponseObject, error)
	// Get notifications for the current user
	// (GET /api/notifications)
	GetNotifications(ctx context.Context, request GetNotificationsRequestObject) (GetNotificationsResponseObject, error)
	// Mark all notifications as read
	// (POST /api/notifications/read-all)
	MarkAllNotificationsRead(ctx context.Context, request MarkAllNotificationsReadRequestObject) (MarkAllNotificationsReadResponseObject, error)
	// Mark a single notification as read
	// (PATCH /api/notifications/{notificationId}/read)
	MarkNotificationRead(ctx context.Context, request MarkNotificationReadRequestObject) (MarkNotificationReadResponseObject, error)
	// Get all trips for the current user
	// (GET /api/trip)
	GetAllTrips(ctx context.Context, request GetAllTripsRequestObject) (GetAllTripsResponseObject, error)
	// Create a new trip
	// (POST /api/trip)
	CreateTrip(ctx context.Context, request CreateTripRequestObject) (CreateTripResponseObject, error)
	// Delete trip
	// (DELETE /api/trip/{tripId})
	DeleteTripById(ctx context.Context, request DeleteTripByIdRequestObject) (DeleteTripByIdResponseObject, error)
	// Get trip by ID
	// (GET /api/trip/{tripId})
	GetTripById(ctx context.Context, request GetTripByIdRequestObject) (GetTripByIdResponseObject, error)
	// Update trip
	// (PUT /api/trip/{tripId})
	UpdateTripById(ctx context.Context, request UpdateTripByIdRequestObject) (UpdateTripByIdResponseObject, error)
	// Get a single activity by ID
	// (GET /api/trip/{tripId}/activity)
	GetTripActivity(ctx context.Context, request GetTripActivityRequestObject) (GetTripActivityResponseObject, error)
	// Create activity
	// (POST /api/trip/{tripId}/activity)
	CreateActivity(ctx context.Context, request CreateActivityRequestObject) (CreateActivityResponseObject, error)
	// Update activity (activity ID must be in the body)
	// (PUT /api/trip/{tripId}/activity)
	UpdateActivity(ctx context.Context, request UpdateActivityRequestObject) (UpdateActivityResponseObject, error)
	// Delete activity by ID
	// (DELETE /api/trip/{tripId}/activity/{activityId})
	DeleteActivityById(ctx context.Context, request DeleteActivityByIdRequestObject) (DeleteActivityByIdResponseObject, error)
	// Delete the active invite link for a trip
	// (DELETE /api/trip/{tripId}/invite)
	DeleteInviteLink(ctx context.Context, request DeleteInviteLinkRequestObject) (DeleteInviteLinkResponseObject, error)
	// Get active invite link for a trip
	// (GET /api/trip/{tripId}/invite)
	GetInviteLink(ctx context.Context, request GetInviteLinkRequestObject) (GetInviteLinkResponseObject, error)
	// Create an invite link for the trip
	// (POST /api/trip/{tripId}/invite)
	CreateInviteLink(ctx context.Context, request CreateInviteLinkRequestObject) (CreateInviteLinkResponseObject, error)
	// Send a direct invite to a user
	// (POST /api/trip/{tripId}/invite-direct)
	DirectInviteUser(ctx context.Context, request DirectInviteUserRequestObject) (DirectInviteUserResponseObject, error)
	// Get all activity polls for a trip
	// (GET /api/trip/{tripId}/polls/activity)
	GetTripActivityPolls(ctx context.Context, request GetTripActivityPollsRequestObject) (GetTripActivityPollsResponseObject, error)
	// Create activity poll
	// (POST /api/trip/{tripId}/polls/activity)
	CreateActivityPoll(ctx context.Context, request CreateActivityPollRequestObject) (CreateActivityPollResponseObject, error)
	// Delete an activity poll
	// (DELETE /api/trip/{tripId}/polls/activity/{pollId})
	DeleteActivityPollById(ctx context.Context, request DeleteActivityPollByIdRequestObject) (DeleteActivityPollByIdResponseObject, error)
	// Get activity poll details
	// (GET /api/trip/{tripId}/polls/activity/{pollId})
	GetActivityPollById(ctx context.Context, request GetActivityPollByIdRequestObject) (GetActivityPollByIdResponseObject, error)
	// Vote for or against an activity
	// (POST /api/trip/{tripId}/polls/activity/{pollId}/vote)
	VoteOnActivityPoll(ctx context.Context, request VoteOnActivityPollRequestObject) (VoteOnActivityPollResponseObject, error)
	// Get trip status
	// (GET /api/trip/{tripId}/status)
	GetTripStatusById(ctx context.Context, request GetTripStatusByIdRequestObject) (GetTripStatusByIdResponseObject, error)
	// Change trip status
	// (PATCH /api/trip/{tripId}/status)
	UpdateTripStatusById(ctx context.Context, request UpdateTripStatusByIdRequestObject) (UpdateTripStatusByIdResponseObject, error)
	// Get current authenticated user info
	// (GET /api/users/me)
	GetMe(ctx context.Context, request GetMeRequestObject) (GetMeResponseObject, error)
	// Update current authenticated user profile
	// (PATCH /api/users/me)
	UpdateMe(ctx context.Context, request UpdateMeRequestObject) (UpdateMeResponseObject, error)
	// Get all co-travelers from user's trips
	// (GET /api/users/trip-members)
	GetTripMembers(ctx context.Context, request GetTripMembersRequestObject) (GetTripMembersResponseObject, error)
	// Get user by ID
	// (GET /api/users/{userId})
	GetUserById(ctx context.Context, request GetUserByIdRequestObject) (GetUserByIdResponseObject, 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
}

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

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

// JoinTripByInvite operation middleware
func (sh *strictHandler) JoinTripByInvite(w http.ResponseWriter, r *http.Request, code string) {
	var request JoinTripByInviteRequestObject

	request.Code = code

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

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

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

// GetNews operation middleware
func (sh *strictHandler) GetNews(w http.ResponseWriter, r *http.Request, params GetNewsParams) {
	var request GetNewsRequestObject

	request.Params = params

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

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

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

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

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

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

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

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

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

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

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

// MarkNotificationRead operation middleware
func (sh *strictHandler) MarkNotificationRead(w http.ResponseWriter, r *http.Request, notificationId openapi_types.UUID) {
	var request MarkNotificationReadRequestObject

	request.NotificationId = notificationId

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

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

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

// GetAllTrips operation middleware
func (sh *strictHandler) GetAllTrips(w http.ResponseWriter, r *http.Request, params GetAllTripsParams) {
	var request GetAllTripsRequestObject

	request.Params = params

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

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

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

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

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

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

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

// DeleteTripById operation middleware
func (sh *strictHandler) DeleteTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request DeleteTripByIdRequestObject

	request.TripId = tripId

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

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

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

// GetTripById operation middleware
func (sh *strictHandler) GetTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request GetTripByIdRequestObject

	request.TripId = tripId

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

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

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

// UpdateTripById operation middleware
func (sh *strictHandler) UpdateTripById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request UpdateTripByIdRequestObject

	request.TripId = tripId

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

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

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

// GetTripActivity operation middleware
func (sh *strictHandler) GetTripActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params GetTripActivityParams) {
	var request GetTripActivityRequestObject

	request.TripId = tripId
	request.Params = params

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

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

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

// CreateActivity operation middleware
func (sh *strictHandler) CreateActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request CreateActivityRequestObject

	request.TripId = tripId

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

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

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

// UpdateActivity operation middleware
func (sh *strictHandler) UpdateActivity(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request UpdateActivityRequestObject

	request.TripId = tripId

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

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

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

// DeleteActivityById operation middleware
func (sh *strictHandler) DeleteActivityById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, activityId openapi_types.UUID) {
	var request DeleteActivityByIdRequestObject

	request.TripId = tripId
	request.ActivityId = activityId

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

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

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

// DeleteInviteLink operation middleware
func (sh *strictHandler) DeleteInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request DeleteInviteLinkRequestObject

	request.TripId = tripId

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

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

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

// GetInviteLink operation middleware
func (sh *strictHandler) GetInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request GetInviteLinkRequestObject

	request.TripId = tripId

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

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

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

// CreateInviteLink operation middleware
func (sh *strictHandler) CreateInviteLink(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request CreateInviteLinkRequestObject

	request.TripId = tripId

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

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

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

// DirectInviteUser operation middleware
func (sh *strictHandler) DirectInviteUser(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request DirectInviteUserRequestObject

	request.TripId = tripId

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

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

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

// GetTripActivityPolls operation middleware
func (sh *strictHandler) GetTripActivityPolls(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params GetTripActivityPollsParams) {
	var request GetTripActivityPollsRequestObject

	request.TripId = tripId
	request.Params = params

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

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

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

// CreateActivityPoll operation middleware
func (sh *strictHandler) CreateActivityPoll(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request CreateActivityPollRequestObject

	request.TripId = tripId

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

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

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

// DeleteActivityPollById operation middleware
func (sh *strictHandler) DeleteActivityPollById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID) {
	var request DeleteActivityPollByIdRequestObject

	request.TripId = tripId
	request.PollId = pollId

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

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

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

// GetActivityPollById operation middleware
func (sh *strictHandler) GetActivityPollById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID) {
	var request GetActivityPollByIdRequestObject

	request.TripId = tripId
	request.PollId = pollId

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

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

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

// VoteOnActivityPoll operation middleware
func (sh *strictHandler) VoteOnActivityPoll(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, pollId openapi_types.UUID) {
	var request VoteOnActivityPollRequestObject

	request.TripId = tripId
	request.PollId = pollId

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

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

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

// GetTripStatusById operation middleware
func (sh *strictHandler) GetTripStatusById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID) {
	var request GetTripStatusByIdRequestObject

	request.TripId = tripId

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

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

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

// UpdateTripStatusById operation middleware
func (sh *strictHandler) UpdateTripStatusById(w http.ResponseWriter, r *http.Request, tripId openapi_types.UUID, params UpdateTripStatusByIdParams) {
	var request UpdateTripStatusByIdRequestObject

	request.TripId = tripId
	request.Params = params

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

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

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

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

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

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

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

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

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

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

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

// GetUserById operation middleware
func (sh *strictHandler) GetUserById(w http.ResponseWriter, r *http.Request, userId openapi_types.UUID) {
	var request GetUserByIdRequestObject

	request.UserId = userId

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

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

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

// Base64 encoded, gzipped, json marshaled Swagger object
var swaggerSpec = []string{

	"H4sIAAAAAAAC/+xdbW8byZH+K425AGsvKJJ68cbmYoForcTHxG+wpMUhlo5uzRTJtpvds909kglBwO5+",
	"ug8B9kuA+3I/wnDOSJDc+v7C6C/klwT9MuQM2UOObPHFu/qyK5L9WlVPVXV1dfk8CPkg5gyYkkHrPJBh",
	"HwbY/LkbKnJK1FD/HQseg1AEzC9YStJjEHUU1x+JgoH5vsvFAKugFSQJiYJaoIYxBK1AKkFYL7gYfYGF",
	"wEP9OeRSFTp2Kcdq3JMlgxMQpqUArCDqnJjlRCBDQWJFOAtaQXsPpf+fvk//cfmn9K/p+/Rt+ubyh/Rd",
	"+o/LH9Hl9+n79K/p/6Zv0reX/5W+S/+Svkfpm/Tvlz+kf0vfpj+l7y+/v/zh8k/oQCSAzvrAkOoTibDb",
	"PdJ/n2GiCOsh1QckQCZUId5FGMWcUnTKFdTRU2CRbuL6EZAIC0CMKyT7/Iwhwlz3XkKxQEqQeDwJJVKh",
	"f373Z91kiE4g5ANAp0SSEwqIMzpEuKtAmBHMpDGWEmQ9qM0nepgIASw0hIPXeBBT/ftvD58FtSDGSoHQ",
	"RPzP57sbfzw+3774lW+MCA87jhmt82BAGBkkg6C1OWpKmIKeZRWwqKPIAIrzbTW37mw0f73R3DzY3Go1",
	"m61m84/51UdYwYbp5pmeRJXEi8hObNmgm7ufTzingJn+nfIQW5k5D34loBu0gn9rjOW/4YS/8TBrd1EL",
	"GFdW6KdmkwoLNXunzXtX3akiioJ3OvvF7IVnkD3QbS/GgOMnLyFUepSsxVNOqQfY7teO4h0cRVWnywMU",
	"FwE9c7PXC+q/6NYazrZ1+lP6t/RdFYAUJvZQHl7HRIC80tYqSqxUWCWyKp010/Ztj9miIkjcqbgCrb1E",
	"J+QJU7mxcnA2DeTH6Xk9huzgHiZMzphGdrpc+H6eJ8n7IzIC03rpuZVkMBpOStCLFKB7mj8tQ6Pg2LP0",
	"AoRyA0rS6ysJoJvpwaTCicBMG6s+V0A1GQRmMuZCfyf7PI5tW676ILxz3Tfyn9/IM/g2AUuia0emD2Xp",
	"f6dvLMzSny5/TN9d/nD5vQXYu8vv0rfmv+/T/zOmqb2XA94Iiz7YXf64KtiVYeJCs+zbxHC99dw1K0xR",
	"myLxsUfoLMfa7JQoeEjYq1J+FRc/aRy+2NhuHmxtt+7ca925V9U4TOwhN0P5Sg8EiUvXOJcBLOro9fjN",
	"2+bO5LpLFJxQM0ZpblYcpYKa1Jv1qMfxpPvJYABCe2JthelwLontED7q7hEBobJyUErfRIKopoYn5s06",
	"+mb+rRBWR07Im/76Po8mdvz4yUHnd08OH+/5qGr6HMDrCRE1nqn2W7s8Yf7FTq3KUkLP/wxkzJmE6SWG",
	"bnVT66CEvfJjtmSeh66Df/yihtvvc6EQpnEfs2QAgoRIN0SKI9nXHvoZUX1EzLggjU7ICLH76/+49/XW",
	"LMflw52dudpxgU4HkR1nHr1ecnXvwcehhzkfe8KERZEA6fel6YSe3Nms373X3MqrBp6cUPAdDal190d9",
	"N7fqO/e2qvVleNJ7v88plxKSgY9yMcUhONpUokWPsFL1QPWvxclf8j7rRNzLXO3InHERFXvI7VBsq6e/",
	"kTKvR0dt52kau4bc4D6V8xjOZFvB4OoWpATZtSBOTkZG4aMt+/SCuSJdUiaHHwLeisgq3e8ApMQ9v/oT",
	"gKMSJF6Lh58dHMdCY7VdNTw/gx6RCkS5Z9orjr51p5YLEGx7IwQDTOi05P/GfayHfJCXZtvcs7MesMhG",
	"JDIvfYANzrvg/ij3vWejb4BfPwTWU/2gdadp9pN93PaMNa1Ffs/7rDjMZrN5faDOreeub9Q+V7yTiAka",
	"95WKZavRyJG5gU+xwqL+Mu4VXHZBvG5YIqa3ujdJMN9O56kdR8PxFCPm1oyAZTLjU0/a7fs453au/1kR",
	"aQPQduUjz8r8jFV1Gyfd68X60RWUhe75CLIwYZEhVVVohstSlM0W9yvIcMUNTQcXIoG7yh7uY4oZy2IC",
	"OBpm50hNfk1aCjbkEGIWAqXmbyzCPjktiT8cxtF1ntuueECb2/wq0mC3cigLxqPonf+OAI2kCWvjRPWB",
	"KW22IUL6CIRCzFBiBkHcRM+JQPyMoVjwLqFQR7uUoq4dQrvy3AyLqQlXmKh5LPgpiSDKt7IjRnXNPZ8l",
	"K65wtwfo1iCRCp0A2txGXCBOIxC380eFCjZvbKuK4z/I1NzVTVgmx5MkFVIhp0Q/wCLlwVQc+aklOzJN",
	"0OGzh4UJrtO6FOd9iH0bqmp3psVS+tRT0TvLMe5D3MWRg7NYH+aTVKnf8Iohz7DPSViIwXa59QdsGPl4",
	"npfhBpj2GfSaIUwEUcN9bfOy+AF/RWA30bI0FUUAKYnWQfwVMESkTCDSOsmQFp0SjF7sg9q4b4ZoIWmb",
	"d0zzr+r1+ov6EXvklEgsQAJTiDCEKdUqSpnANBKWErJ+pJGqWebWlLlHraAw8JgXOCZ/gGFwoXdGWJd7",
	"1NjTNtqPIRydi1CXC6TNDNoHcarpNFLuQf5rtPu0HdSCUxDSjtSsb9abxlGJgeGYBK1gu96sb9vbxL4h",
	"ZQPHpKEVemMke7G76tUcNgtoRxrazhF0W/+aR0PLCqbAXkjgOKZuyY2X0lo866jMv8XLnb4visKhRALm",
	"CxusMoveajavbW6jY8ycE2zIG7k62gcl0YsCU18gy3NtnvqAI+dPjqWruIjcoaEgc/gk3Nza/hL9u1Lx",
	"E0aHX6KnWPW/anyJHuHXG7s9+OruFzvNpucMqBe909y8NlLYgKWHFm12iimJUCgg0jTBVBagGbSeH2vl",
	"MhhgMcxkBWEWoR4ohDOQoRFGFO5JjXsD4WM9VEEOeaJmCqL+fUokdjzmiPd6Gv2JQjIJQ5Cym1BqfPel",
	"0O0xV0VnyVItTye9Nk0oYkmsHSjtYl2JYsId/MtploUGFoTfychDJQhvLhzCh8YztU6B5Xlz8Tz/xrJR",
	"Mw9sGz3xvcVP7EBHzeEGKazNziyQZkxDGDE4M258uZzZOFTjPOQRXOgl9sBzRnhmWS4RZjZhZlKQ66jd",
	"NfJtAvtEIqtXNAAYV8jd9taOmGljsmGUWdlnEh0etvdMik+kTwmKm3GUIPFnEr1w5/kXyBzO9YB2DHND",
	"Yp0J3VeASgSDyNrtIkZ+zwnT5vTrYTsLusVY4AHYS/Xn/usKSxi7n1tQ79XRkbuNOApuZ76BtrZjz8Dc",
	"fkzio5Zjf95T3iqEkL6YNgLHC7SNJl7jEbX9nDJFLzlhmiGO2qtTruYsmZ3/qFX9RDuCqMsp5WdaKh27",
	"TPTXLHRnKdZzJCKjyzp9Os2SG5alIYw+1AhyOgIjCxvEuzaTzvKvYKI0KhC2ONLOc56AY21htyhzCoPB",
	"mczpiSLUHoB6rH+fhzDAIuyjbxMQQ3QrJGpYQyb9RQxrmn6KxyQcgcw0G6Ps26Dmdb7S/zEZEH9P36Zv",
	"guuH0yiaOItDo2uaqaDiNNOe/EG3urMM09VmCgTDNDNcBUF4AApRrEAf8OFMoq7gA/SA8x4F5JiZSYP5",
	"mBOF3B3PbJkoNFwKI/LXT5WZsRa+o+ZHgbLmmDhpN/NcKVC3hD0NrRk2sMs49PqSj7B4tUtpYbhngKNK",
	"HvkupROrHmDxCiKEtXHG0dqQV+/SHPqLq82WeVWynuc/tqOLRnaVGGMV9v1Ezo/sCDyhLj3ORXGemW7G",
	"vJSB4yoMzS9yjXi5JNNe2P04EccnSkgSpnVlnkFXECflrs7KdOcupdpbm2tTtf8tEjC+kvWGbfhdjy8R",
	"P9Ou3MnQp0d8RtbcgBUM7eTV+EXt3NvT3W/VruCJZhddy7HRB86X/cRMglZZlpdzzIHZ3/FFrUTLj5MS",
	"FxQzmM56XHLUoOxwcz8fMFiV9lq9v2fJ4IIDysrBhOzkdVPjXP+3HV1YE0HB3lIWhWrPfO8O2dXsmR11",
	"8XbMLm3lNmt7OTOPQyNGgS/RXHotpCV+iZTVSm3e6gVp8aGW1ZqXJYpkSTBixZKpTaoByskQtfe85jPx",
	"COc4NWTp8nn9lno6z2XJV3S/eGysXl2vg0di5fAqvkgD5x5Gz7Iio0dYS0JqbSoukj0vPjw0asZ3ZMJm",
	"0uWZq0rHpPzztfU+Kt3YMnsXb8MQo/fsk4ZtxNB5Z8NlY2ZB1m0swMs1asV51/AIukLrtj6n37GM+/FR",
	"7vzdwGNh8LAEvoHHyl2xkRG5NfqrvTe6gndlVE54NLztB9Bsp61xnv1VKayUjbvME1fNO/B42Tdxq5/F",
	"QWjknbPZAawqTpVf5t07v4KQT6T0gxhgvV46RLaNNMH+XELGOOavh60fsSfmZqdAM/NSIwahhW9cPomz",
	"+hF7Zq6DJNpp7iDSHfeLOEj2mULwmkjly5yyu889+F6nwG57TB9HtxuwLHTqg2JRAn+ktw9ZgmBOfo34",
	"4skD/ji3qFaWdWjlVg9qZHRU3AvQLcbZhsuzuj01Vw4qE8LPeDaCaWyGlebS1Fg1rFCIpd1HSAkwUzos",
	"oRHi3S4IpLjLO0WcwQwghua6TqMQWBRzwrz4egBqHcB1fU5Hbjdl2nZSMFwU6ga2i5vah0gn+BYs/gxB",
	"E1b4ACxnsYWJGFEZUiyc8taufsTa3VyqcQ7qdglZnqPbBCmkACMsN4hEt0gEg5hrwt7WQFV9EGdEZhef",
	"ZhwisyxyHzonCw194ge+srpJS76dn60i8kbdscYm1Ba1v/k9Y/iN+liZ1c+iKazUAs/MJfa5yhuRqetU",
	"nqaYr/t0aFNfPmVY+spYLTkk46kcVQ5N825yXR5d/ULgx4V9jM/y93Zr+7JgH1iEMLI4zhSD4ghPZqrN",
	"Uwgxp1Re+arvqe617DjRxyVB+oqLLveWz9Sivbnpm3vT503LHEWHjMD6HWRD4Ko3b6bxz8Hb9BUZWLK/",
	"WZTwOVdyK3hG6h4XjmsNZuH1GEt1+wZtZTd3BmzTAKtiSRrn+vPU3UO186ptb6FeHjPNS93q7y3sdhcf",
	"ktW7zWKxNz7i0nxEQ3a2Xjld2cUJmwfY8izgXwCGmkszczcpWqtP0coDAUWgMKHyIy1Y45Rb4+V3K7/h",
	"Cp6wVbiViwXR9furZSWxFhCKKZbYKi9LO125y+NNcgVIQMhFtEQfdtdFA7TwmfiskehC1YMbPbNUk19Q",
	"NkYo9ClUH0Rtpba8Ia6qcsaVSmeFXWy84uf0WmcUgbkxomv6ZmcUXpt+tON/dT9+6bJ8cZ0XIiwfeWnv",
	"pj/mjU5zeVXqLMmQ+Td+SFbZ4+ZYuWwY3u9j1oPZSMwsSiJByIYtTFpmRR5BsIIykGv2vD97zO8pwWyq",
	"iY4pbDZU0HVTlVj4WWk9Z8Wzcs5TtZxdgeZ8VpMr2Twq4Tz6BxSNc2wygNEZoRSdjGs6H7Hdcenozz/n",
	"jA4//xxBRJRnyn9+92fb0VzuM1Nn1+1aGv8G69348zOsUn8EwSJfR+ZLZ69JAdOsBrQjuCfQtrowNu4B",
	"Okqaze0QbW7fXhuEubT2GSBzAjmNs6Im00pvI/dvDMzyjB+5ZssqauKq/n+apU1CvqEEPgUKwpUgc9Uh",
	"lSt+M5Mt5/p/LqBfxhLdsbLfZ8db22PKehq1JfklhxOpEFPyZAA9mamfyU2xcGqx5PjzY801CeI0Ew1T",
	"ft3U1W81GpSHmPa5VK27zbvNQLd1o09nLveIVFb+aq5COWYRolmJYydmZtrpR8P3c5V9cprJdbLMn+pk",
	"MkUGmOEeDIDlJnEFj0pfJvv65F7/lvY75e4f4HB9XA7BjDx9OW6c5X5Mt39sihACRL5KhK63+eSbagPH",
	"cbES1wmYoGfWsVCF6+L44l8BAAD//3v5bPl9ewAA",
}

// GetSwagger returns the content of the embedded swagger specification file
// or error if failed to decode
func decodeSpec() ([]byte, error) {
	zipped, err := base64.StdEncoding.DecodeString(strings.Join(swaggerSpec, ""))
	if err != nil {
		return nil, fmt.Errorf("error base64 decoding spec: %w", err)
	}
	zr, err := gzip.NewReader(bytes.NewReader(zipped))
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %w", err)
	}
	var buf bytes.Buffer
	_, err = buf.ReadFrom(zr)
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %w", err)
	}

	return buf.Bytes(), nil
}

var rawSpec = decodeSpecCached()

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

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

	return res
}

// GetSwagger returns the Swagger specification corresponding to the generated code
// in this file. The external references of Swagger specification are resolved.
// The logic of resolving external references is tightly connected to "import-mapping" feature.
// Externally referenced files must be embedded in the corresponding golang packages.
// Urls can be supported but this task was out of the scope.
func GetSwagger() (swagger *openapi3.T, err error) {
	resolvePath := PathToRawSpec("")

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