rest

type Client struct {
	Headers   map[string][]string
	Endpoints []*ResourceEndpoint
	Encoder   func(v interface{}) ([]byte, error)
	Decoder   func(data []byte, v interface{}) error
	Tracer    retrace.RequestTracer
}

type ClientRequest struct {
	// Resource is the path to the resource not including the scheme, domain or port
	Resource string
	// One of the six Verbs aka Methods defined for RESTful calls
	Verb string
	// Definition is useful for metrics, monitoring & tracing
	Definition ServerResource
	// Body applies to POST, PUT & PATCH
	Body interface{}
	// Headers for this request.  If a header name already exists in the client,
	// these headers will override existing on the client;
	Headers map[string][]string
	// contains filtered or unexported fields
}

type ClientResource interface {
	Get(args interface{}) *ClientRequest
	Post(args interface{}, body interface{}) *ClientRequest
	Put(args interface{}, body interface{}) *ClientRequest
	Patch(args interface{}, body interface{}) *ClientRequest
	Delete(args interface{}) *ClientRequest
	Head(args interface{}) *ClientRequest
}

type DeleteHandler interface {
	Delete(*Request, Responder)
}

type EndpointResponse struct {
	HttpResponse *http.Response
}

type FrozenCommunication struct {
	Request  *FrozenRequest  `json:"request"`
	Response *FrozenResponse `json:"response"`
}

type FrozenRequest struct {
	Headers  map[string][]string `json:"headers"`
	Verb     string              `json:"verb"`
	Resource string              `json:"resource"`
	Body     json.RawMessage     `json:"body"`

	ResourceT string        `json:"resourceT,omitempty"`
	Requestor *FrozenSender `json:"requestor,omitempty"`
}

type FrozenResponse struct {
	Headers    map[string][]string `json:"headers"`
	StatusCode string              `json:"statusCode"`
	Status     string              `json:"status"`
	Body       json.RawMessage     `json:"body"`
}

type FrozenSender struct {
	Device   string `json:"device,omitempty"`
	User     string `json:"user,omitempty"`
	Account  string `json:"account,omitempty"`
	Location string `json:"location,omitempty"`
}

type FullResource interface {
	ClientResource
	ServerResource
}

type GetHandler interface {
	Get(*Request, Responder)
}

type Handler interface {
}

type HandlerFunc func(*Request, Responder)

type HeadHandler interface {
	Head(*Request, Responder)
}

type IdIntArg struct {
	Id int `json:"id,string" url:"id"`
}

type PatchHandler interface {
	Patch(*Request, Responder)
}

type PostHandler interface {
	Post(*Request, Responder)
}

type PutHandler interface {
	Put(*Request, Responder)
}

type Request struct {
	Raw        *http.Request
	Context    *RequestContext
	Definition ServerResource
	Args       interface{} //map?
	Body       interface{}
	// contains filtered or unexported fields
}

type RequestContext struct {
	Trace retrace.Tracer
	// contains filtered or unexported fields
}

type ResourceDef struct {
	ResourceT    string // /sync/order
	ResourceArgs reflect.Type
	Verb         string   // GET POST
	Headers      []string //TODO: change to reflect.Type
	RequestBody  reflect.Type
	ResponseBody reflect.Type
	// where else would be put content type, if not here?
	RequestContentTypes  []string
	ResponseContentTypes []string
	// contains filtered or unexported fields
}

type ResourceEndpoint struct {
	Host         string `json:"host"`         // Can be host or host:port
	Scheme       string `json:"scheme"`       //http, https, websocket,
	ResourceRoot string `json:"resourceRoot"` // Root could be /api or /v1
}

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

type Responder interface {
	AddHeader(key, value string)
	SetBody(interface{})
	SetContentType(ct string)
	SetStatus(statusCode int, statusMessage string, err error)
}

type Response struct {
	Body        interface{}
	Status      int
	Message     string
	Headers     map[string]string
	ContentType string
	Error       error
}

type Sender interface {
	Send(r *ClientRequest, ctx *RequestContext) (*EndpointResponse, error)
}

type ServerResource interface {
	//the Resource template
	ResourceT() string
	ResourceArgs() interface{}
	// Methods supported
	Verb() string
	// Headers Required
	Headers() []string
	// Request returns a new instance of the request
	RequestBody() interface{}
	// Response return a new instance of the response
	ResponseBody() interface{}
	// RequestContentTypes are a list of accepted content-type for the request portion
	RequestContentTypes() []string
	// ResponseContentTypes are a list content-type that the response will be sent in
	ResponseContentTypes() []string //not sure this should be an array?
}

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