MongoDB Java Driver

import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

// Connect to MongoDB
MongoClient mongoClient = new MongoClient("localhost", 27017);
MongoDatabase database = mongoClient.getDatabase("mydb");
MongoCollection<Document> collection = database.getCollection("users");

// Insert a document
Document user = new Document("name", "Alice")
    .append("age", 30)
    .append("email", "alice@example.com");
collection.insertOne(user);

// Find documents
for (Document doc : collection.find()) {
    System.out.println(doc.toJson());
}

// Close connection
mongoClient.close();

// Legacy MongoClient (extends Mongo class)
public class MongoClient extends Mongo implements Closeable {
    public MongoClient();
    public MongoClient(String host);
    public MongoClient(String host, int port);
    public MongoClient(ServerAddress addr);
    public MongoClient(List<ServerAddress> seeds);
    public MongoClient(MongoClientURI uri);
    
    public MongoDatabase getDatabase(String databaseName);
    public MongoIterable<String> listDatabaseNames();
    public void close();
}

// Modern client factory (recommended)
public final class MongoClients {
    public static MongoClient create();
    public static MongoClient create(String connectionString);
    public static MongoClient create(ConnectionString connectionString);
    public static MongoClient create(MongoClientSettings settings);
    public static MongoClient create(ConnectionString connectionString, MongoDriverInformation mongoDriverInformation);
    public static MongoClient create(MongoClientSettings settings, MongoDriverInformation mongoDriverInformation);
}

public interface MongoDatabase {
    String getName();
    MongoCollection<Document> getCollection(String collectionName);
    <TDocument> MongoCollection<TDocument> getCollection(String collectionName, Class<TDocument> documentClass);
    
    void createCollection(String collectionName);
    void createCollection(String collectionName, CreateCollectionOptions options);
    MongoIterable<String> listCollectionNames();
    ListCollectionsIterable<Document> listCollections();
    
    Document runCommand(Bson command);
    void drop();
}

public interface MongoCollection<TDocument> {
    // Insert operations
    void insertOne(TDocument document);
    void insertMany(List<? extends TDocument> documents);
    
    // Query operations  
    FindIterable<TDocument> find();
    FindIterable<TDocument> find(Bson filter);
    TDocument findOne(Bson filter);
    
    // Update operations
    UpdateResult updateOne(Bson filter, Bson update);
    UpdateResult updateMany(Bson filter, Bson update);
    UpdateResult replaceOne(Bson filter, TDocument replacement);
    
    // Delete operations
    DeleteResult deleteOne(Bson filter);
    DeleteResult deleteMany(Bson filter);
    
    // Count operations
    long count();
    long countDocuments();
    long estimatedDocumentCount();
}

// Filter builders
public final class Filters {
    public static Bson eq(String fieldName, Object value);
    public static Bson ne(String fieldName, Object value);
    public static Bson gt(String fieldName, Object value);
    public static Bson gte(String fieldName, Object value);
    public static Bson lt(String fieldName, Object value);
    public static Bson lte(String fieldName, Object value);
    public static Bson in(String fieldName, Object... values);
    public static Bson and(Bson... filters);
    public static Bson or(Bson... filters);
}

// Update builders  
public final class Updates {
    public static Bson set(String fieldName, Object value);
    public static Bson inc(String fieldName, Number amount);
    public static Bson push(String fieldName, Object value);
    public static Bson pull(String fieldName, Object value);
}

public interface MongoCollection<TDocument> {
    AggregateIterable<TDocument> aggregate(List<? extends Bson> pipeline);
    <TResult> AggregateIterable<TResult> aggregate(List<? extends Bson> pipeline, Class<TResult> resultClass);
}

public final class Aggregates {
    public static Bson match(Bson filter);
    public static Bson project(Bson projection);
    public static Bson sort(Bson sort);
    public static Bson group(Object id, BsonField... fieldAccumulators);
    public static Bson lookup(String from, String localField, String foreignField, String as);
    public static Bson unwind(String fieldName);
}

