pet

type AddPet ¶

type AddPet struct {
	Context *middleware.Context
	Params  AddPetParams
	Handler AddPetHandler
}

AddPet swagger:route POST /pet pet addPet

Add a new pet to the store

func NewAddPet(ctx *middleware.Context, handler AddPetHandler) *AddPet

func (o *AddPet) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type AddPetHandler ¶

type AddPetHandler interface {
	Handle(AddPetParams, interface{}) middleware.Responder
}

AddPetHandler interface for that can handle valid add pet params

type AddPetHandlerFunc ¶

type AddPetHandlerFunc func(AddPetParams, interface{}) middleware.Responder

AddPetHandlerFunc turns a function with the right signature into a add pet handler

func (fn AddPetHandlerFunc) Handle(params AddPetParams, principal interface{}) middleware.Responder

type AddPetMethodNotAllowed ¶

type AddPetMethodNotAllowed struct {
}

AddPetMethodNotAllowed Invalid input

swagger:response addPetMethodNotAllowed

func NewAddPetMethodNotAllowed() AddPetMethodNotAllowed

func (o *AddPetMethodNotAllowed) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type AddPetParams ¶

type AddPetParams struct {
	/*Pet object that needs to be added to the store
	  Required: true
	  In: body
	*/
	Body *models.Pet
}

AddPetParams contains all the bound params for the add pet operation typically these are obtained from a http.Request

swagger:parameters addPet

func NewAddPetParams() AddPetParams

