diff --git a/src/IncomingRequestInterface.php b/src/IncomingRequestInterface.php
deleted file mode 100644
index 76f8c03..0000000
--- a/src/IncomingRequestInterface.php
+++ /dev/null
@@ -1,171 +0,0 @@
-<?php
-
-namespace Psr\Http\Message;
-
-/**
- * Representation of an incoming, server-side HTTP request.
- *
- * Per the HTTP specification, this interface includes accessors for
- * the following:
- *
- * - Protocol version
- * - HTTP method
- * - URL
- * - Headers
- * - Message body
- *
- * Additionally, it encapsulates all data as it has arrived to the 
- * application from the PHP environment, including:
- *
- * - The values represented in $_SERVER.
- * - Any cookies provided (generally via $_COOKIE)
- * - Query string arguments (generally via $_GET, or as parsed via parse_str())
- * - Upload files, if any (as represented by $_FILES)
- * - Deserialized body parameters (generally from $_POST)
- *
- * The above values MUST be immutable, in order to ensure that all consumers of
- * the request instance within a given request cycle receive the same information.
- *
- * Additionally, this interface recognizes the utility of introspecting a
- * request to derive and match additional parameters (e.g., via URI path 
- * matching, decrypting cookie values, deserializing non-form-encoded body
- * content, matching authorization headers to users, etc). These parameters
- * are stored in an "attributes" property, which MUST be mutable.
- */
-interface IncomingRequestInterface extends MessageInterface
-{
-    /**
-     * Retrieves the HTTP method of the request.
-     *
-     * @return string Returns the request method.
-     */
-    public function getMethod();
-
-    /**
-     * Retrieves the request URL.
-     *
-     * @link http://tools.ietf.org/html/rfc3986#section-4.3
-     * @return string Returns the URL as a string. The URL SHOULD be an absolute
-     *     URI as specified in RFC 3986, but MAY be a relative URI.
-     */
-    public function getUrl();
-
-    /**
-     * Retrieve server parameters.
-     *
-     * Retrieves data related to the incoming request environment, 
-     * typically derived from PHP's $_SERVER superglobal. The data IS NOT 
-     * REQUIRED to originate from $_SERVER.
-     * 
-     * @return array
-     */
-    public function getServerParams();
-
-    /**
-     * Retrieve cookies.
-     *
-     * Retrieves cookies sent by the client to the server.
-     *
-     * The assumption is these are injected during instantiation, typically
-     * from PHP's $_COOKIE superglobal. The data IS NOT REQUIRED to come from
-     * $_COOKIE, but MUST be compatible with the structure of $_COOKIE.
-     *
-     * @return array
-     */
-    public function getCookieParams();
-
-    /**
-     * Retrieve query string arguments.
-     *
-     * Retrieves the deserialized query string arguments, if any.
-     *
-     * These values SHOULD remain immutable over the course of the incoming
-     * request. They MAY be injected during instantiation, such as from PHP's
-     * $_GET superglobal, or MAY be derived from some other value such as the
-     * URI. In cases where the arguments are parsed from the URI, the data
-     * MUST be compatible with what PHP's `parse_str()` would return for
-     * purposes of how duplicate query parameters are handled, and how nested
-     * sets are handled.
-     *
-     * @return array
-     */
-    public function getQueryParams();
-
-    /**
-     * Retrieve the upload file metadata.
-     *
-     * This method MUST return file upload metadata in the same structure
-     * as PHP's $_FILES superglobal.
-     *
-     * These values SHOULD remain immutable over the course of the incoming
-     * request. They MAY be injected during instantiation, such as from PHP's
-     * $_FILES superglobal, or MAY be derived from other sources.
-     *
-     * @return array Upload file(s) metadata, if any.
-     */
-    public function getFileParams();
-
-    /**
-     * Retrieve any parameters provided in the request body.
-     *
-     * If the request body can be deserialized to an array, this method MAY be
-     * used to retrieve them. These MAY be injected during instantiation from
-     * PHP's $_POST superglobal. The data IS NOT REQUIRED to come from $_POST,
-     * but MUST be an array.
-     *
-     * @return array The deserialized body parameters, if any.
-     */
-    public function getBodyParams();
-
-    /**
-     * Retrieve attributes derived from the request.
-     *
-     * The request "attributes" may be used to allow injection of any
-     * parameters derived from the request: e.g., the results of path
-     * match operations; the results of decrypting cookies; the results of
-     * deserializing non-form-encoded message bodies; etc. Attributes
-     * will be application and request specific, and CAN be mutable.
-     *
-     * @return array Attributes derived from the request.
-     */
-    public function getAttributes();
-
-    /**
-     * Retrieve a single derived request attribute.
-     * 
-     * Retrieves a single derived request attribute as described in
-     * getAttributes(). If the attribute has not been previously set, returns
-     * the default value as provided.
-     * 
-     * @see getAttributes()
-     * @param string $attribute Attribute name.
-     * @param mixed $default Default value to return if the attribute does not exist.
-     * @return mixed
-     */
-    public function getAttribute($attribute, $default = null);
-
-    /**
-     * Set attributes derived from the request.
-     *
-     * This method allows setting request attributes, as described in
-     * getAttributes().
-     *
-     * @see getAttributes()
-     * @param array $attributes Attributes derived from the request.
-     * @return void
-     */
-    public function setAttributes(array $attributes);
-
-    /**
-     * Set a single derived request attribute.
-     * 
-     * This method allows setting a single derived request attribute as
-     * described in getAttributes().
-     *
-     * @see getAttributes()
-     * @param string $attribute The attribute name.
-     * @param mixed $value The value of the attribute.
-     * @return void
-     */
-    public function setAttribute($attribute, $value);
-}
diff --git a/src/IncomingResponseInterface.php b/src/IncomingResponseInterface.php
deleted file mode 100644
index 9463351..0000000
--- a/src/IncomingResponseInterface.php
+++ /dev/null
@@ -1,45 +0,0 @@
-<?php
-
-namespace Psr\Http\Message;
-
-/**
- * Representation of an incoming, client-side response.
- * 
- * Per the HTTP specification, this interface includes accessors for
- * the following:
- *
- * - Protocol version
- * - Status code and reason phrase
- * - Headers
- * - Message body
- *
- * As the response is the result of making a request, it is considered
- * immutable.
- */
-interface IncomingResponseInterface extends MessageInterface
-{
-    /**
-     * Gets the response Status-Code.
-     *
-     * The Status-Code is a 3-digit integer result code of the server's attempt
-     * to understand and satisfy the request.
-     *
-     * @return integer Status code.
-     */
-    public function getStatusCode();
-
-    /**
-     * Gets the response Reason-Phrase, a short textual description of the Status-Code.
-     *
-     * Because a Reason-Phrase is not a required element in a response
-     * Status-Line, the Reason-Phrase value MAY be null. Implementations MAY
-     * choose to return the default RFC 7231 recommended reason phrase (or those
-     * listed in the IANA HTTP Status Code Registry) for the response's
-     * Status-Code.
-     *
-     * @link http://tools.ietf.org/html/rfc7231#section-6
-     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-     * @return string|null Reason phrase, or null if unknown.
-     */
-    public function getReasonPhrase();
-}
diff --git a/src/MessageInterface.php b/src/MessageInterface.php
index a744853..23360b7 100644
--- a/src/MessageInterface.php
+++ b/src/MessageInterface.php
@@ -7,13 +7,17 @@
  * from a server to a client. This interface defines the methods common to
  * each.
  *