public interface GridFSBucket {
    ObjectId uploadFromStream(String filename, InputStream source);
    void downloadToStream(ObjectId id, OutputStream destination);
    
    GridFSUploadStream openUploadStream(String filename);
    GridFSDownloadStream openDownloadStream(ObjectId id);
    
    GridFSFindIterable find();
    void delete(ObjectId id);
    void rename(ObjectId id, String newFilename);
}

public final class GridFSBuckets {
    public static GridFSBucket create(MongoDatabase database);
    public static GridFSBucket create(MongoDatabase database, String bucketName);
}

public interface MongoClient {
    ChangeStreamIterable<Document> watch();
    ChangeStreamIterable<Document> watch(List<? extends Bson> pipeline);
    <TResult> ChangeStreamIterable<TResult> watch(List<? extends Bson> pipeline, Class<TResult> resultClass);
}

public interface ChangeStreamIterable<TResult> extends MongoIterable<ChangeStreamDocument<TResult>> {
    ChangeStreamIterable<TResult> fullDocument(FullDocument fullDocument);
    ChangeStreamIterable<TResult> resumeAfter(BsonDocument resumeToken);
    ChangeStreamIterable<TResult> startAfter(BsonDocument startAfter);
    ChangeStreamIterable<TResult> maxAwaitTime(long maxAwaitTime, TimeUnit timeUnit);
}

public interface MongoClient {
    ClientSession startSession();
    ClientSession startSession(ClientSessionOptions options);
}

public interface ClientSession extends Closeable {
    void startTransaction();
    void startTransaction(TransactionOptions transactionOptions);
    void commitTransaction();
    void abortTransaction();
    
    <T> T withTransaction(TransactionBody<T> transactionBody);
    
    BsonTimestamp getOperationTime();
    BsonDocument getClusterTime();
}

// Flexible document representation
public class Document extends LinkedHashMap<String, Object> {
    public Document();
    public Document(String key, Object value);
    public Document append(String key, Object value);
    
    public String toJson();
    public static Document parse(String json);
}

// Type-safe BSON document
public class BsonDocument extends BsonValue implements Map<String, BsonValue> {
    public BsonDocument();
    public BsonDocument append(String key, BsonValue value);
    public BsonValue get(Object key);
}

// BSON value hierarchy
public abstract class BsonValue {
    public abstract BsonType getBsonType();
    public boolean isString();
    public boolean isDocument();
    public BsonString asString();
    public BsonDocument asDocument();
}

public final class MongoCredential {
    public static MongoCredential createCredential(String userName, String database, char[] password);
    public static MongoCredential createScramSha1Credential(String userName, String source, char[] password);
    public static MongoCredential createScramSha256Credential(String userName, String source, char[] password);
    public static MongoCredential createMongoX509Credential(String userName);
    public static MongoCredential createGSSAPICredential(String userName);
}

// Client-side encryption
public interface ClientEncryption extends Closeable {
    BsonBinary encrypt(BsonValue value, EncryptOptions options);
    BsonValue decrypt(BsonBinary encryptedValue);
    BsonBinary createDataKey(String kmsProvider);
}

public final class MongoClientOptions {
    public static Builder builder();
    
    public static final class Builder {
        public Builder connectionsPerHost(int connectionsPerHost);
        public Builder connectTimeout(int connectTimeout);
        public Builder socketTimeout(int socketTimeout);
        public Builder readPreference(ReadPreference readPreference);
        public Builder writeConcern(WriteConcern writeConcern);
        public Builder codecRegistry(CodecRegistry codecRegistry);
        public MongoClientOptions build();
    }
}

// Read preferences
public abstract class ReadPreference {
    public static ReadPreference primary();
    public static ReadPreference secondary();
    public static ReadPreference secondaryPreferred();
    public static ReadPreference nearest();
}

// Write concerns
public class WriteConcern {
    public static final WriteConcern ACKNOWLEDGED;
    public static final WriteConcern UNACKNOWLEDGED;
    public static final WriteConcern MAJORITY;
}