core

type CanInterface interface {
	Interface() any
}

type CanNextReader interface {
	NextReader() io.ReadCloser
}

type CanNextWriter interface {
	NextWriter() io.Writer
}

type CanString interface {
	String() string
}

type CommonOption struct {
	// when enable
	// should ignore value when value is empty
	Omitempty bool
	Explode   bool
}

type FlattenParams struct {
	Parameters []RequestParameter
}

type GroupedParameters = map[string][]Parameter

type HeaderWriter interface {
	WithHeader
	io.Writer
}

type MayValidator interface {
	NewValidator(ctx context.Context, typ typex.Type) (validator.Validator, error)
}

type Mgr interface {
	NewTransformer(context.Context, typesx.Type, Option) (Transformer, error)
	GetTransformerNames(name string) []string
}

type Option struct {
	Name   string
	MIME   string
	Strict bool
	CommonOption
}

type Parameter struct {
	In    string
	Name  string
	Field typesx.StructField
	Type  typesx.Type
	Tags  map[string]Tag
	Loc   []int
}

type ParameterValue struct {
	Parameter
	Value reflect.Value
}

type RequestParameter struct {
	Parameter
	TransformerOption Option
	Transformer       Transformer
	Validator         validator.Validator
}

type StringBuilders struct {
	// contains filtered or unexported fields
}

type StringReader struct {
	// contains filtered or unexported fields
}

type StringReaders struct {
	Readers []io.ReadCloser
	// contains filtered or unexported fields
}

type Tag string

type Transformer interface {
	// Names should include name or alias of transformer
	// prefer using some keyword about content-type
	// first must validate content-type
	Names() []string
	// New will create transformer new transformer instance by type
	// in this step will to check transformer is valid for type
	New(context.Context, typesx.Type) (Transformer, error)

	TransformerEncoder
	TransformerDecoder
}

type TransformerAndOption struct {
	Transformer
	Option Option
}

type TransformerDecoder interface {
	// DecodeFrom
	// will unmarshal data from read into some struct
	DecodeFrom(ctx context.Context, r io.ReadCloser, v any, headers ...textproto.MIMEHeader) error
}

type TransformerEncoder interface {
	// EncodeTo
	// if w implement interface { Header() http.Header }
	// Content-Type will be set
	EncodeTo(ctx context.Context, w io.Writer, v any) (err error)
}

type WithHeader interface {
	Header() http.Header
}

type WithNamedByTag interface {
	NamedByTag() string
}