+ * Messages are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return a new instance that contains the changed state.
+ *
  * @link http://www.ietf.org/rfc/rfc7230.txt
  * @link http://www.ietf.org/rfc/rfc7231.txt
  */
 interface MessageInterface
 {
     /**
-     * Gets the HTTP protocol version as a string.
+     * Retrieves the HTTP protocol version as a string.
      *
      * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0").
      *
@@ -22,14 +26,22 @@ interface MessageInterface
     public function getProtocolVersion();
 
     /**
-     * Gets the body of the message.
+     * Create a new instance with the specified HTTP protocol version.
+     *
+     * The version string MUST contain only the HTTP version number (e.g.,
+     * "1.1", "1.0").
      *
-     * @return StreamableInterface|null Returns the body, or null if not set.
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new protocol version.
+     *
+     * @param string $version HTTP protocol version
+     * @return self
      */
-    public function getBody();
+    public function withProtocolVersion($version);
 
     /**
-     * Gets all message headers.
+     * Retrieves all message headers.
      *
      * The keys represent the header name as it will be sent over the wire, and
      * each value is an array of strings associated with the header.
@@ -69,7 +81,8 @@ public function hasHeader($header);
      * a comma.
      *
      * NOTE: Not all header values may be appropriately represented using
-     * comma concatenation.
+     * comma concatenation. For such headers, use getHeaderLines() instead
+     * and supply your own delimiter when concatenating.
      *
      * @param string $header Case-insensitive header name.
      * @return string
@@ -82,5 +95,78 @@ public function getHeader($header);
      * @param string $header Case-insensitive header name.
      * @return string[]
      */
-    public function getHeaderAsArray($header);
+    public function getHeaderLines($header);
+
+    /**
+     * Create a new instance with the provided header, replacing any existing
+     * values of any headers with the same case-insensitive name.
+     *
+     * The header name is case-insensitive. The header values MUST be a string
+     * or an array of strings.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new and/or updated header and value.
+     *
+     * @param string $header Header name
+     * @param string|string[] $value Header value(s).
+     * @return self
+     * @throws \InvalidArgumentException for invalid header names or values.
+     */
+    public function withHeader($header, $value);
+
+    /**
+     * Creates a new instance, with the specified header appended with the
+     * given value.
+     *
+     * Existing values for the specified header will be maintained. The new
+     * value(s) will be appended to the existing list. If the header did not
+     * exist previously, it will be added.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new header and/or value.
+     *
+     * @param string $header Header name to add
+     * @param string|string[] $value Header value(s).
+     * @return self
+     * @throws \InvalidArgumentException for invalid header names or values.
+     */
+    public function withAddedHeader($header, $value);
+
+    /**
+     * Creates a new instance, without the specified header.
+     *
+     * Header resolution MUST be done without case-sensitivity.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that removes
+     * the named header.
+     *
+     * @param string $header HTTP header to remove
+     * @return self
+     */
+    public function withoutHeader($header);
+
+    /**
+     * Gets the body of the message.
+     *
+     * @return StreamableInterface Returns the body as a stream.
+     */
+    public function getBody();
+
+    /**
+     * Create a new instance, with the specified message body.
+     *
+     * The body MUST be a StreamableInterface object.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new body stream.
+     *
+     * @param StreamableInterface $body Body.
+     * @return self
+     * @throws \InvalidArgumentException When the body is not valid.
+     */
+    public function withBody(StreamableInterface $body);
 }