func (o *AddPetParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type DeletePet ¶

type DeletePet struct {
	Context *middleware.Context
	Params  DeletePetParams
	Handler DeletePetHandler
}

DeletePet swagger:route DELETE /pet/{petId} pet deletePet

Deletes a pet

func NewDeletePet(ctx *middleware.Context, handler DeletePetHandler) *DeletePet

func (o *DeletePet) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type DeletePetBadRequest ¶

type DeletePetBadRequest struct {
}

DeletePetBadRequest Invalid pet value

swagger:response deletePetBadRequest

func NewDeletePetBadRequest() DeletePetBadRequest

func (o *DeletePetBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type DeletePetHandler ¶

type DeletePetHandler interface {
	Handle(DeletePetParams, interface{}) middleware.Responder
}

DeletePetHandler interface for that can handle valid delete pet params

type DeletePetHandlerFunc ¶

type DeletePetHandlerFunc func(DeletePetParams, interface{}) middleware.Responder

DeletePetHandlerFunc turns a function with the right signature into a delete pet handler

func (fn DeletePetHandlerFunc) Handle(params DeletePetParams, principal interface{}) middleware.Responder

type DeletePetParams ¶

type DeletePetParams struct {
	/*
	  In: header
	*/
	APIKey string
	/*Pet id to delete
	  Required: true
	  In: path
	*/
	PetID int64
}

DeletePetParams contains all the bound params for the delete pet operation typically these are obtained from a http.Request

swagger:parameters deletePet

func NewDeletePetParams() DeletePetParams

func (o *DeletePetParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type FindPetsByStatus ¶

type FindPetsByStatus struct {
	Context *middleware.Context
	Params  FindPetsByStatusParams
	Handler FindPetsByStatusHandler
}

FindPetsByStatus swagger:route GET /pet/findByStatus pet findPetsByStatus

Finds Pets by status ¶

Multiple status values can be provided with comma seperated strings

func NewFindPetsByStatus(ctx *middleware.Context, handler FindPetsByStatusHandler) *FindPetsByStatus

func (o *FindPetsByStatus) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type FindPetsByStatusBadRequest ¶

type FindPetsByStatusBadRequest struct {
}

FindPetsByStatusBadRequest Invalid status value

swagger:response findPetsByStatusBadRequest

func NewFindPetsByStatusBadRequest() FindPetsByStatusBadRequest

func (o *FindPetsByStatusBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type FindPetsByStatusHandler ¶

type FindPetsByStatusHandler interface {
	Handle(FindPetsByStatusParams, interface{}) middleware.Responder
}

FindPetsByStatusHandler interface for that can handle valid find pets by status params

type FindPetsByStatusHandlerFunc ¶

type FindPetsByStatusHandlerFunc func(FindPetsByStatusParams, interface{}) middleware.Responder

FindPetsByStatusHandlerFunc turns a function with the right signature into a find pets by status handler

func (fn FindPetsByStatusHandlerFunc) Handle(params FindPetsByStatusParams, principal interface{}) middleware.Responder

type FindPetsByStatusOK ¶

type FindPetsByStatusOK struct {

	// In: body
	Payload []*models.Pet `json:"body,omitempty"`
}

FindPetsByStatusOK successful operation

swagger:response findPetsByStatusOK

func NewFindPetsByStatusOK() FindPetsByStatusOK

func (o *FindPetsByStatusOK) WithPayload(payload []*models.Pet) *FindPetsByStatusOK

func (o *FindPetsByStatusOK) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type FindPetsByStatusParams ¶

type FindPetsByStatusParams struct {
	/*Status values that need to be considered for filter
	  Required: true
	  In: query
	  Collection Format: csv
	*/
	Status []string
}

FindPetsByStatusParams contains all the bound params for the find pets by status operation typically these are obtained from a http.Request

swagger:parameters findPetsByStatus

func NewFindPetsByStatusParams() FindPetsByStatusParams

func (o *FindPetsByStatusParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type FindPetsByTags ¶

type FindPetsByTags struct {
	Context *middleware.Context
	Params  FindPetsByTagsParams
	Handler FindPetsByTagsHandler
}

FindPetsByTags swagger:route GET /pet/findByTags pet findPetsByTags

Finds Pets by tags ¶

Muliple tags can be provided with comma seperated strings. Use tag1, tag2, tag3 for testing.

func NewFindPetsByTags(ctx *middleware.Context, handler FindPetsByTagsHandler) *FindPetsByTags

func (o *FindPetsByTags) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type FindPetsByTagsBadRequest ¶

type FindPetsByTagsBadRequest struct {
}

FindPetsByTagsBadRequest Invalid tag value

swagger:response findPetsByTagsBadRequest

func NewFindPetsByTagsBadRequest() FindPetsByTagsBadRequest

func (o *FindPetsByTagsBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type FindPetsByTagsHandler ¶

type FindPetsByTagsHandler interface {
	Handle(FindPetsByTagsParams, interface{}) middleware.Responder
}

FindPetsByTagsHandler interface for that can handle valid find pets by tags params

type FindPetsByTagsHandlerFunc ¶

type FindPetsByTagsHandlerFunc func(FindPetsByTagsParams, interface{}) middleware.Responder

FindPetsByTagsHandlerFunc turns a function with the right signature into a find pets by tags handler

func (fn FindPetsByTagsHandlerFunc) Handle(params FindPetsByTagsParams, principal interface{}) middleware.Responder

type FindPetsByTagsOK ¶

type FindPetsByTagsOK struct {

	// In: body
	Payload []*models.Pet `json:"body,omitempty"`
}

FindPetsByTagsOK successful operation

swagger:response findPetsByTagsOK

func NewFindPetsByTagsOK() FindPetsByTagsOK

func (o *FindPetsByTagsOK) WithPayload(payload []*models.Pet) *FindPetsByTagsOK

func (o *FindPetsByTagsOK) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type FindPetsByTagsParams ¶

type FindPetsByTagsParams struct {
	/*Tags to filter by
	  Required: true
	  In: query
	  Collection Format: csv
	*/
	Tags []string
}

FindPetsByTagsParams contains all the bound params for the find pets by tags operation typically these are obtained from a http.Request

swagger:parameters findPetsByTags

func NewFindPetsByTagsParams() FindPetsByTagsParams

func (o *FindPetsByTagsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type GetPetByID ¶

type GetPetByID struct {
	Context *middleware.Context
	Params  GetPetByIDParams
	Handler GetPetByIDHandler
}

GetPetByID swagger:route GET /pet/{petId} pet getPetById

Find pet by ID ¶

Returns a single pet

func NewGetPetByID(ctx *middleware.Context, handler GetPetByIDHandler) *GetPetByID

func (o *GetPetByID) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type GetPetByIDBadRequest ¶

type GetPetByIDBadRequest struct {
}

GetPetByIDBadRequest Invalid ID supplied

swagger:response getPetByIdBadRequest

func NewGetPetByIDBadRequest() GetPetByIDBadRequest

func (o *GetPetByIDBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type GetPetByIDHandler ¶

type GetPetByIDHandler interface {
	Handle(GetPetByIDParams, interface{}) middleware.Responder
}

GetPetByIDHandler interface for that can handle valid get pet by id params

type GetPetByIDHandlerFunc ¶

type GetPetByIDHandlerFunc func(GetPetByIDParams, interface{}) middleware.Responder

GetPetByIDHandlerFunc turns a function with the right signature into a get pet by id handler

func (fn GetPetByIDHandlerFunc) Handle(params GetPetByIDParams, principal interface{}) middleware.Responder

type GetPetByIDNotFound ¶

type GetPetByIDNotFound struct {
}

GetPetByIDNotFound Pet not found

swagger:response getPetByIdNotFound

func NewGetPetByIDNotFound() GetPetByIDNotFound

func (o *GetPetByIDNotFound) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type GetPetByIDOK ¶

type GetPetByIDOK struct {

	// In: body
	Payload *models.Pet `json:"body,omitempty"`
}

GetPetByIDOK successful operation

swagger:response getPetByIdOK

func NewGetPetByIDOK() GetPetByIDOK

func (o *GetPetByIDOK) WithPayload(payload *models.Pet) *GetPetByIDOK

func (o *GetPetByIDOK) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type GetPetByIDParams ¶

type GetPetByIDParams struct {
	/*ID of pet to return
	  Required: true
	  In: path
	*/
	PetID int64
}

GetPetByIDParams contains all the bound params for the get pet by id operation typically these are obtained from a http.Request

swagger:parameters getPetById

func NewGetPetByIDParams() GetPetByIDParams

func (o *GetPetByIDParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type UpdatePet ¶

type UpdatePet struct {
	Context *middleware.Context
	Params  UpdatePetParams
	Handler UpdatePetHandler
}

UpdatePet swagger:route PUT /pet pet updatePet

Update an existing pet

func NewUpdatePet(ctx *middleware.Context, handler UpdatePetHandler) *UpdatePet

func (o *UpdatePet) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type UpdatePetBadRequest ¶

type UpdatePetBadRequest struct {
}

UpdatePetBadRequest Invalid ID supplied

swagger:response updatePetBadRequest

func NewUpdatePetBadRequest() UpdatePetBadRequest

func (o *UpdatePetBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type UpdatePetHandler ¶

type UpdatePetHandler interface {
	Handle(UpdatePetParams, interface{}) middleware.Responder
}

UpdatePetHandler interface for that can handle valid update pet params

type UpdatePetHandlerFunc ¶

type UpdatePetHandlerFunc func(UpdatePetParams, interface{}) middleware.Responder

UpdatePetHandlerFunc turns a function with the right signature into a update pet handler

func (fn UpdatePetHandlerFunc) Handle(params UpdatePetParams, principal interface{}) middleware.Responder

type UpdatePetMethodNotAllowed ¶

type UpdatePetMethodNotAllowed struct {
}

UpdatePetMethodNotAllowed Validation exception

swagger:response updatePetMethodNotAllowed

func NewUpdatePetMethodNotAllowed() UpdatePetMethodNotAllowed

func (o *UpdatePetMethodNotAllowed) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type UpdatePetNotFound ¶

type UpdatePetNotFound struct {
}

UpdatePetNotFound Pet not found

swagger:response updatePetNotFound

func NewUpdatePetNotFound() UpdatePetNotFound

func (o *UpdatePetNotFound) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type UpdatePetParams ¶

type UpdatePetParams struct {
	/*Pet object that needs to be added to the store
	  Required: true
	  In: body
	*/
	Body *models.Pet
}

UpdatePetParams contains all the bound params for the update pet operation typically these are obtained from a http.Request

swagger:parameters updatePet

func NewUpdatePetParams() UpdatePetParams

func (o *UpdatePetParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type UpdatePetWithForm ¶

type UpdatePetWithForm struct {
	Context *middleware.Context
	Params  UpdatePetWithFormParams
	Handler UpdatePetWithFormHandler
}

UpdatePetWithForm swagger:route POST /pet/{petId} pet updatePetWithForm

Updates a pet in the store with form data

func NewUpdatePetWithForm(ctx *middleware.Context, handler UpdatePetWithFormHandler) *UpdatePetWithForm

func (o *UpdatePetWithForm) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type UpdatePetWithFormHandler ¶

type UpdatePetWithFormHandler interface {
	Handle(UpdatePetWithFormParams, interface{}) middleware.Responder
}

UpdatePetWithFormHandler interface for that can handle valid update pet with form params

type UpdatePetWithFormHandlerFunc ¶

type UpdatePetWithFormHandlerFunc func(UpdatePetWithFormParams, interface{}) middleware.Responder

UpdatePetWithFormHandlerFunc turns a function with the right signature into a update pet with form handler

func (fn UpdatePetWithFormHandlerFunc) Handle(params UpdatePetWithFormParams, principal interface{}) middleware.Responder

type UpdatePetWithFormMethodNotAllowed ¶

type UpdatePetWithFormMethodNotAllowed struct {
}

UpdatePetWithFormMethodNotAllowed Invalid input

swagger:response updatePetWithFormMethodNotAllowed

func NewUpdatePetWithFormMethodNotAllowed() UpdatePetWithFormMethodNotAllowed

func (o *UpdatePetWithFormMethodNotAllowed) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type UpdatePetWithFormParams ¶

type UpdatePetWithFormParams struct {
	/*Updated name of the pet
	  In: formData
	*/
	Name string
	/*ID of pet that needs to be updated
	  Required: true
	  In: path
	*/
	PetID int64
	/*Updated status of the pet
	  In: formData
	*/
	Status string
}

UpdatePetWithFormParams contains all the bound params for the update pet with form operation typically these are obtained from a http.Request

swagger:parameters updatePetWithForm

func NewUpdatePetWithFormParams() UpdatePetWithFormParams

func (o *UpdatePetWithFormParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

type UploadFile ¶ added in v0.2.0

type UploadFile struct {
	Context *middleware.Context
	Params  UploadFileParams
	Handler UploadFileHandler
}

UploadFile swagger:route POST /pet/{petId}/uploadImage pet uploadFile

uploads an image

func NewUploadFile(ctx *middleware.Context, handler UploadFileHandler) *UploadFile

func (o *UploadFile) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type UploadFileHandler ¶ added in v0.2.0

type UploadFileHandler interface {
	Handle(UploadFileParams, interface{}) middleware.Responder
}

UploadFileHandler interface for that can handle valid upload file params

type UploadFileHandlerFunc ¶ added in v0.2.0

type UploadFileHandlerFunc func(UploadFileParams, interface{}) middleware.Responder

UploadFileHandlerFunc turns a function with the right signature into a upload file handler

func (fn UploadFileHandlerFunc) Handle(params UploadFileParams, principal interface{}) middleware.Responder

type UploadFileOK ¶ added in v0.2.0

type UploadFileOK struct {

	// In: body
	Payload *models.APIResponse `json:"body,omitempty"`
}

UploadFileOK successful operation

swagger:response uploadFileOK

func NewUploadFileOK() UploadFileOK

func (o *UploadFileOK) WithPayload(payload *models.APIResponse) *UploadFileOK

func (o *UploadFileOK) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

type UploadFileParams ¶ added in v0.2.0

type UploadFileParams struct {
	/*Additional data to pass to server
	  In: formData
	*/
	AdditionalMetadata string
	/*file to upload
	  In: formData
	*/
	File httpkit.File
	/*ID of pet to update
	  Required: true
	  In: path
	*/
	PetID int64
}

UploadFileParams contains all the bound params for the upload file operation typically these are obtained from a http.Request

swagger:parameters uploadFile

func NewUploadFileParams() UploadFileParams

func (o *UploadFileParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error