codec

type Codec interface {
	// MarshalErrors marshals given errors.
	MarshalErrors(w io.Writer, errors ...*Error) error
	// UnmarshalErrors unmarshal provided errors.
	UnmarshalErrors(r io.Reader) (MultiError, error)
	// MimeType returns the mime type that this codec is defined for.
	MimeType() string
}

type Error struct {
	// ID is a unique identifier for this particular occurrence of a problem.
	ID string `json:"id,omitempty"`
	// Title is a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of the problem, except for purposes of localization.
	Title string `json:"title,omitempty"`
	// Detail is a human-readable explanation specific to this occurrence of the problem. Like title, this field’s value can be localized.
	Detail string `json:"detail,omitempty"`
	// Status is the status code applicable to this problem, expressed as a string value.
	Status string `json:"status,omitempty"`
	// Code is an application-specific error code, expressed as a string value.
	Code string `json:"code,omitempty"`
	// Meta is an object containing non-standard meta-information about the error.
	Meta Meta `json:"meta,omitempty"`
}

type FieldAnnotations struct {
	Name        string
	IsHidden    bool
	IsOmitEmpty bool
	Custom      []*mapping.FieldTag
}

type LinkOptions struct {
	// Type defines link type.
	Type LinkType
	// BaseURL should be the common base url for all the links.
	BaseURL string
	// Collection is the link root collection name.
	Collection string
	// RootID is the root collection primary value.
	RootID string
	// RelatedField is the related field name used in the relationship link type.
	RelationField string
}

type LinkType int

type MarshalOption func(o *MarshalOptions)

type MarshalOptions struct {
	Link         LinkOptions
	SingleResult bool
}

type Meta map[string]interface{}

type ModelMarshaler interface {
	// MarshalModels marshal provided models into given codec encoding type. The function should
	// simply encode only provided models without any additional payload like metadata.
	MarshalModels(models []mapping.Model, options ...MarshalOption) ([]byte, error)
	// MarshalModel marshal single models into given codec encoding type.
	MarshalModel(model mapping.Model, options ...MarshalOption) ([]byte, error)
}

type ModelUnmarshaler interface {
	// UnmarshalModels unmarshals provided data into mapping.Model slice. The data should simply be only encoded models.
	// Requires model or model struct option.
	UnmarshalModels(data []byte, options ...UnmarshalOption) ([]mapping.Model, error)
	// UnmarshalModel unmarshal single model from provided input data. Requires model or model struct option.
	UnmarshalModel(data []byte, options ...UnmarshalOption) (mapping.Model, error)
}

type MultiError []*Error

type PaginationLinks struct {
	// Self should define this page query url.
	Self string `json:"self,omitempty"`
	// First should specify the first page query url.
	First string `json:"first,omitempty"`
	// Prev specify previous page query url.
	Prev string `json:"prev,omitempty"`
	// Next specify next page query url.
	Next string `json:"next,omitempty"`
	// Last specify the last page query url.
	Last string `json:"last,omitempty"`
	// Total defines the total number of the pages.
	Total int64 `json:"total"`
}

type ParameterExtractor interface {
	ExtractParameters(c *core.Controller, q *query.Scope) (query.Parameters, error)
}

type ParameterParser interface {
	ParseParameters(c *core.Controller, q *query.Scope, parameters query.Parameters) error
}

type Payload struct {
	// Payload defined model structure.
	ModelStruct *mapping.ModelStruct
	// Data contains models data.
	Data []mapping.Model
	// FieldSets is the index based field sets that maps it's indexes with the data.
	FieldSets []mapping.FieldSet
	// Meta is an object containing non-standard meta-data information about the payload.
	Meta Meta
	// IncludedRelations is the information about included relations in the payload.
	IncludedRelations []*query.IncludedRelation
	// PaginationLinks are the links used for pagination.
	PaginationLinks *PaginationLinks
}

type PayloadMarshaler interface {
	MarshalPayload(w io.Writer, payload *Payload, options ...MarshalOption) error
}

type PayloadUnmarshaler interface {
	UnmarshalPayload(r io.Reader, options ...UnmarshalOption) (*Payload, error)
}

type UnmarshalOption func(o *UnmarshalOptions)

type UnmarshalOptions struct {
	StrictUnmarshal, ExpectSingle bool
	ModelStruct                   *mapping.ModelStruct
	Model                         mapping.Model
}