diff --git a/src/OutgoingRequestInterface.php b/src/OutgoingRequestInterface.php
deleted file mode 100644
index 3e08789..0000000
--- a/src/OutgoingRequestInterface.php
+++ /dev/null
@@ -1,121 +0,0 @@
-<?php
-
-namespace Psr\Http\Message;
-
-/**
- * Representation of an outgoing, client-side request.
- * 
- * Per the HTTP specification, this interface includes both accessors for
- * and mutators for the following:
- *
- * - Protocol version
- * - HTTP method
- * - URL
- * - Headers
- * - Message body
- *
- * As the request CAN be built iteratively, the interface allows
- * mutability of all properties.
- */
-interface OutgoingRequestInterface extends MessageInterface
-{
-    /**
-     * Set the HTTP protocol version.
-     *
-     * The version string MUST contain only the HTTP version number (e.g.,
-     * "1.1", "1.0").
-     *
-     * @param string $version HTTP protocol version
-     * @return void
-     */
-    public function setProtocolVersion($version);
-
-    /**
-     * Retrieves the HTTP method of the request.
-     *
-     * @return string Returns the request method.
-     */
-    public function getMethod();
-
-    /**
-     * Sets the HTTP method to be performed on the resource identified by the
-     * Request-URI.
-     *
-     * While HTTP method names are typically all uppercase characters, HTTP
-     * method names are case-sensitive and thus implementations SHOULD NOT
-     * modify the given string.
-     *
-     * @param string $method Case-insensitive method.
-     * @return void
-     * @throws \InvalidArgumentException for invalid HTTP methods.
-     */
-    public function setMethod($method);
-
-    /**
-     * Retrieves the request URL.
-     *
-     * @link http://tools.ietf.org/html/rfc3986#section-4.3
-     * @return string Returns the URL as a string. The URL SHOULD be an
-     *     absolute URI as specified in RFC 3986, but MAY be a relative URI.
-     */
-    public function getUrl();
-
-    /**
-     * Sets the request URL.
-     *
-     * The URL MUST be a string. The URL SHOULD be an absolute URI as specified
-     * in RFC 3986, but MAY be a relative URI.
-     *
-     * @link http://tools.ietf.org/html/rfc3986#section-4.3
-     * @param string $url Request URL.
-     * @return void
-     * @throws \InvalidArgumentException If the URL is invalid.
-     */
-    public function setUrl($url);
-
-    /**
-     * Sets a header, replacing any existing values of any headers with the
-     * same case-insensitive name.
-     *
-     * The header name is case-insensitive. The header values MUST be a string
-     * or an array of strings.
-     *
-     * @param string $header Header name
-     * @param string|string[] $value Header value(s).
-     * @return void
-     * @throws \InvalidArgumentException for invalid header names or values.
-     */
-    public function setHeader($header, $value);
-
-    /**
-     * Appends a header value for the specified header.
-     *
-     * Existing values for the specified header will be maintained. The new
-     * value(s) will be appended to the existing list.
-     *
-     * @param string $header Header name to add
-     * @param string|string[] $value Header value(s).
-     * @return void
-     * @throws \InvalidArgumentException for invalid header names or values.
-     */
-    public function addHeader($header, $value);
-
-    /**
-     * Remove a specific header by case-insensitive name.
-     *
-     * @param string $header HTTP header to remove
-     * @return void
-     */
-    public function removeHeader($header);
-
-    /**
-     * Sets the body of the message.
-     *
-     * The body MUST be a StreamableInterface object.
-     *
-     * @param StreamableInterface $body Body.
-     * @return void
-     * @throws \InvalidArgumentException When the body is not valid.
-     */
-    public function setBody(StreamableInterface $body);
-}
diff --git a/src/OutgoingResponseInterface.php b/src/OutgoingResponseInterface.php
deleted file mode 100644
index e9f3094..0000000
--- a/src/OutgoingResponseInterface.php
+++ /dev/null
@@ -1,119 +0,0 @@
-<?php
-
-namespace Psr\Http\Message;
-
-/**
- * Representation of an outgoing, server-side response.
- *
- * Per the HTTP specification, this interface includes both accessors for
- * and mutators for the following:
- *
- * - Protocol version
- * - Status code and reason phrase
- * - Headers
- * - Message body
- *
- * As the response CAN be built iteratively, the interface allows
- * mutability of all properties.
- */
-interface OutgoingResponseInterface extends MessageInterface
-{
-    /**
-     * Set the HTTP protocol version.
-     *
-     * The version string MUST contain only the HTTP version number (e.g.,
-     * "1.1", "1.0").
-     *
-     * @param string $version HTTP protocol version
-     * @return void
-     */
-    public function setProtocolVersion($version);
-
-    /**
-     * Gets the response Status-Code.
-     *
-     * The Status-Code is a 3-digit integer result code of the server's attempt
-     * to understand and satisfy the request.
-     *
-     * @return integer Status code.
-     */
-    public function getStatusCode();
-
-    /**
-     * Sets the status code, and optionally reason phrase,  of this response.
-     *
-     * If no Reason-Phrase is specified, implementations MAY choose to default
-     * to the RFC 7231 or IANA recommended reason phrase for the response's
-     * Status-Code.
-     *
-     * @link http://tools.ietf.org/html/rfc7231#section-6
-     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-     * @param integer $code The 3-digit integer result code to set.
-     * @param null|string $reasonPhrase The reason phrase to use with the
-     *     provided status code; if none is provided, implementations MAY
-     *     use the defaults as suggested in the HTTP specification.
-     * @throws \InvalidArgumentException For invalid status code arguments.
-     */
-    public function setStatus($code, $reasonPhrase = null);
-
-    /**
-     * Gets the response Reason-Phrase, a short textual description of the Status-Code.
-     *
-     * Because a Reason-Phrase is not a required element in a response
-     * Status-Line, the Reason-Phrase value MAY be null. Implementations MAY
-     * choose to return the default RFC 7231 recommended reason phrase (or those
-     * listed in the IANA HTTP Status Code Registry) for the response's
-     * Status-Code.
-     *
-     * @link http://tools.ietf.org/html/rfc7231#section-6
-     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-     * @return string|null Reason phrase, or null if unknown.
-     */
-    public function getReasonPhrase();
-
-    /**
-     * Sets a header, replacing any existing values of any headers with the
-     * same case-insensitive name.
-     *
-     * The header name is case-insensitive. The header values MUST be a string
-     * or an array of strings.
-     *
-     * @param string $header Header name
-     * @param string|string[] $value Header value(s).
-     * @return void
-     * @throws \InvalidArgumentException for invalid header names or values.
-     */
-    public function setHeader($header, $value);
-
-    /**
-     * Appends a header value for the specified header.
-     *
-     * Existing values for the specified header will be maintained. The new
-     * value(s) will be appended to the existing list.
-     *
-     * @param string $header Header name to add
-     * @param string|string[] $value Header value(s).
-     * @return void
-     * @throws \InvalidArgumentException for invalid header names or values.
-     */
-    public function addHeader($header, $value);
-
-    /**
-     * Remove a specific header by case-insensitive name.
-     *
-     * @param string $header HTTP header to remove
-     * @return void
-     */
-    public function removeHeader($header);
-
-    /**
-     * Sets the body of the message.
-     *
-     * The body MUST be a StreamableInterface object.
-     *
-     * @param StreamableInterface $body Body.
-     * @return void
-     * @throws \InvalidArgumentException When the body is not valid.
-     */
-    public function setBody(StreamableInterface $body);
-}
diff --git a/src/RequestInterface.php b/src/RequestInterface.php
new file mode 100644
index 0000000..54ec043
--- /dev/null
+++ b/src/RequestInterface.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Representation of an outgoing, client-side request.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - HTTP method
+ * - URI
+ * - Headers
+ * - Message body
+ *
+ * Requests are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return a new instance that contains the changed state.
+ */
+interface RequestInterface extends MessageInterface
+{
+    /**
+     * Retrieves the HTTP method of the request.
+     *
+     * @return string Returns the request method.
+     */
+    public function getMethod();
+
+    /**
+     * Create a new instance with the provided HTTP method.
+     *
+     * While HTTP method names are typically all uppercase characters, HTTP
+     * method names are case-sensitive and thus implementations SHOULD NOT
+     * modify the given string.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * changed request method.
+     *
+     * @param string $method Case-insensitive method.
+     * @return self
+     * @throws \InvalidArgumentException for invalid HTTP methods.
+     */
+    public function withMethod($method);
+
+    /**
+     * Retrieves the URI instance.
+     *
+     * This method MUST return a UriTargetInterface instance.
+     *
+     * @link http://tools.ietf.org/html/rfc3986#section-4.3
+     * @return UriTargetInterface Returns a UriTargetInterface instance
+     *     representing the URI of the request, if any.
+     */
+    public function getUri();
+
+    /**
+     * Create a new instance with the provided URI.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new UriTargetInterface instance.
+     *
+     * @link http://tools.ietf.org/html/rfc3986#section-4.3
+     * @param UriTargetInterface $uri New request URI to use.
+     * @return self
+     */
+    public function withUri(UriTargetInterface $uri);
+}
diff --git a/src/ResponseInterface.php b/src/ResponseInterface.php
new file mode 100644
index 0000000..a9f0fe1
--- /dev/null
+++ b/src/ResponseInterface.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Representation of an outgoing, server-side response.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - Status code and reason phrase
+ * - Headers
+ * - Message body
+ *
+ * Responses are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return a new instance that contains the changed state.
+ */
+interface ResponseInterface extends MessageInterface
+{
+    /**
+     * Gets the response Status-Code.
+     *
+     * The Status-Code is a 3-digit integer result code of the server's attempt
+     * to understand and satisfy the request.
+     *
+     * @return integer Status code.
+     */
+    public function getStatusCode();
+
+    /**
+     * Create a new instance with the specified status code, and optionally
+     * reason phrase, for the response.
+     *
+     * If no Reason-Phrase is specified, implementations MAY choose to default
+     * to the RFC 7231 or IANA recommended reason phrase for the response's
+     * Status-Code.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * updated status and reason phrase.
+     *
+     * @link http://tools.ietf.org/html/rfc7231#section-6
+     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+     * @param integer $code The 3-digit integer result code to set.
+     * @param null|string $reasonPhrase The reason phrase to use with the
+     *     provided status code; if none is provided, implementations MAY
+     *     use the defaults as suggested in the HTTP specification.
+     * @return self
+     * @throws \InvalidArgumentException For invalid status code arguments.
+     */
+    public function withStatus($code, $reasonPhrase = null);
+
+    /**
+     * Gets the response Reason-Phrase, a short textual description of the Status-Code.
+     *
+     * Because a Reason-Phrase is not a required element in a response
+     * Status-Line, the Reason-Phrase value MAY be null. Implementations MAY
+     * choose to return the default RFC 7231 recommended reason phrase (or those
+     * listed in the IANA HTTP Status Code Registry) for the response's
+     * Status-Code.
+     *
+     * @link http://tools.ietf.org/html/rfc7231#section-6
+     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+     * @return string|null Reason phrase, or null if unknown.
+     */
+    public function getReasonPhrase();
+}
diff --git a/src/ServerRequestInterface.php b/src/ServerRequestInterface.php
new file mode 100644
index 0000000..6a58a0a
--- /dev/null
+++ b/src/ServerRequestInterface.php
@@ -0,0 +1,229 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Representation of an incoming, server-side HTTP request.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - HTTP method
+ * - URI
+ * - Headers
+ * - Message body
+ *
+ * Additionally, it encapsulates all data as it has arrived to the
+ * application from the CGI and/or PHP environment, including:
+ *
+ * - The values represented in $_SERVER.
+ * - Any cookies provided (generally via $_COOKIE)
+ * - Query string arguments (generally via $_GET, or as parsed via parse_str())
+ * - Upload files, if any (as represented by $_FILES)
+ * - Deserialized body parameters (generally from $_POST)
+ *
+ * $_SERVER and $_FILES values MUST be treated as immutable, as they represent
+ * application state at the time of request; as such, no methods are provided
+ * to allow modification of those values. The other values provide such methods,
+ * as they can be restored from $_SERVER, $_FILES, or the request body, and may
+ * need treatment during the application (e.g., body parameters may be
+ * deserialized based on content type).
+ *
+ * Additionally, this interface recognizes the utility of introspecting a
+ * request to derive and match additional parameters (e.g., via URI path
+ * matching, decrypting cookie values, deserializing non-form-encoded body
+ * content, matching authorization headers to users, etc). These parameters
+ * are stored in an "attributes" property.
+ *
+ * Requests are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return a new instance that contains the changed state.
+ */
+interface ServerRequestInterface extends RequestInterface
+{
+    /**
+     * Retrieve server parameters.
+     *
+     * Retrieves data related to the incoming request environment,
+     * typically derived from PHP's $_SERVER superglobal. The data IS NOT
+     * REQUIRED to originate from $_SERVER.
+     *
+     * @return array
+     */
+    public function getServerParams();
+
+    /**
+     * Retrieve cookies.
+     *
+     * Retrieves cookies sent by the client to the server.
+     *
+     * The data MUST be compatible with the structure of the $_COOKIE
+     * superglobal.
+     *
+     * @return array
+     */
+    public function getCookieParams();
+
+    /**
+     * Create a new instance with the specified cookies.
+     *
+     * The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST
+     * be compatible with the structure of $_COOKIE. Typically, this data will
+     * be injected at instantiation.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * updated cookie values.
+     *
+     * @param array $cookies Array of key/value pairs representing cookies.
+     * @return self
+     */
+    public function withCookieParams(array $cookies);
+
+    /**
+     * Retrieve query string arguments.
+     *
+     * Retrieves the deserialized query string arguments, if any.
+     *
+     * Note: the query params might not be in sync with the URL or server
+     * params. If you need to ensure you are only getting the original
+     * values, you may need to parse the composed URL or the `QUERY_STRING`
+     * composed in the server params.
+     *
+     * @return array
+     */
+    public function getQueryParams();
+
+    /**
+     * Create a new instance with the specified query string arguments.
+     *
+     * These values SHOULD remain immutable over the course of the incoming
+     * request. They MAY be injected during instantiation, such as from PHP's
+     * $_GET superglobal, or MAY be derived from some other value such as the
+     * URI. In cases where the arguments are parsed from the URI, the data
+     * MUST be compatible with what PHP's parse_str() would return for
+     * purposes of how duplicate query parameters are handled, and how nested
+     * sets are handled.
+     *
+     * Setting query string arguments MUST NOT change the URL stored by the
+     * request, nor the values in the server params.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * updated query string arguments.
+     *
+     * @param array $query Array of query string arguments, typically from
+     *     $_GET.
+     * @return self
+     */
+    public function withQueryParams(array $query);
+
+    /**
+     * Retrieve the upload file metadata.
+     *
+     * This method MUST return file upload metadata in the same structure
+     * as PHP's $_FILES superglobal.
+     *
+     * These values MUST remain immutable over the course of the incoming
+     * request. They SHOULD be injected during instantiation, such as from PHP's
+     * $_FILES superglobal, but MAY be derived from other sources.
+     *
+     * @return array Upload file(s) metadata, if any.
+     */
+    public function getFileParams();
+
+    /**
+     * Retrieve any parameters provided in the request body.
+     *
+     * If the request body can be deserialized to an array, this method MAY be
+     * used to retrieve them.
+     *
+     * @return array The deserialized body parameters, if any.
+     */
+    public function getBodyParams();
+
+    /**
+     * Create a new instance with the specified body parameters.
+     *
+     * These MAY be injected during instantiation from PHP's $_POST
+     * superglobal. The data IS NOT REQUIRED to come from $_POST, but MUST be
+     * an array. This method can be used during the request lifetime to inject
+     * parameters discovered and/or deserialized from the request body; as an
+     * example, if content negotiation determines that the request data is
+     * a JSON payload, this method could be used to inject the deserialized
+     * parameters.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * updated body parameters.
+     *
+     * @param array $params The deserialized body parameters.
+     * @return self
+     */
+    public function withBodyParams(array $params);
+
+    /**
+     * Retrieve attributes derived from the request.
+     *
+     * The request "attributes" may be used to allow injection of any
+     * parameters derived from the request: e.g., the results of path
+     * match operations; the results of decrypting cookies; the results of
+     * deserializing non-form-encoded message bodies; etc. Attributes
+     * will be application and request specific, and CAN be mutable.
+     *
+     * @return array Attributes derived from the request.
+     */
+    public function getAttributes();
+
+    /**
+     * Retrieve a single derived request attribute.
+     *
+     * Retrieves a single derived request attribute as described in
+     * getAttributes(). If the attribute has not been previously set, returns
+     * the default value as provided.
+     *
+     * This method obviates the need for a hasAttribute() method, as it allows
+     * specifying a default value to return if the attribute is not found.
+     *
+     * @see getAttributes()
+     * @param string $attribute Attribute name.
+     * @param mixed $default Default value to return if the attribute does not exist.
+     * @return mixed
+     */
+    public function getAttribute($attribute, $default = null);
+
+    /**
+     * Create a new instance with the specified derived request attribute.
+     *
+     * This method allows setting a single derived request attribute as
+     * described in getAttributes().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * updated attribute.
+     *
+     * @see getAttributes()
+     * @param string $attribute The attribute name.
+     * @param mixed $value The value of the attribute.
+     * @return self
+     */
+    public function withAttribute($attribute, $value);
+
+    /**
+     * Create a new instance that removes the specified derived request
+     * attribute.
+     *
+     * This method allows removing a single derived request attribute as
+     * described in getAttributes().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that removes
+     * the attribute.
+     *
+     * @see getAttributes()
+     * @param string $attribute The attribute name.
+     * @return self
+     */
+    public function withoutAttribute($attribute);
+}
diff --git a/src/StreamableInterface.php b/src/StreamableInterface.php
index 96fad9d..8be1fbc 100644
--- a/src/StreamableInterface.php
+++ b/src/StreamableInterface.php
@@ -70,19 +70,30 @@ public function isSeekable();
     /**
      * Seek to a position in the stream.
      *
-     * @link  http://www.php.net/manual/en/function.fseek.php
+     * @link http://www.php.net/manual/en/function.fseek.php
      * @param int $offset Stream offset
      * @param int $whence Specifies how the cursor position will be calculated
-     *                    based on the seek offset. Valid values are identical
-     *                    to the built-in PHP $whence values for `fseek()`.
-     *                    SEEK_SET: Set position equal to offset bytes
-     *                    SEEK_CUR: Set position to current location plus offset
-     *                    SEEK_END: Set position to end-of-stream plus offset
-     *
+     *     based on the seek offset. Valid values are identical to the built-in
+     *     PHP $whence values for `fseek()`.  SEEK_SET: Set position equal to
+     *     offset bytes SEEK_CUR: Set position to current location plus offset
+     *     SEEK_END: Set position to end-of-stream plus offset.
      * @return bool Returns TRUE on success or FALSE on failure.
      */
     public function seek($offset, $whence = SEEK_SET);
 
