diff --git a/docs/api/MongoDB/CRUD.php b/docs/api/MongoDB/CRUD.php
deleted file mode 100644
index af9453aec..000000000
--- a/docs/api/MongoDB/CRUD.php
+++ /dev/null
@@ -1,61 +0,0 @@
-<?php
-namespace MongoDB;
-
-interface WriteBatch {
-    function add($document);
-}
-
-
-class InsertBatch implements WriteBatch {
-    function add($document) {
-        $this->documents[] = $document;
-    }
-}
-
-class UpdateBatch implements WriteBatch {
-    function add($document) {
-        $this->documents[] = $document;
-    }
-}
-
-class DeleteBatch implements WriteBatch {
-    function add($document) {
-        $this->documents[] = $document;
-    }
-}
-
-class Query {
-    function __construct($query) {}
-}
-class Command {
-    function __construct($command) {}
-}
-
-
-
-
-class WriteResults {
-
-    /* Returns nModified, n, nUserted, .. */
-    function getNumbers() {
-    }
-
-    /* Returns how many operations were executed */
-    function getOpCount() {
-    }
-
-    /* Returns the server that the operation was executed on */
-    function getServer() {
-    }
-
-    /* Any stats available from the server */
-    function getTimer() {
-    }
-}
-
-class QueryResults {
-    function __construct(Server $server, $cursor_id, $firstBatch) {
-    }
-}
-
-
diff --git a/docs/api/MongoDB/Command/Command.php b/docs/api/MongoDB/Command/Command.php
new file mode 100644
index 000000000..8b7af5471
--- /dev/null
+++ b/docs/api/MongoDB/Command/Command.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace MongoDB\Command;
+
+/**
+ * Value object for a database command document.
+ */
+final class Command
+{
+    private $document;
+
+    /**
+     * @param array|object $document Command document
+     */
+    public function __construct($document)
+    {
+        $this->document = $document;
+    }
+}
diff --git a/docs/api/MongoDB/Command/CommandCursor.php b/docs/api/MongoDB/Command/CommandCursor.php
new file mode 100644
index 000000000..17364580a
--- /dev/null
+++ b/docs/api/MongoDB/Command/CommandCursor.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace MongoDB\Command;
+
+use MongoDB\Cursor;
+use MongoDB\CursorId;
+
+/**
+ * Cursor implementation that may be constructed from values found in a
+ * CommandResult's response document.
+ *
+ * The iteration and internal logic is very similar to QueryCursor, so both
+ * classes should likely share code. The first batch is comparable to the
+ * documents found in the OP_REPLY message returned by a QueryCursor's original
+ * OP_QUERY, in that both may be available at the time the cursor is
+ * constructed.
+ */
+final class CommandCursor implements Cursor
+{
+    private $server;
+    private $batchSize;
+    private $cursorId;
+    private $firstBatch;
+
+    /**
+     * @param Server   $server
+     * @param CursorId $cursorId
+     * @param array    $firstBatch
+     */
+    public function __construct(Server $server, CursorId $cursorId, array $firstBatch)
+    {
+        $this->server = $server;
+        $this->cursorId = $cursorId;
+        $this->firstBatch = $firstBatch;
+    }
+
+    // Iterator methods...
+
+    /**
+     * @return Cursor::getId()
+     */
+    public function getId()
+    {
+        return $this->cursorId;
+    }
+
+    /**
+     * @see Cursor::getServer()
+     */
+    public function getServer()
+    {
+        return $this->server;
+    }
+
+    /**
+     * @see Cursor::isDead()
+     */
+    public function isDead()
+    {
+        // Return whether the cursor is exhausted and has no more results
+    }
+
+    /**
+     * @see \MongoDB\Cursor::setBatchSize()
+     */
+    public function setBatchSize($batchSize)
+    {
+        $this->batchSize = (integer) $batchSize;
+    }
+}
diff --git a/docs/api/MongoDB/Command/CommandResult.php b/docs/api/MongoDB/Command/CommandResult.php
new file mode 100644
index 000000000..013102bb5
--- /dev/null
+++ b/docs/api/MongoDB/Command/CommandResult.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace MongoDB\Command;
+
+use MongoDB\Server;
+
+/**
+ * Result returned by Server and Manager executeCommand() methods.
+ */
+final class CommandResult
+{
+    private $server;
+    private $responseDocument;
+
+    /**
+     * @param Server       $server
+     * @param array|object $responseDocument
+     */
+    public function __construct(Server $server, $responseDocument)
+    {
+        $this->server = $server;
+        $this->responseDocument = $responseDocument;
+    }
+
+    /**
+     * @return array Original response document from the server
+     */
+    public function getResponseDocument()
+    {
+        return $this->responseDocument;
+    }
+
+    /**
+     * @return Server Server from which the result originated
+     */
+    public function getServer()
+    {
+        return $this->server;
+    }
+}
diff --git a/docs/api/MongoDB/Cursor.php b/docs/api/MongoDB/Cursor.php
new file mode 100644
index 000000000..c920a281c
--- /dev/null
+++ b/docs/api/MongoDB/Cursor.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace MongoDB;
+
+interface Cursor extends \Iterator
+{
+    /**
+     * @return CursorId
+     */
+    function getId();
+
+    /**
+     * @return Server Server from which the cursor originated
+     */
+    function getServer();
+
+    /**
+     * @return boolean Whether the cursor is exhausted and has no more results
+     */
+    function isDead();
+
+    /**
+     * @param integer $batchSize
+     */
+    function setBatchSize($batchSize);
+}
diff --git a/docs/api/MongoDB/CursorId.php b/docs/api/MongoDB/CursorId.php
new file mode 100644
index 000000000..ed1e79fa6
--- /dev/null
+++ b/docs/api/MongoDB/CursorId.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace MongoDB;
+
+/**
+ * Value object for the 64-bit cursor identifier.
+ *
+ * This is useful for compatibility with 32-bit platforms, and also allows
+ * Cursor constructors to type-hint against a class.
+ */
+final class CursorId
+{
+    // $id is an internal uint64_t value instead of a class property
+
+    /**
+     * @param integer|string $id
+     */
+    public function __construct($id)
+    {
+        // Set internal uint64_t value
+    }
+
+    /**
+     * @return string
+     */
+    public function __toString()
+    {
+        /* Return string representation of internal uint64_t value.
+         *
+         * This can be used to compare two CursorIds on a 32-bit platform. Is
+         * this functionality necessary, or should we do without any "getter"
+         * method?
+         */
+    }
+}
diff --git a/docs/api/MongoDB/Management.php b/docs/api/MongoDB/Management.php
deleted file mode 100644
index a60e2a44a..000000000
--- a/docs/api/MongoDB/Management.php
+++ /dev/null
@@ -1,55 +0,0 @@
-<?php
-namespace MongoDB;
-
-class Server {
-    const TYPE_MONGOS     = 0x01;
-    const TYPE_STANDALONE = 0x02;
-    const TYPE_ARBITER    = 0x03;
-    const TYPE_SECONDARY  = 0x04;
-    const TYPE_PRIMARY    = 0x05;
-
-    /* These need to be final as they will not be called by the driver to retrieve the 
-     * information, these getters are only useful for userland */
-    final function getHostname() {}
-    final function getPort() {}
-    final function getLatency() {}
-    final function getMaxWireVersion() {}
-    final function getMinWireVersion() {}
-    final function getServerType() {}
-
-    /* extracting config info */
-    final function isPassive() {}
-    final function isDelayed() {}
-
-    final function executeQuery($namespace, \MongoDB\Query $query) {}
-    final function executeWrite($namespace, \MongoDB\WriteBatch $batch, WriteOptions $wo) {}
-}
-
-
-class Manager extends \SplObjectStorage {
-    function __construct(array $servers, $dbname, $connection_options) {
-    }
-
-    static function fromDSN($dsn) {
-    }
-
-    final function executeQuery($namespace, \MongoDB\Query $query, ReadPreference $rp) {
-        foreach($this->getConnectedServers() as $server) {
-            if ($server->matchesReadPreference($rp)) {
-                return $server->executeQuery($namespace, $query);
-            }
-        }
-        throw new NoServerMatchingReadPreference($rp);
-    }
-
-    final function executeWrite($namespace, \MongoDB\WriteBatch $batch, WriteOptions $wo) {
-        foreach($this->getConnectedServers() as $server) {
-            if ($server->isPrimary()) {
-                return $server->executeWrite($namespace, $batch, $wo);
-            }
-        }
-
-        throw new NoPrimaryAvailable;
-    }
-}
-
diff --git a/docs/api/MongoDB/Manager.php b/docs/api/MongoDB/Manager.php
new file mode 100644
index 000000000..2494d31da
--- /dev/null
+++ b/docs/api/MongoDB/Manager.php
@@ -0,0 +1,175 @@
+<?php
+
+namespace MongoDB;
+
+use MongoDB\Command\Command;
+use MongoDB\Command\CommandResult;
+use MongoDB\Query\Query;
+use MongoDB\Query\QueryCursor;
+use MongoDB\Write\WriteBatch;
+use MongoDB\Write\WriteOptions;
+use MongoDB\Write\WriteResult;
+
+/**
+ * Manager abstracts a cluster of Server objects (i.e. socket connections).
+ *
+ * Typically, users will connect to a cluster using a URI, and the Manager will
+ * perform tasks such as replica set discovery and create the necessary Server
+ * objects. That said, it is also possible to create a Manager with an arbitrary
+ * collection of Server objects using the static factory method (this can be
+ * useful for testing or administration).
+ *
+ * Operation methods do not take socket-level options (e.g. socketTimeoutMS).
+ * Those options should be specified during construction.
+ */
+final class Manager
+{
+    /**
+     * @param string $uri           Connection URI
+     * @param array  $options       Connection options (e.g. auth, socket timeouts)
+     * @param array  $driverOptions Driver options (e.g. stream contexts)
+     */
+    public function __construct($uri, array $options = array(), array $driverOptions = array())
+    {
+        // Parse DSN and options and create Server objects
+    }
+
+    /**
+     * @param Server[] $servers
+     * @return Manager
+     */
+    static public function createFromServers(array $servers)
+    {
+        /* Instantiate a new Manager instance with the provided Servers
+         *
+         * Should this method take $driverOptions as a second parameter? The
+         * Servers would already be constructed, so stream context options
+         * would not apply; however, we may want to take other options, such as
+         * event callbacks, down the line.
+         */
+    }
+
+    /**
+     * @param string         $db
+     * @param Command        $command
+     * @param ReadPreference $readPreference
+     * @return CommandResult
+     */
+    public function executeCommand($db, Command $command, ReadPreference $readPreference = null)
+    {
+        /* Select server based on (1) command requirements and (2) read
+         * preference and invoke Server::executeCommand().
+         *
+         * Read preferences should be injected into the command document if
+         * necessary (e.g. mongos).
+         *
+         * Rely on libmongoc for server selection and read preference injection.
+         *
+         * Throw exception if no candidate server is found. Throw a special
+         * exception the command requirement and read preferences logically
+         * conflict (e.g. mapReduce with output collection and secondary RP).
+         */
+    }
+
+    /**
+     * @param string         $namespace
+     * @param Query          $query
+     * @param ReadPreference $readPreference
+     * @return QueryCursor
+     */
+    public function executeQuery($namespace, Query $query, ReadPreference $readPreference = null)
+    {
+        /* Select server based on read preference and invoke
+         * Server::executeQuery().
+         *
+         * Read preferences should be injected into the query document if
+         * necessary (e.g. mongos).
+         *
+         * Rely on libmongoc for server selection and read preference injection.
+         *
+         * Throw exception if no candidate server is found.
+         */
+    }
+
+    /**
+     * @param string     $namespace
+     * @param WriteBatch $batch
+     * @param array      $writeOptions Ordering and write concern options (default: {"ordered": true, "w": 1})
+     * @return WriteResult
+     */
+    public function executeWrite($namespace, WriteBatch $batch, array $writeOptions = null)
+    {
+        /* Select writeable server and invoke Server::executeQuery().
+         *
+         * Write options are optional, and will be merged into the default,
+         * which is {"ordered": true, "w": 1}.
+         *
+         * On error, we should consider throwing:
+         *
+         *  - NoCandidateException: no writeable server was found
+         *  - WriteException: write failed; a WriteResult should be included.
+         *  - ConnectionException: low-level socket error
+         *
+         * If a WriteException is thrown, its WriteResult may contain multiple
+         * write errors and write concern errors.
+         */
+    }
+
+    /**
+     * Convenience method for single insert operation.
+     *
+     * @param string       $namespace
+     * @param array|object $document     Document to insert
+     * @param array        $writeOptions Write concern options (default: {"w": 1})
+     * @return InsertResult
+     */
+    public function executeInsert($namespace, $document, array $writeOptions = null)
+    {
+        /* Construct and execute an InsertBatch
+         *
+         * Write options are optional, and will be merged into the default,
+         * which is {"w": 1}.
+         */
+    }
+
+    /**
+     * Convenience method for single update operation.
+     *
+     * @param string       $namespace
+     * @param array|object $query         Update criteria
+     * @param array|object $newObj        Update modifier or replacement document
+     * @param array        $updateOptions Update options (e.g. "upsert")
+     * @param array        $writeOptions  Write concern options (default: {"w": 1})
+     * @return UpdateResult
+     */
+    public function executeUpdate($namespace, $query, $newObj, array $updateOptions = null, array $writeOptions = null)
+    {
+        /* Construct and execute an UpdateBatch
+         *
+         * Write options are optional, and will be merged into the default,
+         * which is {"w": 1}.
+         *
+         * What should be the default value for $options? No multi, no upsert?
+         */
+    }
+
+    /**
+     * Convenience method for single delete operation.
+     *
+     * @param string       $namespace
+     * @param array|object $query         Deletion criteria
+     * @param array        $deleteOptions Deletion options (e.g. "limit")
+     * @param array        $writeOptions  Write concern options (default: {"w": 1})
+     * @return DeleteResult
+     */
+    public function executeDelete($namespace, $query, array $deleteOptions = null, array $writeOptions = null)
+    {
+        /* Construct and execute an DeleteBatch
+         *
+         * Write options are optional, and will be merged into the default,
+         * which is {"w": 1}.
+         *
+         * What should be the default value for $options? No limit?
+         */
+    }
+}
diff --git a/docs/api/MongoDB/Query/Query.php b/docs/api/MongoDB/Query/Query.php
new file mode 100644
index 000000000..cfda9704a
--- /dev/null
+++ b/docs/api/MongoDB/Query/Query.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace MongoDB\Query;
+
+/**
+ * Value object corresponding to a wire protocol OP_QUERY message.
+ *
+ * If and when queries become commands, we will need to introduce a new Query
+ * object, such as QueryCommand. At that point, the query will likely be
+ * constructed from a single document, which includes the arguments below in a
+ * similar fashion to findAndModify.
+ */
+final class Query
+{
+    // See: http://docs.mongodb.org/meta-driver/latest/legacy/mongodb-wire-protocol/#op-query
+    const FLAG_TAILABLE_CURSOR   = 0x01;
+    const FLAG_SLAVE_OK          = 0x02;
+    const FLAG_OPLOG_REPLAY      = 0x03;
+    const FLAG_NO_CURSOR_TIMEOUT = 0x04;
+    const FLAG_AWAIT_DATA        = 0x05;
+    const FLAG_EXHAUST           = 0x06;
+    const FLAG_PARTIAL           = 0x07;
+
+    private $query;
+    private $selector;
+    private $flags;
+    private $skip;
+    private $limit;
+
+    /**
+     * @param array|object $query    Query document
+     * @param array|object $selector Selector document
+     * @param integer      $flags    Query flags
+     * @param integer      $limit    Limit
+     * @param integer      $skip     Skip
+     */
+    public function __construct($query, $selector, $flags, $skip, $limit)
+    {
+        $this->query = $query;
+        $this->selector = $selector;
+        $this->flags = (integer) $flags;
+        $this->skip = (integer) $skip;
+        $this->limit = (integer) $limit;
+    }
+}
diff --git a/docs/api/MongoDB/Query/QueryCursor.php b/docs/api/MongoDB/Query/QueryCursor.php
new file mode 100644
index 000000000..a06ece593
--- /dev/null
+++ b/docs/api/MongoDB/Query/QueryCursor.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace MongoDB\Query;
+
+use MongoDB\Cursor;
+use MongoDB\CursorId;
+
+/**
+ * Cursor implementation that is returned after executing a Query.
+ *
+ * The iteration and internal logic is very similar to CommandCursor, so both
+ * classes should likely share code. The documents in the OP_REPLY message
+ * returned by the original OP_QUERY is comparable to the first batch of a
+ * command cursor, in that both may be available at the time the cursor is
+ * constructed.
+ */
+final class QueryCursor implements Cursor
+{
+    private $server;
+    private $batchSize;
+    private $cursorId;
+
+    /**
+     * @param Server   $server
+     * @param CursorId $cursorId
+     */
+    public function __construct(Server $server, CursorId $cursorId)
+    {
+        $this->server = $server;
+        $this->cursorId = $cursorId;
+    }
+
+    // Iterator methods...
+
+    /**
+     * @see Cursor::getId()
+     */
+    public function getId()
+    {
+        return $this->cursorId;
+    }
+
+    /**
+     * @see Cursor::getServer()
+     */
+    public function getServer()
+    {
+        return $this->server;
+    }
+
+    /**
+     * @see Cursor::isDead()
+     */
+    public function isDead()
+    {
+        // Return whether the cursor is exhausted and has no more results
+    }
+
+    /**
+     * @see Cursor::setBatchSize()
+     */
+    public function setBatchSize($batchSize)
+    {
+        $this->batchSize = (integer) $batchSize;
+    }
+}
diff --git a/docs/api/MongoDB/ReadPreference.php b/docs/api/MongoDB/ReadPreference.php
new file mode 100644
index 000000000..69201aa76
--- /dev/null
+++ b/docs/api/MongoDB/ReadPreference.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace MongoDB;
+
+/**
+ * Value object for read preferences used in issuing commands and queries.
+ */
+final class ReadPreference
+{
+    const RP_PRIMARY             = 'primary';
+    const RP_PRIMARY_PREFERRED   = 'primaryPreferred';
+    const RP_SECONDARY           = 'secondary';
+    const RP_SECONDARY_PREFERRED = 'secondaryPreferred';
+    const RP_NEAREST             = 'nearest';
+
+    private $readPreference;
+    private $tagSets;
+
+    /**
+     * @param string  $readPreference Read preference name
+     * @param array[] $tagSets        Array of zero or more tag sets (i.e. tag criteria)
+     */
+    public function __construct($readPreference, array $tagSets = null)
+    {
+        $this->readPreference = (string) $readPreference;
+        $this->tagSets = $tagSets;
+    }
+}
diff --git a/docs/api/MongoDB/Server.php b/docs/api/MongoDB/Server.php
new file mode 100644
index 000000000..3074d260a
--- /dev/null
+++ b/docs/api/MongoDB/Server.php
@@ -0,0 +1,190 @@
+<?php
+
+namespace MongoDB;
+
+use MongoDB\Command\Command;
+use MongoDB\Command\CommandResult;
+use MongoDB\Query\Query;
+use MongoDB\Query\QueryCursor;
+use MongoDB\Write\WriteBatch;
+use MongoDB\Write\WriteResult;
+
+/**
+ * Server abstracts a socket connection to a single MongoDB server. The server
+ * itself may be a mongod (stand-alone or replica set node) or mongos process.
+ *
+ * Users will typically not construct this class directly. The common use case
+ * will be connection to a cluster of servers via a URI with the Manager class.
+ *
+ * This class does not utilize read preferences, since there is only a single
+ * single socket on which to send a command, query, or write.
+ *
+ * Operation methods do not take socket-level options (e.g. socketTimeoutMS).
+ * Those options should be specified during construction.
+ */
+final class Server
+{
+    const TYPE_MONGOS     = 0x01;
+    const TYPE_STANDALONE = 0x02;
+    const TYPE_ARBITER    = 0x03;
+    const TYPE_SECONDARY  = 0x04;
+    const TYPE_PRIMARY    = 0x05;
+
+    private $host;
+    private $port;
+    private $options;
+    private $driverOptions;
+
+    /**
+     * @param string  $host          Server host
+     * @param integer $port          Server port
+     * @param array   $options       Connection options (e.g. auth, socket timeouts)
+     * @param array   $driverOptions Driver options (e.g. stream contexts)
+     */
+    public function __construct($host, $port, array $options = array(), array $driverOptions = array())
+    {
+        $this->host = (string) $host;
+        $this->port = (integer) $port;
+        $this->options = $options;
+        $this->driverOptions = $driverOptions;
+
+        /* Server connections may use a persistent socket connection. Sockets
+         * will need to be hashed by all relevant arguments, which likely means
+         * all of Server's constructor arguments. Argument arrays will need to 
+         * be normalized before we compute the hash (i.e. option order shouldn't
+         * matter).
+         *
+         * Actual socket connections should be created lazily.
+         */
+    }
+
+    /**
+     * @param string  $db
+     * @param Command $command
+     * @return CommandResult
+     */
+    public function executeCommand($db, Command $command)
+    {
+        /* This method does not take a ReadPreference. If connected to mongos,
+         * it the user's responsibility to set a read preference on the command
+         * document (if applicable).
+         */
+    }
+
+    /**
+     * @param string $namespace
+     * @param Query  $query
+     * @return QueryCursor
+     */
+    public function executeQuery($namespace, Query $query)
+    {
+        /* This method does not take a ReadPreference. If connected to mongos,
+         * it the user's responsibility to set a read preference on the command
+         * document (if applicable).
+         */
+    }
+
+    /**
+     * @param string     $namespace
+     * @param WriteBatch $batch
+     * @return WriteResult
+     */
+    public function executeWrite($namespace, WriteBatch $batch)
+    {
+        /* Write options are not taken as an argument, since they are specified
+         * during WriteBatch construction.
+         *
+         * On error, we should consider throwing:
+         *
+         *  - WriteException: write failed; a WriteResult should be included.
+         *  - ConnectionException: low-level socket error
+         *
+         * If a WriteException is thrown, its WriteResult may contain multiple
+         * write errors and write concern errors.
+         *
+         * What exception is used for sending a write to a secondary? Would that
+         * be a WriteException without a WriteResult attached?
+         */
+    }
+
+    public function getHost()
+    {
+        /* This does not return the host name from isMaster, since the "me"
+         * field is only present in replica set connections. There is also less
+         * value in providing the driver with the host name by which the server
+         * identifies (vs. the host name used to connect to it).
+         */
+        return $this->host;
+    }
+
+    /**
+     * @return array Connection metadata (e.g. min/maxWireVersion, RS hosts)
+     */
+    public function getInfo()
+    {
+        // Return last isMaster result document
+    }
+
+    /**
+     * @return integer Server latency in milliseconds
+     */
+    public function getLatency()
+    {
+        // Return last ping time in milliseconds (calculated value)
+    }
+
+    /**
+     * @return integer
+     */
+    public function getPort()
+    {
+        return $this->port;
+    }
+
+    /**
+     * @see http://docs.mongodb.org/manual/reference/replica-states/
+     * @return integer Replica set node state
+     */
+    public function getState()
+    {
+        /* Return the replica set node's state via replSetGetStatus
+         *
+         * We may want to create class constants for documented states.
+         *
+         * What should this return if the node isn't in a replica set?
+         */
+    }
+
+    /**
+     * @return integer Server type code
+     */
+    public function getType()
+    {
+        /* Return the server's current type code.
+         *
+         * The fact that Servers are mutable and this return value is subject to
+         * change is not a problem, as libmongoc should have its own snapshot of
+         * the cluster topology for evaluating read preferences.
+         */
+    }
+
+    public function isDelayed()
+    {
+        /* Return whether the secondary is delayed.
+         *
+         * What should this return for a node that isn't in a replica set? Isn't
+         * the actual delay time more useful than a boolean? This isn't reported
+         * in isMaster, so how do we calculate this short of reading the replica
+         * set configuration?
+         */
+    }
+
+    public function isPassive()
+    {
+        /* Return inferred value from isMaster data.
+         *
+         * Is this really useful in light of getInfo(), which provides the same
+         * information, and more?
+         */
+    }
+}
diff --git a/docs/api/MongoDB/Write/DeleteBatch.php b/docs/api/MongoDB/Write/DeleteBatch.php
new file mode 100644
index 000000000..177145b7b
--- /dev/null
+++ b/docs/api/MongoDB/Write/DeleteBatch.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Aggregates a collection of delete operations, to be executed in batches.
+ */
+final class DeleteBatch implements WriteBatch
+{
+    private $documents;
+
+    /**
+     * @see WriteBatch::add()
+     */
+    public function add($document)
+    {
+        $this->documents[] = $document;
+    }
+
+    /**
+     * @see Countable::count()
+     */
+    public function count()
+    {
+        return count($this->documents);
+    }
+}
diff --git a/docs/api/MongoDB/Write/DeleteResult.php b/docs/api/MongoDB/Write/DeleteResult.php
new file mode 100644
index 000000000..9b0fb215c
--- /dev/null
+++ b/docs/api/MongoDB/Write/DeleteResult.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Result returned by Server and Manager executeWrite() methods processing a
+ * DeleteBatch.
+ *
+ * This class may be constructed internally if it will encapsulate a libmongoc
+ * data structure.
+ */
+final class DeleteResult implements WriteResult
+{
+    /**
+     * @return integer
+     */
+    public function getNumRemoved() {}
+
+    /**
+     * @see WriteResult::getInfo()
+     */
+    public function getInfo() {}
+
+    /**
+     * @see WriteResult::getServer()
+     */
+    public function getServer() {}
+
+    /**
+     * @see WriteResult::getWriteConcernErrors()
+     */
+    public function getWriteConcernErrors() {}
+
+    /**
+     * @see WriteResult::getWriteErrors()
+     */
+    public function getWriteErrors() {}
+}
diff --git a/docs/api/MongoDB/Write/GeneratedId.php b/docs/api/MongoDB/Write/GeneratedId.php
new file mode 100644
index 000000000..bb7426b10
--- /dev/null
+++ b/docs/api/MongoDB/Write/GeneratedId.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Value object for a document identifier that was generated by the driver or
+ * server during an insert or upsert operation, respectively.
+ */
+final class GeneratedId
+{
+    private $id;
+    private $index;
+
+    /**
+     * @param mixed   $id    Document identifier
+     * @param integer $index Batch index of the corresponding operation
+     */
+    public function __construct($id, $index)
+    {
+        $this->id = $id;
+        $this->index = (integer) $index;
+    }
+
+    /**
+     * @return mixed Document identifier
+     */
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return integer Batch index of the corresponding operation
+     */
+    public function getIndex()
+    {
+        return $this->index;
+    }
+}
diff --git a/docs/api/MongoDB/Write/InsertBatch.php b/docs/api/MongoDB/Write/InsertBatch.php
new file mode 100644
index 000000000..a811008e5
--- /dev/null
+++ b/docs/api/MongoDB/Write/InsertBatch.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Aggregates a collection of insert operations, to be executed in batches.
+ */
+final class InsertBatch implements WriteBatch
+{
+    private $documents;
+
+    /**
+     * @see WriteBatch::add()
+     */
+    public function add($document)
+    {
+        $this->documents[] = $document;
+    }
+
+    /**
+     * @see Countable::count()
+     */
+    public function count()
+    {
+        return count($this->documents);
+    }
+}
diff --git a/docs/api/MongoDB/Write/InsertResult.php b/docs/api/MongoDB/Write/InsertResult.php
new file mode 100644
index 000000000..fc01261db
--- /dev/null
+++ b/docs/api/MongoDB/Write/InsertResult.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Result returned by Server and Manager executeWrite() methods processing an
+ * InsertBatch.
+ *
+ * This class may be constructed internally if it will encapsulate a libmongoc
+ * data structure.
+ */
+final class InsertResult implements WriteResult
+{
+    /**
+     * @return integer
+     */
+    public function getNumInserted() {}
+
+    /**
+     * @return GeneratedId[]
+     */
+    public function getGeneratedIds()
+    {
+        /* Return an array of identifiers generated by the driver. Each
+         * GeneratedId has a batch index and the ID value.
+         *
+         * This supersedes the identifier-setting hack in the 1.x driver.
+         */
+    }
+
+    /**
+     * @see WriteResult::getInfo()
+     */
+    public function getInfo() {}
+
+    /**
+     * @see WriteResult::getServer()
+     */
+    public function getServer() {}
+
+    /**
+     * @see WriteResult::getWriteConcernErrors()
+     */
+    public function getWriteConcernErrors() {}
+
+    /**
+     * @see WriteResult::getWriteErrors()
+     */
+    public function getWriteErrors() {}
+}
diff --git a/docs/api/MongoDB/Write/UpdateBatch.php b/docs/api/MongoDB/Write/UpdateBatch.php
new file mode 100644
index 000000000..8201c9f3a
--- /dev/null
+++ b/docs/api/MongoDB/Write/UpdateBatch.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Aggregates a collection of update operations, to be executed in batches.
+ */
+final class UpdateBatch implements WriteBatch
+{
+    private $documents;
+
+    /**
+     * @see WriteBatch::add()
+     */
+    public function add($document)
+    {
+        $this->documents[] = $document;
+    }
+
+    /**
+     * @see Countable::count()
+     */
+    public function count()
+    {
+        return count($this->documents);
+    }
+}
diff --git a/docs/api/MongoDB/Write/UpdateResult.php b/docs/api/MongoDB/Write/UpdateResult.php
new file mode 100644
index 000000000..cb5730e28
--- /dev/null
+++ b/docs/api/MongoDB/Write/UpdateResult.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Result returned by Server and Manager executeWrite() methods processing an
+ * UpdateBatch.
+ *
+ * This class may be constructed internally if it will encapsulate a libmongoc
+ * data structure.
+ */
+final class UpdateResult implements WriteResult
+{
+    /**
+     * @return integer
+     */
+    public function getNumMatched() {}
+
+    /**
+     * @return integer
+     */
+    public function getNumModified() {}
+
+    /**
+     * @return integer
+     */
+    public function getNumUpserted() {}
+
+    /**
+     * @return GeneratedId[]
+     */
+    public function getUpserts()
+    {
+        /* Return an array of identifiers upserted by the server. Each
+         * GeneratedId has a batch index and the ID value.
+         */
+    }
+
+    /**
+     * @see WriteResult::getInfo()
+     */
+    public function getInfo() {}
+
+    /**
+     * @see WriteResult::getServer()
+     */
+    public function getServer() {}
+
+    /**
+     * @see WriteResult::getWriteConcernErrors()
+     */
+    public function getWriteConcernErrors() {}
+
+    /**
+     * @see WriteResult::getWriteErrors()
+     */
+    public function getWriteErrors() {}
+}
diff --git a/docs/api/MongoDB/Write/WriteBatch.php b/docs/api/MongoDB/Write/WriteBatch.php
new file mode 100644
index 000000000..d8f3ddedc
--- /dev/null
+++ b/docs/api/MongoDB/Write/WriteBatch.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace MongoDB\Write;
+
+interface WriteBatch extends \Countable
+{
+    /**
+     * @param array|object $document Operation/document to add to the batch
+     */
+    function add($document);
+}
diff --git a/docs/api/MongoDB/Write/WriteConcernError.php b/docs/api/MongoDB/Write/WriteConcernError.php
new file mode 100644
index 000000000..5f510f22e
--- /dev/null
+++ b/docs/api/MongoDB/Write/WriteConcernError.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Value object for a write concern error.
+ */
+final class WriteConcernError
+{
+    private $message;
+    private $code;
+    private $info;
+
+    /**
+     * @param string  $message Server error message
+     * @param integer $code    Server error code
+     * @param array   $info    Additional metadat for the error (e.g. {"wtimeout": true})
+     */
+    public function __construct($message, $code, array $info)
+    {
+        $this->message = (string) $message;
+        $this->code = (integer) $code;
+        $this->info = $info;
+    }
+
+    /**
+     * @return integer Server error code
+     */
+    public function getCode()
+    {
+        return $this->code;
+    }
+
+    /**
+     * @return array Additional metadata for the error (e.g. {"wtimeout": true})
+     */
+    public function getInfo()
+    {
+        return $this->info;
+    }
+
+    /**
+     * @return string Server error message
+     */
+    public function getMessage()
+    {
+        return $this-message;
+    }
+}
diff --git a/docs/api/MongoDB/Write/WriteError.php b/docs/api/MongoDB/Write/WriteError.php
new file mode 100644
index 000000000..497cc52fd
--- /dev/null
+++ b/docs/api/MongoDB/Write/WriteError.php
@@ -0,0 +1,60 @@
+<?php
+
+namespace MongoDB\Write;
+
+/**
+ * Value object for a write error (e.g. duplicate key).
+ */
+final class WriteError
+{
+    private $message;
+    private $code;
+    private $index;
+    private $operation;
+
+    /**
+     * @param string       $message   Server error message
+     * @param integer      $code      Server error code
+     * @param integer      $index     Batch index of the error
+     * @param array|object $operation Operation or document responsible for the error
+     */
+    public function __construct($message, $code, $index, $operation)
+    {
+        $this->message = (string) $message;
+        $this->code = (integer) $code;
+        $this->index = (integer) $index;
+        $this->operation = $operation;
+    }
+
+    /**
+     * @return integer Server error code
+     */
+    public function getCode()
+    {
+        return $this->code;
+    }
+
+    /**
+     * @return integer Batch index of the error
+     */
+    public function getIndex()
+    {
+        return $this->index;
+    }
+
+    /**
+     * @return string Server error message
+     */
+    public function getMessage()
+    {
+        return $this-message;
+    }
+
+    /**
+     * @return array|object Operation or document responsible for the error
+     */
+    public function getOperation()
+    {
+        return $this->operation;
+    }
+}
diff --git a/docs/api/MongoDB/Write/WriteResult.php b/docs/api/MongoDB/Write/WriteResult.php
new file mode 100644
index 000000000..946b964a1
--- /dev/null
+++ b/docs/api/MongoDB/Write/WriteResult.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace MongoDB\Write;
+
+interface WriteResult
+{
+    /**
+     * @see https://github.com/mongodb/specifications/blob/master/source/server_write_commands.rst#situational-fields
+     * @return array Additional metadata for the operation(s) (e.g. lastOp)
+     */
+    function getInfo();
+
+    /**
+     * @return Server Server from which the result originated
+     */
+    function getServer();
+
+    /**
+     * @return WriteConcernError[]
+     */
+    function getWriteConcernErrors();
+
+    /**
+     * @return WriteError[]
+     */
+    function getWriteErrors();
+}