// Post adds a POST route > handler to the router.
186005
func (f *Fibre) Post(p string, h HandlerFunc) {
	f.router.Add(POST, p, h)
}
534941
func (s *Server) Post(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodPost, path, h, opts...)
}
1166898
func Post(url string, bodyType string, body io.Reader) (resp *http.Response, err error) {
	c := New()
	return c.Post(url, bodyType, body)
}
746781
func (r *Route) Post(handlers ...Handler) *Route {
	return r.group.add("POST", r.path, handlers)
}
822567
func (this *Server) Post(path string, fn ...func(*Request, *Response, func())) {
	this.Verb("post", path, fn...)
}
1019115
func (r *Router) Post(path string, fn interface{}) *Router {
	return r.addRoute(httpMethodPost, path, fn)
}
791028
func (c *Client) Post(URI string, data interface{}, decoded interface{}) (*http.Response, error) {
	if debug {
		fmt.Printf("DEBUG: POST URI=%s\n", URI)
	}
	req, err := c.NewJSONRequest("POST", URI, data)
	if err != nil {
		return nil, err
	}
	if debug {
		fmt.Printf("DEBUG: POST req=%v decoded=%v\n", req, decoded)
	}
	resp, err := c.DoRest(req, decoded)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusCreated {
		return nil, fmt.Errorf("Unexpected http code %d on URL %v. expecting %d", resp.StatusCode, resp.Request.URL, http.StatusCreated)
	}
	return resp, err
}
793712
func (rt *Router) Post(path string, handler http.Handler) {
	rt.Handle(http.MethodPost, path, handler)
}
707504
func (r *Router) Handler(method string, path string, handler http.Handler) {
	r.Router.Handler(method, path, handler)
}
1342523
func (r *Router) Post(path string, fn http.HandlerFunc) *Router {
	return r.Method(http.MethodPost, path, fn)
}
1205364
func (m *Mux) Post(pattern PatternType, handler HandlerType) {
	m.rt.handleUntyped(pattern, mPOST, handler)
}
886579
func (c *CredentialGraphClient) Post(ctx context.Context, t *CredentialGraph) (CredentialGraph, error) {
	resp := rawGraph{}
	err := c.client.RoundTrip(ctx, "POST", "/credentialgraph", nil, t, &resp)
	if err != nil {
		return nil, err
	}

	return resp.convert()
}
1026259
func (c *HTTPClient) Post(url string, bodyType string, body io.Reader) (*http.Response, error) {
	var resp *http.Response
	breaker := c.breakerLookup(url)
	err := breaker.Call(func() error {
		aresp, err := c.Client.Post(url, bodyType, body)
		resp = aresp
		return err
	}, c.timeout)
	return resp, err
}
1212502
func (l *HostIPListener) Post(p map[string]struct{}) {
	l.mu.Lock()
	defer l.mu.Unlock()
	for id := range l.passive {
		if _, ok := p[id]; !ok {
			delete(l.passive, id)
			_, ipaddr, _ := ParseIPID(id)
			req := IPRequest{HostID: l.hostid, IPAddress: ipaddr}
			l.release(req)
		}
	}
}
860365
func Post(url string, opts Options) error {
	r, err := Request("POST", url, opts)
	if opts.Response != nil {
		*opts.Response = r
	}
	return err
}
546544
func (k *KexRouter) Post(sessID kex2.SessionID, sender kex2.DeviceID, seqno kex2.Seqno, msg []byte) (err error) {
	mctx := k.M().WithLogTag("KEXR")
	mctx.Debug("+ KexRouter.Post(%x, %x, %d, ...)", sessID, sender, seqno)
	defer func() {
		mctx.Debug("- KexRouter.Post(%x, %x, %d) -> %s", sessID, sender, seqno, ErrToOk(err))
	}()

	arg := APIArg{
		Endpoint: "kex2/send",
		Args: HTTPArgs{
			"I":      HexArg(sessID[:]),
			"sender": HexArg(sender[:]),
			"seqno":  I{Val: int(seqno)},
			"msg":    B64Arg(msg),
		},
	}
	mctx = mctx.BackgroundWithLogTags()
	kexAPITimeout(&arg, time.Second*5)
	_, err = mctx.G().API.Post(mctx, arg)

	return err
}
1159221
func (r *Router) Handler(path string, h http.Handler, ms ...Method) {
	r.Route(
		path,
		func(w http.ResponseWriter, req *Request) error {
			h.ServeHTTP(w, req.Request)
			return nil
		},
		ms...,
	)
}