+    /**
+     * Seek to the beginning of the stream.
+     *
+     * If the stream is not seekable, this method will return FALSE, indicating
+     * failure; otherwise, it will perform a seek(0), and return the status of
+     * that operation.
+     *
+     * @see seek()
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @return bool Returns TRUE on success or FALSE on failure.
+     */
+    public function rewind();
+
     /**
      * Returns whether or not the stream is writable.
      *
@@ -94,9 +105,8 @@ public function isWritable();
      * Write data to the stream.
      *
      * @param string $string The string that is to be written.
-     *
      * @return int|bool Returns the number of bytes written to the stream on
-     *                  success or FALSE on failure.
+     *     success or FALSE on failure.
      */
     public function write($string);
 
@@ -111,10 +121,10 @@ public function isReadable();
      * Read data from the stream.
      *
      * @param int $length Read up to $length bytes from the object and return
-     *                    them. Fewer than $length bytes may be returned if
-     *                    underlying stream call returns fewer bytes.
+     *     them. Fewer than $length bytes may be returned if underlying stream
+     *     call returns fewer bytes.
      * @return string|false Returns the data read from the stream, false if
-     *                      unable to read or if an error occurs.
+     *     unable to read or if an error occurs.
      */
     public function read($length);
 
@@ -134,9 +144,8 @@ public function getContents();
      * @link http://php.net/manual/en/function.stream-get-meta-data.php
      * @param string $key Specific metadata to retrieve.
      * @return array|mixed|null Returns an associative array if no key is
