Bind POST request to route
@param  String  $path
@param  \Closure  $callback
@param  Boolean $condition
@return void
486343
public function post($path, $callback, $condition = true){
        if (!$this->req_is('post')) return;
        $this->bind($path, $callback, $condition);
    }
442984
public function create($collection, Closure $callback = null)
    {
        $blueprint = $this->createBlueprint($collection);
        $blueprint->create();
        sleep(10);
        if ($callback) {
            $callback($blueprint);
        }
    }
520000
public function put( $path, callable $callback ) {
        $route = new Route( 'PUT', $path, $callback );
        $this->_routes[] = $route;
        return $route;
    }
452077
public function listen(Closure $callback)
    {
        if (isset($this->events)) {
            $this->events->listen(Events\QueryExecuted::class, $callback);
        }
    }
879745
public function delete(string $path, callable $callback, int $priority = 0)
    {
        return $this->route('delete', $path, $callback, $priority);
    }
508011
private function mapRoute(string $pattern, callable $callback)
    {
        $word = self::getPattern($pattern);

        $pattern = '/^' . str_replace('/', '\/', $word) . '$/';
        $this->routes[$pattern] = $callback;
    }
301751
public function post(string $path, callable $callback, int $priority = 0)
    {
        return $this->route('post', $path, $callback, $priority);
    }
1082402
public function nest(Closure $callback, $condition)
    {
        $topic = new static();

        $callback($topic);
        if (count($topic->conditions)) {
            $open_parenthesis = '(';
            $topic = $topic->conditions;
            $close_parenthesis = ')';

            $this->conditions[] = compact('condition', 'open_parenthesis', 'topic', 'close_parenthesis');
        }

        return $this;
    }
1082154
public function executeForEach(Closure $callback): void
    {
        $query = $this->newQuery();

        foreach ($query->cursor() as $entity) {
            $callback($entity);
        }
    }
258078
public function execute(\Closure $callback = null)
    {
        $stacks = $this->buildStacks();

        foreach ($stacks as $requests) {
            foreach ($requests as $request) {
                $status = curl_multi_add_handle($this->handle, $request->getHandle());
                if ($status !== CURLM_OK) {
                    throw new \Exception(sprintf(
                        'Unable to add request to cURL multi handle (code #%u)',
                        $status
                    ));
                }
            }

            $this->dispatch();

            foreach ($requests as $request) {
                $request->setRawResponse(curl_multi_getcontent($request->getHandle()));
                curl_multi_remove_handle($this->handle, $request->getHandle());

                if ($callback !== null) {
                    $callback($request->getResponse());
                }
            }
        }
    }
1230416
function post($path, $body, $contentType = null)
	{
		return $this->_dispatchRequest(
			$this->_buildRequest('POST', $path, $body, $contentType)
		);
	}
1211746
public function then(\Closure $callback)
    {
        if ($this->ready) {
            return null;
        }

        $this->ready = true;

        if (!$this->checkDomain() || !$this->checkPath() || !$this->checkSecurity()) {
            return null;
        }

        $oNS = parent::$prefixNS;
        $oPP = parent::$prefixPath;

        if ($this->ns) {
            parent::$prefixNS = $this->ns;
        }

        if ($this->path) {
            parent::$prefixPath = rtrim($this->currentPrefixPath, '/');
        }

        call_user_func_array($callback, $this->arguments);

        parent::$prefixNS = $oNS;
        parent::$prefixPath = $oPP;
    }
803374
public function when(string $path, $listener): void
    {
        $this->whenOn($path, RouteMatched::class, $listener);
    }
437391
public function post(string $url, $callback): Route
    {
        $route = new Route(['POST'], $url, $callback);
        $this->addRoute($route);

        return $route;
    }
786401
public function executeFor($id, Closure $callback): void
    {
        $callback(
            $this->newQuery()->findOrFail($id)
        );
    }
1312714
public function delete($path, $callback)
    {
        Argument::i()
            //argument 1 should be a string
            ->test(1, 'string')
            //argument 2 should be callable
            ->test(2, 'callable');
        
        return $this->route('delete', $path, $callback);
    }
120694
public function route($method, $path, $callback)
    {
        Argument::i()
            //argument 1 should be a string
            ->test(1, 'string')
            //argument 2 should be a string
            ->test(2, 'string')
            //argument 3 should be callable
            ->test(3, 'callable');
        
        $method = strtoupper($method);
        
        if ($method === 'ALL') {
            return $this
                ->route('get', $path, $callback)
                ->route('post', $path, $callback)
                ->route('put', $path, $callback)
                ->route('delete', $path, $callback);
        }
        
        $this->routeMiddleware[$method][] = array($path, $callback);
        
        return $this;
    }