-     *                          provided. Returns a specific key value if a key
-     *                          is provided and the value is found, or null if
-     *                          the key is not found.
+     *     provided. Returns a specific key value if a key is provided and the
+     *     value is found, or null if the key is not found.
      */
     public function getMetadata($key = null);
 }
diff --git a/src/UriTargetInterface.php b/src/UriTargetInterface.php
new file mode 100644
index 0000000..02d309b
--- /dev/null
+++ b/src/UriTargetInterface.php
@@ -0,0 +1,327 @@
+<?php
+namespace Psr\Http\Message;
+
+/**
+ * Value object representing the request target, and typically a URI.
+ *
+ * Instances of this interface are considered immutable; all methods that
+ * might change state MUST be implemented such that they retain the internal
+ * state of the current instance and return a new instance that contains the
+ * changed state.
+ *
+ * Since this interface represents a request target per RFC 7230, the instance
+ * MAY represent an absolute URI OR one of the request targets that are not
+ * fully qualified URIs, including origin-form, authority-form, or
+ * asterisk-form. As such, test methods exist for determining what request
+ * target form is in use:
+ *
+ * - isAbsolute() tests if the target is in absolute-form (minimally scheme +
+ *   authority).
+ * - isOrigin() tests if the target is in origin-form (path + optional query
+ *   string only).
+ * - isAuthority() tests if the target contains the authority only.
+ * - isAsterisk() tests if the entirety of the target is '*'.
+ *
+ * These target forms are included, as they are valid forms for use with an
+ * HTTP request, and will appear without other URI segments available within
+ * the request line. This interface models the target as it appears in the
+ * incoming request line or as it will be emitted by a client.
+ *
+ * Typically, for all forms other than absolute-form, minimally the Host header
+ * will be also be present in the request message. For server-side requests,
+ * the scheme will typically be discoverable in the server parameters.
+ *
+ * @link http://tools.ietf.org/html/rfc3986 (the URI specification)
+ * @link http://tools.ietf.org/html/rfc7230#section-2.7 (URIs as used in the HTTP specification)
+ */
+interface UriTargetInterface
+{
+    /**
+     * Retrieve the URI scheme.
+     *
+     * Implementations SHOULD restrict values to "http", "https", or an empty
+     * string but MAY accommodate other schemes if required.
+     *
+     * If no scheme is present, this method MUST return an empty string.
+     *
+     * The string returned MUST omit the trailing "://" delimiter if present.
+     *
+     * @return string The scheme of the URI.
+     */
+    public function getScheme();
+
+    /**
+     * Retrieve the authority portion of the URI.
+     *
+     * The authority portion of the URI is:
+     *
+     * <pre>
+     * [user-info@]host[:port]
+     * </pre>
+     *
+     * If the port component is not set or is the standard port for the current
+     * scheme, it SHOULD NOT be included.
+     *
+     * This method MUST return an empty string if no authority information is
+     * present.
+     *
+     * @return string Authority portion of the URI, in "[user-info@]host[:port]"
+     *     format.
+     */
+    public function getAuthority();
+
+    /**
+     * Retrieve the user information portion of the URI, if present.
+     *
+     * If a user is present in the URI, this will return that value;
+     * additionally, if the password is also present, it will be appended to the
+     * user value, with a colon (":") separating the values.
+     *
+     * Implementations MUST NOT return the "@" suffix when returning this value.
+     *
+     * @return string User information portion of the URI, if present, in
+     *     "username[:password]" format.
+     */
+    public function getUserInfo();
+
+    /**
+     * Retrieve the host segment of the URI.
+     *
+     * This method MUST return a string; if no host segment is present, an
+     * empty string MUST be returned.
+     *
+     * @return string Host segment of the URI.
+     */
+    public function getHost();
+
+    /**
+     * Retrieve the port segment of the URI.
+     *
+     * If a port is present, and it is non-standard for the current scheme,
+     * this method MUST return it as an integer. If the port is the standard port
+     * used with the current scheme, this method SHOULD return null.
+     *
+     * If no port is present, and no scheme is present, this method MUST return
+     * a null value.
+     *
+     * If no port is present, but a scheme is present, this method MAY return
+     * the standard port for that scheme, but SHOULD return null.
+     *
+     * @return null|int The port for the URI.
+     */
+    public function getPort();
+
+    /**
+     * Retrieve the path segment of the URI.
+     *
+     * This method MUST return a string; if no path is present it MUST return
+     * an empty string.
+     *
+     * @return string The path segment of the URI.
+     */
+    public function getPath();
+
+    /**
+     * Retrieve the query string of the URI.
+     *
+     * This method MUST return a string; if no query string is present, it MUST
+     * return an empty string.
+     *
+     * The string returned MUST omit the leading "?" character.
+     *
+     * @return string The URI query string.
+     */
+    public function getQuery();
+
+    /**
+     * Retrieve the fragment segment of the URI.
+     *
+     * This method MUST return a string; if no fragment is present, it MUST
+     * return an empty string.
+     *
+     * The string returned MUST omit the leading "#" character.
+     *
+     * @return string The URI fragment.
+     */
+    public function getFragment();
+
+    /**
+     * Create a new instance with the specified scheme.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified scheme. If the scheme
+     * provided includes the "://" delimiter, it MUST be removed.
+     *
+     * Implementations SHOULD restrict values to "http", "https", or an empty
+     * string but MAY accommodate other schemes if required.
+     *
+     * An empty scheme is equivalent to removing the scheme.
+     *
+     * @param string $scheme The scheme to use with the new instance.
+     * @return self A new instance with the specified scheme.
+     * @throws \InvalidArgumentException for invalid or unsupported schemes.
+     */
+    public function withScheme($scheme);
+
+    /**
+     * Create a new instance with the specified user information.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified user information.
+     *
+     * Password is optional, but the user information MUST include the
+     * user; an empty string for the user is equivalent to removing user
+     * information.
+     *
+     * @param string $user User name to use for authority.
+     * @param null|string $password Password associated with $user.
+     * @return self A new instance with the specified user information.
+     */
+    public function withUserInfo($user, $password = null);
+
+    /**
+     * Create a new instance with the specified host.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified host.
+     *
+     * An empty host value is equivalent to removing the host.
+     *
+     * @param string $host Hostname to use with the new instance.
+     * @return self A new instance with the specified host.
+     * @throws \InvalidArgumentException for invalid hostnames.
+     */
+    public function withHost($host);
+
+    /**
+     * Create a new instance with the specified port.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified port.
+     *
+     * Implementations MUST raise an exception for ports outside the
+     * established TCP and UDP port ranges.
+     *
+     * A null value provided for the port is equivalent to removing the port
+     * information.
+     *
+     * @param null|int $port Port to use with the new instance; a null value
+     *     removes the port information.
+     * @return self A new instance with the specified port.
+     * @throws \InvalidArgumentException for invalid ports.
+     */
+    public function withPort($port);
+
+    /**
+     * Create a new instance with the specified path.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified path.
+     *
+     * The path MUST be prefixed with "/"; if not, the implementation MAY
+     * provide the prefix itself.
+     *
+     * An empty path value is equivalent to removing the path.
+     *
+     * @param string $path The path to use with the new instance.
+     * @return self A new instance with the specified path.
+     * @throws \InvalidArgumentException for invalid paths.
+     */
+    public function withPath($path);
+
+    /**
+     * Create a new instance with the specified query string.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified query string.
+     *
+     * If the query string is prefixed by "?", that character MUST be removed.
+     * Additionally, the query string SHOULD be parseable by parse_str() in
+     * order to be valid.
+     *
+     * An empty query string value is equivalent to removing the query string.
+     *
+     * @param string $query The query string to use with the new instance.
+     * @return self A new instance with the specified query string.
+     * @throws \InvalidArgumentException for invalid query strings.
+     */
+    public function withQuery($query);
+
+    /**
+     * Create a new instance with the specified URI fragment.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * a new instance that contains the specified URI fragment.
+     *
+     * If the fragment is prefixed by "#", that character MUST be removed.
+     *
+     * An empty fragment value is equivalent to removing the fragment.
+     *
+     * @param string $fragment The URI fragment to use with the new instance.
+     * @return self A new instance with the specified URI fragment.
+     */
+    public function withFragment($fragment);
+
+    /**
+     * Indicate whether the URI is in origin-form.
+     *
+     * Origin-form is a URI that includes only the path, and optionally the
+     * query string.
+     *
+     * @link http://tools.ietf.org/html/rfc7230#section-5.3.1
+     * @return bool
+     */
+    public function isOrigin();
+
+    /**
+     * Indicate whether the URI is absolute.
+     *
+     * An absolute URI contains minimally a non-empty scheme and non-empty
+     * authority.
+     *
+     * @see getAuthority()
+     * @link http://tools.ietf.org/html/rfc7230#section-5.3.2
+     * @return bool
+     */
+    public function isAbsolute();
+
+    /**
+     * Indicate whether the URI is in authority form.
+     *
+     * An authority-form URI is an URI that contains ONLY the authority
+     * information.
+     *
+     * @see getAuthority()
+     * @link http://tools.ietf.org/html/rfc7230#section-5.3.3
+     * @return bool
+     */
+    public function isAuthority();
+
+    /**
+     * Indicate whether the URI is an asterisk-form.
+     *
+     * An asterisk form URI will contain "*" as the path, and no other URI
+     * segments.
+     *
+     * @link http://tools.ietf.org/html/rfc7230#section-5.3.4
+     * @return bool
+     */
+    public function isAsterisk();
+
+    /**
+     * Return the string representation of the URI.
+     *
+     * Concatenates the various segments of the URI, using the appropriate
+     * delimiters:
+     *
+     * - If a scheme is present, "://" MUST append the value.
+     * - If the authority information is present, that value will be
+     *   contatenated.
+     * - If a path is present, it MUST be prefixed by a "/" character.
+     * - If a query string is present, it MUST be prefixed by a "?" character.
+     * - If a URI fragment is present, it MUST be prefixed by a "#" character.
+     *
+     * @return string
+     */
+    public function __toString();
+}