couchbase 3.3.0 → 3.4.0

data/ext/couchbase/test/test_integration_management.cxx

@@ -17,21 +17,26 @@
 
 #include "test_helper_integration.hxx"
 
-#include <couchbase/management/analytics_link.hxx>
-#include <couchbase/operations/management/analytics.hxx>
-#include <couchbase/operations/management/bucket.hxx>
-#include <couchbase/operations/management/collections.hxx>
-#include <couchbase/operations/management/eventing.hxx>
-#include <couchbase/operations/management/freeform.hxx>
-#include <couchbase/operations/management/query.hxx>
-#include <couchbase/operations/management/search.hxx>
-#include <couchbase/operations/management/user.hxx>
-
-static couchbase::operations::management::bucket_get_response
+#include "core/management/analytics_link.hxx"
+#include "core/operations/management/analytics.hxx"
+#include "core/operations/management/bucket.hxx"
+#include "core/operations/management/collections.hxx"
+#include "core/operations/management/eventing.hxx"
+#include "core/operations/management/freeform.hxx"
+#include "core/operations/management/query.hxx"
+#include "core/operations/management/search.hxx"
+#include "core/operations/management/user.hxx"
+#include "couchbase/cluster.hxx"
+#include "couchbase/create_primary_query_index_options.hxx"
+#include "couchbase/create_query_index_options.hxx"
+#include "couchbase/drop_query_index_options.hxx"
+#include "couchbase/watch_query_indexes_options.hxx"
+
+static couchbase::core::operations::management::bucket_get_response
 wait_for_bucket_created(test::utils::integration_test_guard& integration, const std::string& bucket_name)
 {
     test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name);
-    couchbase::operations::management::bucket_get_request req{ bucket_name };
+    couchbase::core::operations::management::bucket_get_request req{ bucket_name };
     auto resp = test::utils::execute(integration.cluster, req);
     return resp;
 }
@@ -53,6 +58,10 @@ TEST_CASE("integration: bucket management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_bucket_management()) {
+        return;
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -61,30 +70,30 @@ TEST_CASE("integration: bucket management", "[integration]")
 
     SECTION("crud")
     {
-        couchbase::management::cluster::bucket_settings bucket_settings;
+        couchbase::core::management::cluster::bucket_settings bucket_settings;
         bucket_settings.name = bucket_name;
         bucket_settings.ram_quota_mb = 100;
         bucket_settings.num_replicas = 1;
-        bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
-        bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::value_only;
+        bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
+        bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::value_only;
         bucket_settings.flush_enabled = true;
         if (integration.cluster_version().is_enterprise()) {
             bucket_settings.max_expiry = 10;
-            bucket_settings.compression_mode = couchbase::management::cluster::bucket_compression::active;
+            bucket_settings.compression_mode = couchbase::core::management::cluster::bucket_compression::active;
         }
         bucket_settings.replica_indexes = true;
-        bucket_settings.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::sequence_number;
+        bucket_settings.conflict_resolution_type = couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number;
 
         {
-            couchbase::operations::management::bucket_create_request req;
+            couchbase::core::operations::management::bucket_create_request req;
             req.bucket = bucket_settings;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
             auto resp = wait_for_bucket_created(integration, bucket_name);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(bucket_settings.bucket_type == resp.bucket.bucket_type);
             REQUIRE(bucket_settings.name == resp.bucket.name);
             REQUIRE(Approx(bucket_settings.ram_quota_mb).margin(5) == resp.bucket.ram_quota_mb);
@@ -97,10 +106,10 @@ TEST_CASE("integration: bucket management", "[integration]")
         }
         std::uint64_t old_quota_mb{ 0 };
         {
-            couchbase::operations::management::bucket_get_all_request req{};
+            couchbase::core::operations::management::bucket_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
             INFO(resp.ctx.http_body)
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             bool found = false;
             for (const auto& bucket : resp.buckets) {
                 if (bucket.name != bucket_name) {
@@ -124,38 +133,38 @@ TEST_CASE("integration: bucket management", "[integration]")
 
         {
             bucket_settings.ram_quota_mb = old_quota_mb + 20;
-            couchbase::operations::management::bucket_update_request req;
+            couchbase::core::operations::management::bucket_update_request req;
             req.bucket = bucket_settings;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         auto ram_quota_updated = test::utils::wait_until([&integration, &bucket_name, old_quota_mb]() {
-            couchbase::operations::management::bucket_get_request req{ bucket_name };
+            couchbase::core::operations::management::bucket_get_request req{ bucket_name };
             auto resp = test::utils::execute(integration.cluster, req);
             return !resp.ctx.ec && resp.bucket.ram_quota_mb > old_quota_mb;
         });
         REQUIRE(ram_quota_updated);
 
         {
-            couchbase::operations::management::bucket_drop_request req{ bucket_name };
+            couchbase::core::operations::management::bucket_drop_request req{ bucket_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::bucket_get_request req{ bucket_name };
+            couchbase::core::operations::management::bucket_get_request req{ bucket_name };
             auto resp = retry_on_error(integration, req, {});
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::bucket_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
         }
 
         {
-            couchbase::operations::management::bucket_get_all_request req;
+            couchbase::core::operations::management::bucket_get_all_request req;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(!resp.buckets.empty());
             auto known_buckets =
-              std::count_if(resp.buckets.begin(), resp.buckets.end(), [bucket_name](auto& entry) { return entry.name == bucket_name; });
+              std::count_if(resp.buckets.begin(), resp.buckets.end(), [&bucket_name](auto& entry) { return entry.name == bucket_name; });
             REQUIRE(known_buckets == 0);
         }
     }
@@ -164,14 +173,14 @@ TEST_CASE("integration: bucket management", "[integration]")
     {
         SECTION("flush item")
         {
-            couchbase::document_id id{ bucket_name, "_default", "_default", test::utils::uniq_id("foo") };
+            couchbase::core::document_id id{ bucket_name, "_default", "_default", test::utils::uniq_id("foo") };
 
             {
-                couchbase::operations::management::bucket_create_request req;
+                couchbase::core::operations::management::bucket_create_request req;
                 req.bucket.name = bucket_name;
                 req.bucket.flush_enabled = true;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
@@ -182,114 +191,115 @@ TEST_CASE("integration: bucket management", "[integration]")
                 const tao::json::value value = {
                     { "a", 1.0 },
                 };
-                couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+                couchbase::core::operations::insert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec());
             }
 
             {
-                couchbase::operations::get_request req{ id };
+                couchbase::core::operations::get_request req{ id };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec());
             }
 
             {
-                couchbase::operations::management::bucket_flush_request req{ bucket_name };
+                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             auto flushed = test::utils::wait_until([&integration, id]() {
-                couchbase::operations::get_request req{ id };
+                couchbase::core::operations::get_request req{ id };
                 auto resp = test::utils::execute(integration.cluster, req);
-                return resp.ctx.ec == couchbase::error::key_value_errc::document_not_found;
+                return resp.ctx.ec() == couchbase::errc::key_value::document_not_found;
             });
             REQUIRE(flushed);
         }
 
         SECTION("no bucket")
         {
-            couchbase::operations::management::bucket_flush_request req{ bucket_name };
+            couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::bucket_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
         }
 
         SECTION("flush disabled")
         {
             {
-                couchbase::operations::management::bucket_create_request req;
+                couchbase::core::operations::management::bucket_create_request req;
                 req.bucket.name = bucket_name;
                 req.bucket.flush_enabled = false;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
 
             {
-                couchbase::operations::management::bucket_flush_request req{ bucket_name };
+                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE(resp.ctx.ec == couchbase::error::management_errc::bucket_not_flushable);
+                REQUIRE(resp.ctx.ec == couchbase::errc::management::bucket_not_flushable);
             }
         }
     }
 
-    SECTION("memcached")
-    {
+    if (integration.cluster_version().supports_memcached_buckets()) {
+        SECTION("memcached")
         {
-            couchbase::management::cluster::bucket_settings bucket_settings;
-            bucket_settings.name = bucket_name;
-            bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::memcached;
-            bucket_settings.num_replicas = 0;
-            couchbase::operations::management::bucket_create_request req{ bucket_settings };
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            {
+                couchbase::core::management::cluster::bucket_settings bucket_settings;
+                bucket_settings.name = bucket_name;
+                bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
+                bucket_settings.num_replicas = 0;
+                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        {
-            auto resp = wait_for_bucket_created(integration, bucket_name);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::memcached);
+            {
+                auto resp = wait_for_bucket_created(integration, bucket_name);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::memcached);
+            }
         }
     }
 
     SECTION("ephemeral")
     {
-        couchbase::management::cluster::bucket_settings bucket_settings;
+        couchbase::core::management::cluster::bucket_settings bucket_settings;
         bucket_settings.name = bucket_name;
-        bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::ephemeral;
+        bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
 
         SECTION("default eviction")
         {
             {
-                couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                 auto resp = test::utils::execute(integration.cluster, req);
-                INFO(resp.error_message)
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
                 auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_FALSE(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::ephemeral);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::no_eviction);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
+                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::no_eviction);
             }
         }
 
         SECTION("nru eviction")
         {
             {
-                bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::not_recently_used;
-                couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used;
+                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
                 auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_FALSE(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::ephemeral);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::not_recently_used);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
+                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used);
             }
         }
 
@@ -297,17 +307,17 @@ TEST_CASE("integration: bucket management", "[integration]")
             SECTION("storage backend")
             {
                 {
-                    bucket_settings.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
-                    couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                    bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                     auto resp = test::utils::execute(integration.cluster, req);
-                    REQUIRE_FALSE(resp.ctx.ec);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
                 }
 
                 {
                     auto resp = wait_for_bucket_created(integration, bucket_name);
-                    REQUIRE_FALSE(resp.ctx.ec);
-                    REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::ephemeral);
-                    REQUIRE(resp.bucket.storage_backend == couchbase::management::cluster::bucket_storage_backend::unknown);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
+                    REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::unknown);
                 }
             }
         }
@@ -315,42 +325,41 @@ TEST_CASE("integration: bucket management", "[integration]")
 
     SECTION("couchbase")
     {
-        couchbase::management::cluster::bucket_settings bucket_settings;
+        couchbase::core::management::cluster::bucket_settings bucket_settings;
         bucket_settings.name = bucket_name;
-        bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
+        bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
 
         SECTION("default eviction")
         {
             {
 
-                couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                 auto resp = test::utils::execute(integration.cluster, req);
-                INFO(resp.error_message)
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
                 auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_FALSE(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::value_only);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::value_only);
             }
         }
 
         SECTION("full eviction")
         {
             {
-                bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::full;
-                couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::full;
+                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
                 auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_FALSE(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::full);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::full);
             }
         }
 
@@ -360,35 +369,35 @@ TEST_CASE("integration: bucket management", "[integration]")
                 SECTION("couchstore")
                 {
                     {
-                        bucket_settings.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
-                        couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                        bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+                        couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                         auto resp = test::utils::execute(integration.cluster, req);
-                        REQUIRE_FALSE(resp.ctx.ec);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
                     }
 
                     {
                         auto resp = wait_for_bucket_created(integration, bucket_name);
-                        REQUIRE_FALSE(resp.ctx.ec);
-                        REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
-                        REQUIRE(resp.bucket.storage_backend == couchbase::management::cluster::bucket_storage_backend::couchstore);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
+                        REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                        REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::couchstore);
                     }
                 }
 
                 SECTION("magma")
                 {
                     {
-                        bucket_settings.ram_quota_mb = 256;
-                        bucket_settings.storage_backend = couchbase::management::cluster::bucket_storage_backend::magma;
-                        couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                        bucket_settings.ram_quota_mb = integration.cluster_version().is_neo() ? 1'024 : 256;
+                        bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::magma;
+                        couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                         auto resp = test::utils::execute(integration.cluster, req);
-                        REQUIRE_FALSE(resp.ctx.ec);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
                     }
 
                     {
                         auto resp = wait_for_bucket_created(integration, bucket_name);
-                        REQUIRE_FALSE(resp.ctx.ec);
-                        REQUIRE(resp.bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
-                        REQUIRE(resp.bucket.storage_backend == couchbase::management::cluster::bucket_storage_backend::magma);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
+                        REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                        REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::magma);
                     }
                 }
             }
@@ -398,32 +407,32 @@ TEST_CASE("integration: bucket management", "[integration]")
     SECTION("update no bucket")
     {
 
-        couchbase::management::cluster::bucket_settings bucket_settings;
+        couchbase::core::management::cluster::bucket_settings bucket_settings;
         bucket_settings.name = bucket_name;
-        couchbase::operations::management::bucket_update_request req;
+        couchbase::core::operations::management::bucket_update_request req;
         req.bucket = bucket_settings;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::bucket_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
     }
 
     if (integration.cluster_version().supports_minimum_durability_level()) {
         SECTION("minimum durability level")
         {
-            couchbase::management::cluster::bucket_settings bucket_settings;
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
             bucket_settings.name = bucket_name;
 
             SECTION("default")
             {
                 {
-                    couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                     auto resp = test::utils::execute(integration.cluster, req);
-                    REQUIRE_FALSE(resp.ctx.ec);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
                 }
 
                 {
                     auto resp = wait_for_bucket_created(integration, bucket_name);
-                    REQUIRE_FALSE(resp.ctx.ec);
-                    REQUIRE(resp.bucket.minimum_durability_level == couchbase::protocol::durability_level::none);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.bucket.minimum_durability_level == couchbase::durability_level::none);
                 }
             }
 
@@ -431,17 +440,16 @@ TEST_CASE("integration: bucket management", "[integration]")
                 SECTION("majority")
                 {
                     {
-                        bucket_settings.minimum_durability_level = couchbase::protocol::durability_level::majority;
-                        couchbase::operations::management::bucket_create_request req{ bucket_settings };
+                        bucket_settings.minimum_durability_level = couchbase::durability_level::majority;
+                        couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                         auto resp = test::utils::execute(integration.cluster, req);
-                        INFO(resp.error_message)
-                        REQUIRE_FALSE(resp.ctx.ec);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
                     }
 
                     {
                         auto resp = wait_for_bucket_created(integration, bucket_name);
-                        REQUIRE_FALSE(resp.ctx.ec);
-                        REQUIRE(resp.bucket.minimum_durability_level == couchbase::protocol::durability_level::majority);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
+                        REQUIRE(resp.bucket.minimum_durability_level == couchbase::durability_level::majority);
                     }
                 }
             }
@@ -452,37 +460,37 @@ TEST_CASE("integration: bucket management", "[integration]")
 
     // drop bucket if not already dropped
     {
-        couchbase::operations::management::bucket_drop_request req{ bucket_name };
+        couchbase::core::operations::management::bucket_drop_request req{ bucket_name };
         test::utils::execute(integration.cluster, req);
     }
 }
 
-bool
-collection_exists(std::shared_ptr<couchbase::cluster> cluster,
-                  const std::string& bucket_name,
-                  const std::string& scope_name,
-                  const std::string& collection_name)
+std::optional<couchbase::core::topology::collections_manifest::collection>
+get_collection(std::shared_ptr<couchbase::core::cluster> cluster,
+               const std::string& bucket_name,
+               const std::string& scope_name,
+               const std::string& collection_name)
 {
-    couchbase::operations::management::scope_get_all_request req{ bucket_name };
+    couchbase::core::operations::management::scope_get_all_request req{ bucket_name };
     auto resp = test::utils::execute(cluster, req);
     if (!resp.ctx.ec) {
         for (const auto& scope : resp.manifest.scopes) {
             if (scope.name == scope_name) {
                 for (const auto& collection : scope.collections) {
                     if (collection.name == collection_name) {
-                        return true;
+                        return collection;
                     }
                 }
             }
         }
     }
-    return false;
+    return std::nullopt;
 }
 
 bool
-scope_exists(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name, const std::string& scope_name)
+scope_exists(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name, const std::string& scope_name)
 {
-    couchbase::operations::management::scope_get_all_request req{ bucket_name };
+    couchbase::core::operations::management::scope_get_all_request req{ bucket_name };
     auto resp = test::utils::execute(cluster, req);
     if (!resp.ctx.ec) {
         for (const auto& scope : resp.manifest.scopes) {
@@ -497,6 +505,7 @@ scope_exists(std::shared_ptr<couchbase::cluster> cluster, const std::string& buc
 TEST_CASE("integration: collection management", "[integration]")
 {
     test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
         return;
@@ -504,11 +513,14 @@ TEST_CASE("integration: collection management", "[integration]")
 
     auto scope_name = test::utils::uniq_id("scope");
     auto collection_name = test::utils::uniq_id("collection");
+    std::uint32_t max_expiry = 5;
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
     {
@@ -517,56 +529,66 @@ TEST_CASE("integration: collection management", "[integration]")
     }
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::management_errc::scope_exists);
+        REQUIRE(resp.ctx.ec == couchbase::errc::management::scope_exists);
     }
 
     {
-        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         if (integration.cluster_version().is_enterprise()) {
-            req.max_expiry = 5;
+            req.max_expiry = max_expiry;
         }
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
     {
-        auto created = test::utils::wait_until(
-          [&]() { return collection_exists(integration.cluster, integration.ctx.bucket, scope_name, collection_name); });
+        couchbase::core::topology::collections_manifest::collection collection;
+        auto created = test::utils::wait_until([&]() {
+            auto coll = get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name);
+            if (coll) {
+                collection = *coll;
+                return true;
+            }
+            return false;
+        });
         REQUIRE(created);
+        if (integration.cluster_version().is_enterprise()) {
+            REQUIRE(collection.max_expiry == max_expiry);
+        }
     }
 
-    // TODO: Check collection was created with correct max expiry when supported
-
     {
-        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::management_errc::collection_exists);
+        REQUIRE(resp.ctx.ec == couchbase::errc::management::collection_exists);
     }
 
     {
-        couchbase::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
         auto dropped = test::utils::wait_until(
-          [&]() { return !collection_exists(integration.cluster, integration.ctx.bucket, scope_name, collection_name); });
+          [&]() { return !get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name).has_value(); });
         REQUIRE(dropped);
     }
 
     {
-        couchbase::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::collection_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::collection_not_found);
     }
 
     {
-        couchbase::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
@@ -575,15 +597,15 @@ TEST_CASE("integration: collection management", "[integration]")
     }
 
     {
-        couchbase::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::scope_not_found);
     }
 }
 
 void
-assert_user_and_metadata(const couchbase::management::rbac::user_and_metadata& user,
-                         const couchbase::management::rbac::user_and_metadata& expected)
+assert_user_and_metadata(const couchbase::core::management::rbac::user_and_metadata& user,
+                         const couchbase::core::management::rbac::user_and_metadata& expected)
 {
     REQUIRE(user.username == expected.username);
     REQUIRE(user.groups == expected.groups);
@@ -634,23 +656,23 @@ TEST_CASE("integration: user groups management", "[integration]")
         auto group_name_1 = test::utils::uniq_id("group");
         auto group_name_2 = test::utils::uniq_id("group");
 
-        couchbase::management::rbac::group group{};
+        couchbase::core::management::rbac::group group{};
         group.name = group_name_1;
         group.description = "this is a test";
-        group.roles = { couchbase::management::rbac::role{ "replication_target", integration.ctx.bucket },
-                        couchbase::management::rbac::role{ "replication_admin" } };
+        group.roles = { couchbase::core::management::rbac::role{ "replication_target", integration.ctx.bucket },
+                        couchbase::core::management::rbac::role{ "replication_admin" } };
         group.ldap_group_reference = "asda=price";
 
         {
-            couchbase::operations::management::group_upsert_request req{ group };
+            couchbase::core::operations::management::group_upsert_request req{ group };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::group_get_request req{ group_name_1 };
-            auto resp = retry_on_error(integration, req, couchbase::error::management_errc::group_not_found);
-            REQUIRE_FALSE(resp.ctx.ec);
+            couchbase::core::operations::management::group_get_request req{ group_name_1 };
+            auto resp = retry_on_error(integration, req, couchbase::errc::management::group_not_found);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.group.name == group.name);
             REQUIRE(resp.group.description == group.description);
             REQUIRE(resp.group.ldap_group_reference == group.ldap_group_reference);
@@ -658,15 +680,15 @@ TEST_CASE("integration: user groups management", "[integration]")
 
         {
             group.description = "this is still a test";
-            group.roles.push_back(couchbase::management::rbac::role{ "query_system_catalog" });
-            couchbase::operations::management::group_upsert_request req{ group };
+            group.roles.push_back(couchbase::core::management::rbac::role{ "query_system_catalog" });
+            couchbase::core::operations::management::group_upsert_request req{ group };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
             auto updated = test::utils::wait_until([&]() {
-                couchbase::operations::management::group_get_request req{ group_name_1 };
+                couchbase::core::operations::management::group_get_request req{ group_name_1 };
                 auto resp = test::utils::execute(integration.cluster, req);
                 return !resp.ctx.ec && resp.group.description == group.description;
             });
@@ -675,53 +697,53 @@ TEST_CASE("integration: user groups management", "[integration]")
 
         {
             group.name = group_name_2;
-            couchbase::operations::management::group_upsert_request req{ group };
+            couchbase::core::operations::management::group_upsert_request req{ group };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
             auto created = test::utils::wait_until([&]() {
-                couchbase::operations::management::group_get_all_request req{ group_name_2 };
+                couchbase::core::operations::management::group_get_all_request req{ group_name_2 };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
                 return resp.groups.size() == 2;
             });
             REQUIRE(created);
         }
 
         {
-            couchbase::operations::management::role_get_all_request req{};
+            couchbase::core::operations::management::role_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.roles.size() > 0);
         }
 
         {
-            couchbase::operations::management::group_drop_request req{ group_name_1 };
+            couchbase::core::operations::management::group_drop_request req{ group_name_1 };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::group_drop_request req{ group_name_2 };
+            couchbase::core::operations::management::group_drop_request req{ group_name_2 };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
     }
 
     SECTION("get missing group")
     {
-        couchbase::operations::management::group_get_request req{ test::utils::uniq_id("group") };
+        couchbase::core::operations::management::group_get_request req{ test::utils::uniq_id("group") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::management_errc::group_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::management::group_not_found);
     }
 
     SECTION("drop missing group")
     {
-        couchbase::operations::management::group_drop_request req{ test::utils::uniq_id("group") };
+        couchbase::core::operations::management::group_drop_request req{ test::utils::uniq_id("group") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::management_errc::group_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::management::group_not_found);
     }
 
     SECTION("user and groups crud")
@@ -729,60 +751,60 @@ TEST_CASE("integration: user groups management", "[integration]")
         auto group_name = test::utils::uniq_id("group");
         auto user_name = test::utils::uniq_id("user");
 
-        couchbase::management::rbac::group group{};
+        couchbase::core::management::rbac::group group{};
         group.name = group_name;
         group.description = "this is a test";
-        group.roles = { couchbase::management::rbac::role{ "replication_target", integration.ctx.bucket },
-                        couchbase::management::rbac::role{ "replication_admin" } };
+        group.roles = { couchbase::core::management::rbac::role{ "replication_target", integration.ctx.bucket },
+                        couchbase::core::management::rbac::role{ "replication_admin" } };
 
         {
-            couchbase::operations::management::group_upsert_request req{ group };
+            couchbase::core::operations::management::group_upsert_request req{ group };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        couchbase::management::rbac::user user{ user_name };
+        couchbase::core::management::rbac::user user{ user_name };
         user.display_name = "display_name";
         user.password = "password";
         user.roles = {
-            couchbase::management::rbac::role{ "bucket_admin", integration.ctx.bucket },
+            couchbase::core::management::rbac::role{ "bucket_admin", integration.ctx.bucket },
         };
         user.groups = { group_name };
 
         {
-            couchbase::operations::management::user_upsert_request req{};
+            couchbase::core::operations::management::user_upsert_request req{};
             req.user = user;
-            auto resp = retry_on_error(integration, req, couchbase::error::common_errc::invalid_argument);
-            REQUIRE_FALSE(resp.ctx.ec);
+            auto resp = retry_on_error(integration, req, couchbase::errc::common::invalid_argument);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        couchbase::management::rbac::user_and_metadata expected{};
+        couchbase::core::management::rbac::user_and_metadata expected{};
         expected.username = user.username;
         expected.display_name = user.display_name;
         expected.roles = user.roles;
         expected.groups = user.groups;
-        expected.domain = couchbase::management::rbac::auth_domain::local;
+        expected.domain = couchbase::core::management::rbac::auth_domain::local;
 
-        couchbase::management::rbac::role_and_origins expected_role_1{};
+        couchbase::core::management::rbac::role_and_origins expected_role_1{};
         expected_role_1.name = "bucket_admin";
         expected_role_1.bucket = integration.ctx.bucket;
-        expected_role_1.origins = { couchbase::management::rbac::origin{ "user" } };
+        expected_role_1.origins = { couchbase::core::management::rbac::origin{ "user" } };
 
-        couchbase::management::rbac::role_and_origins expected_role_2{};
+        couchbase::core::management::rbac::role_and_origins expected_role_2{};
         expected_role_2.name = "replication_target";
         expected_role_2.bucket = integration.ctx.bucket;
-        expected_role_2.origins = { couchbase::management::rbac::origin{ "group", group_name } };
+        expected_role_2.origins = { couchbase::core::management::rbac::origin{ "group", group_name } };
 
-        couchbase::management::rbac::role_and_origins expected_role_3{};
+        couchbase::core::management::rbac::role_and_origins expected_role_3{};
         expected_role_3.name = "replication_admin";
-        expected_role_3.origins = { couchbase::management::rbac::origin{ "group", group_name } };
+        expected_role_3.origins = { couchbase::core::management::rbac::origin{ "group", group_name } };
 
         expected.effective_roles = { expected_role_1, expected_role_2, expected_role_3 };
 
         {
-            couchbase::operations::management::user_get_request req{ user_name };
-            auto resp = retry_on_error(integration, req, couchbase::error::management_errc::user_not_found);
-            REQUIRE_FALSE(resp.ctx.ec);
+            couchbase::core::operations::management::user_get_request req{ user_name };
+            auto resp = retry_on_error(integration, req, couchbase::errc::management::user_not_found);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             assert_user_and_metadata(resp.user, expected);
         }
 
@@ -790,27 +812,27 @@ TEST_CASE("integration: user groups management", "[integration]")
         expected.display_name = "different_display_name";
 
         {
-            couchbase::operations::management::user_upsert_request req{};
+            couchbase::core::operations::management::user_upsert_request req{};
             req.user = user;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::user_get_response resp;
+            couchbase::core::operations::management::user_get_response resp;
             test::utils::wait_until([&]() {
-                couchbase::operations::management::user_get_request req{ user.username };
+                couchbase::core::operations::management::user_get_request req{ user.username };
                 resp = test::utils::execute(integration.cluster, req);
                 return !resp.ctx.ec && resp.user.display_name == user.display_name;
             });
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             assert_user_and_metadata(resp.user, expected);
         }
 
         {
-            couchbase::operations::management::user_get_all_request req{};
+            couchbase::core::operations::management::user_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE_FALSE(resp.users.empty());
             auto upserted_user =
               std::find_if(resp.users.begin(), resp.users.end(), [&user_name](const auto& u) { return u.username == user_name; });
@@ -819,15 +841,15 @@ TEST_CASE("integration: user groups management", "[integration]")
         }
 
         {
-            couchbase::operations::management::user_drop_request req{ user_name };
+            couchbase::core::operations::management::user_drop_request req{ user_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::group_drop_request req{ group_name };
+            couchbase::core::operations::management::group_drop_request req{ group_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
     }
 }
@@ -836,31 +858,98 @@ TEST_CASE("integration: user management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_user_management()) {
+        return;
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
 
     SECTION("get missing user")
     {
-        couchbase::operations::management::user_get_request req{ test::utils::uniq_id("user") };
+        couchbase::core::operations::management::user_get_request req{ test::utils::uniq_id("user") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::management_errc::user_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::management::user_not_found);
     }
 
     SECTION("drop missing user")
     {
-        couchbase::operations::management::user_drop_request req{ test::utils::uniq_id("user") };
+        couchbase::core::operations::management::user_drop_request req{ test::utils::uniq_id("user") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::management_errc::user_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::management::user_not_found);
     }
 
     SECTION("get roles")
     {
-        couchbase::operations::management::role_get_all_request req{};
+        couchbase::core::operations::management::role_get_all_request req{};
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.roles.size() > 0);
     }
+
+    if (integration.cluster_version().is_enterprise()) {
+
+        SECTION("change user password")
+        {
+            asio::io_context io;
+            auto guard = asio::make_work_guard(io);
+            std::thread io_thread([&io]() { io.run(); });
+            auto user_name = test::utils::uniq_id("newUser");
+
+            // Create options
+            auto options_original = couchbase::cluster_options(integration.ctx.username, integration.ctx.password);
+            auto options_outdated = couchbase::cluster_options(user_name, integration.ctx.password);
+            auto options_updated = couchbase::cluster_options(user_name, "newPassword");
+
+            // Create new user and upsert
+            couchbase::core::management::rbac::user new_user{ user_name };
+            new_user.display_name = "change_password_user";
+            new_user.password = integration.ctx.password;
+            new_user.roles = {
+                couchbase::core::management::rbac::role{ "admin" },
+            };
+            auto [cluster, ec] = couchbase::cluster::connect(io, integration.ctx.connection_string, options_original).get();
+            auto coreCluster = cluster.core();
+            couchbase::core::operations::management::user_upsert_request upsertReq{};
+            upsertReq.user = new_user;
+            auto upsertResp = test::utils::execute(coreCluster, upsertReq);
+            REQUIRE_SUCCESS(upsertResp.ctx.ec);
+            test::utils::wait_until_user_present(integration.cluster, user_name);
+            cluster.close();
+            guard.reset();
+            io_thread.join();
+
+            // Connect with new credentials and change password
+            asio::io_context io2;
+            auto guard2 = asio::make_work_guard(io2);
+            std::thread io_thread2([&io2]() { io2.run(); });
+            auto [cluster_new, ec_new] = couchbase::cluster::connect(io2, integration.ctx.connection_string, options_outdated).get();
+            auto coreCluster_new = cluster_new.core();
+            couchbase::core::operations::management::change_password_request changePasswordReq{};
+            changePasswordReq.newPassword = "newPassword";
+            auto changePasswordResp = test::utils::execute(coreCluster_new, changePasswordReq);
+            REQUIRE_SUCCESS(changePasswordResp.ctx.ec);
+            test::utils::wait_until_cluster_connected(user_name, changePasswordReq.newPassword, integration.ctx.connection_string);
+            cluster_new.close();
+            guard2.reset();
+            io_thread2.join();
+
+            // Connect with old credentials, should fail
+            asio::io_context io3;
+            auto guard3 = asio::make_work_guard(io3);
+            std::thread io_thread3([&io3]() { io3.run(); });
+            auto [cluster_fail, ec_fail] = couchbase::cluster::connect(io3, integration.ctx.connection_string, options_outdated).get();
+            REQUIRE(ec_fail == couchbase::errc::common::authentication_failure);
+
+            // Make connection with new credentials, should succeed
+            auto [cluster_success, ec_success] = couchbase::cluster::connect(io3, integration.ctx.connection_string, options_updated).get();
+            REQUIRE_SUCCESS(ec_success);
+            cluster_success.close();
+            guard3.reset();
+            io_thread3.join();
+        }
+    }
 }
 
 TEST_CASE("integration: user management collections roles", "[integration]")
@@ -868,7 +957,8 @@ TEST_CASE("integration: user management collections roles", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    if (!integration.cluster_version().supports_collections() || integration.cluster_version().is_community()) {
+    if (!integration.cluster_version().supports_user_management() || !integration.cluster_version().supports_collections() ||
+        integration.cluster_version().is_community()) {
         return;
     }
 
@@ -877,39 +967,39 @@ TEST_CASE("integration: user management collections roles", "[integration]")
     auto user_name = test::utils::uniq_id("user");
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
         REQUIRE(created);
     }
 
     {
-        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
         REQUIRE(created);
     }
 
-    couchbase::management::rbac::user user{ user_name };
+    couchbase::core::management::rbac::user user{ user_name };
     user.display_name = "display_name";
     user.password = "password";
     user.roles = {
-        couchbase::management::rbac::role{ "data_reader", integration.ctx.bucket, scope_name },
+        couchbase::core::management::rbac::role{ "data_reader", integration.ctx.bucket, scope_name },
     };
 
     {
-        couchbase::operations::management::user_upsert_request req{};
+        couchbase::core::operations::management::user_upsert_request req{};
         req.user = user;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::user_get_request req{ user_name };
-        auto resp = retry_on_error(integration, req, couchbase::error::management_errc::user_not_found);
-        REQUIRE_FALSE(resp.ctx.ec);
+        couchbase::core::operations::management::user_get_request req{ user_name };
+        auto resp = retry_on_error(integration, req, couchbase::errc::management::user_not_found);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.user.roles.size() == 1);
         REQUIRE(resp.user.roles[0].name == "data_reader");
         REQUIRE(resp.user.roles[0].bucket == integration.ctx.bucket);
@@ -917,20 +1007,20 @@ TEST_CASE("integration: user management collections roles", "[integration]")
     }
 
     user.roles = {
-        couchbase::management::rbac::role{ "data_reader", integration.ctx.bucket, scope_name, collection_name },
+        couchbase::core::management::rbac::role{ "data_reader", integration.ctx.bucket, scope_name, collection_name },
     };
 
     {
-        couchbase::operations::management::user_upsert_request req{};
+        couchbase::core::operations::management::user_upsert_request req{};
         req.user = user;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::user_get_request req{ user_name };
+        couchbase::core::operations::management::user_get_request req{ user_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.user.roles.size() == 1);
         REQUIRE(resp.user.roles[0].name == "data_reader");
         REQUIRE(resp.user.roles[0].bucket == integration.ctx.bucket);
@@ -943,191 +1033,406 @@ TEST_CASE("integration: query index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_query_index_management()) {
-        return;
-    }
+    if (integration.cluster_version().supports_bucket_management()) {
+        SECTION("primary index")
+        {
+            auto bucket_name = test::utils::uniq_id("bucket");
 
-    auto bucket_name = test::utils::uniq_id("bucket");
-    auto index_name = test::utils::uniq_id("index");
+            {
+                couchbase::core::operations::management::bucket_create_request req;
+                req.bucket.name = bucket_name;
+                req.bucket.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
+                req.bucket.num_replicas = 0;
+                auto resp = test::utils::execute(integration.cluster, req);
+            }
 
-    {
-        couchbase::operations::management::bucket_create_request req;
-        req.bucket.name = bucket_name;
-        req.bucket.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
-        req.bucket.num_replicas = 0;
-        auto resp = test::utils::execute(integration.cluster, req);
-    }
+            REQUIRE(!wait_for_bucket_created(integration, bucket_name).ctx.ec);
+            SECTION("core API")
+            {
 
-    REQUIRE(!wait_for_bucket_created(integration, bucket_name).ctx.ec);
+                {
+                    couchbase::core::operations::management::query_index_create_response resp;
+                    bool operation_completed = test::utils::wait_until([&integration, &bucket_name, &resp]() {
+                        couchbase::core::operations::management::query_index_create_request req{};
+                        req.bucket_name = bucket_name;
+                        req.is_primary = true;
+                        resp = test::utils::execute(integration.cluster, req);
+                        return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(operation_completed);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
-    SECTION("primary index")
-    {
-        {
-            couchbase::operations::management::query_index_create_response resp;
-            bool operation_completed = test::utils::wait_until([&integration, &bucket_name, &resp]() {
-                couchbase::operations::management::query_index_create_request req{};
-                req.bucket_name = bucket_name;
-                req.is_primary = true;
-                resp = test::utils::execute(integration.cluster, req);
-                return resp.ctx.ec != couchbase::error::common_errc::bucket_not_found;
-            });
-            REQUIRE(operation_completed);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+                {
+                    couchbase::core::operations::management::query_index_get_all_request req{};
+                    req.bucket_name = bucket_name;
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.indexes.size() == 1);
+                    REQUIRE(resp.indexes[0].name == "#primary");
+                    REQUIRE(resp.indexes[0].is_primary);
+                }
 
-        {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.indexes.size() == 1);
-            REQUIRE(resp.indexes[0].name == "#primary");
-            REQUIRE(resp.indexes[0].is_primary);
+                {
+                    couchbase::core::operations::management::bucket_drop_request req{ bucket_name };
+                    test::utils::execute(integration.cluster, req);
+                }
+            }
+            SECTION("public api")
+            {
+                couchbase::cluster c(integration.cluster);
+                {
+                    std::error_code ec;
+                    bool operation_completed = test::utils::wait_until([&bucket_name, &ec, &c]() {
+                        auto ctx = c.query_indexes().create_primary_index(bucket_name, {}).get();
+                        ec = ctx.ec();
+                        return ec != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(operation_completed);
+                    REQUIRE_SUCCESS(ec);
+                }
+                {
+                    auto [ctx, indexes] = c.query_indexes().get_all_indexes(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                    REQUIRE(indexes.size() == 1);
+                    REQUIRE(indexes[0].name == "#primary");
+                    REQUIRE(indexes[0].is_primary);
+                }
+                {
+                    auto ctx =
+                      c.query_indexes().watch_indexes(bucket_name, {}, couchbase::watch_query_indexes_options().watch_primary(true)).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+                {
+                    auto ctx = c.query_indexes().drop_primary_index(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+            }
         }
     }
 
     SECTION("non primary index")
     {
+        SECTION("core API")
         {
-            couchbase::operations::management::query_index_create_response resp;
-            bool operation_completed = test::utils::wait_until([&integration, &bucket_name, &index_name, &resp]() {
-                couchbase::operations::management::query_index_create_request req{};
-                req.bucket_name = bucket_name;
+            auto index_name = test::utils::uniq_id("index");
+            {
+                couchbase::core::operations::management::query_index_create_response resp;
+                bool operation_completed = test::utils::wait_until([&integration, &index_name, &resp]() {
+                    couchbase::core::operations::management::query_index_create_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    req.index_name = index_name;
+                    req.fields = { "field", "field2 DESC", "`two words` DESC" };
+                    resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            {
+                couchbase::core::operations::management::query_index_create_request req{};
+                req.bucket_name = integration.ctx.bucket;
                 req.index_name = index_name;
                 req.fields = { "field" };
-                resp = test::utils::execute(integration.cluster, req);
-                return resp.ctx.ec != couchbase::error::common_errc::bucket_not_found;
-            });
-            REQUIRE(operation_completed);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE(resp.ctx.ec == couchbase::errc::common::index_exists);
+            }
 
-        {
-            couchbase::operations::management::query_index_create_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            req.fields = { "field" };
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_exists);
-        }
+            {
+                couchbase::core::operations::management::query_index_create_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                req.fields = { "field" };
+                req.ignore_if_exists = true;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        {
-            couchbase::operations::management::query_index_create_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            req.fields = { "field" };
-            req.ignore_if_exists = true;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            {
+                couchbase::core::operations::management::query_index_get_all_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                auto index = std::find_if(
+                  resp.indexes.begin(), resp.indexes.end(), [&index_name](const auto& exp_index) { return exp_index.name == index_name; });
+                REQUIRE(index != resp.indexes.end());
+                REQUIRE(index->name == index_name);
+                REQUIRE_FALSE(index->is_primary);
+                REQUIRE(index->index_key.size() == 3);
+                REQUIRE(index->index_key[0] == "`field`");
+                REQUIRE(index->index_key[1] == "`field2` DESC");
+                REQUIRE(index->index_key[2] == "`two words` DESC");
+                REQUIRE(index->bucket_name == integration.ctx.bucket);
+                REQUIRE(index->state == "online");
+            }
+            {
+                couchbase::core::operations::management::query_index_drop_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.indexes.size() == 1);
-            REQUIRE(resp.indexes[0].name == index_name);
-            REQUIRE_FALSE(resp.indexes[0].is_primary);
-            REQUIRE(resp.indexes[0].index_key.size() == 1);
-            REQUIRE(resp.indexes[0].index_key[0] == "`field`");
-            REQUIRE(resp.indexes[0].bucket_name == bucket_name);
-            REQUIRE(resp.indexes[0].state == "online");
+            {
+                couchbase::core::operations::management::query_index_drop_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE(resp.ctx.ec == couchbase::errc::common::index_not_found);
+            }
         }
-
+        SECTION("public API")
         {
-            couchbase::operations::management::query_index_drop_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            couchbase::cluster c(integration.cluster);
+            auto index_name = test::utils::uniq_id("index");
+            {
+                std::error_code ec;
+                bool operation_completed = test::utils::wait_until([&integration, &index_name, c, &ec]() {
+                    auto ctx = c.query_indexes()
+                                 .create_index(integration.ctx.bucket, index_name, { "field", "field2 DESC", "`two words` DESC" }, {})
+                                 .get();
+                    ec = ctx.ec();
+                    return ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(ec);
+            }
+            {
+                auto ctx = c.query_indexes().watch_indexes(integration.ctx.bucket, { index_name }, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
 
-        {
-            couchbase::operations::management::query_index_drop_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_not_found);
+            {
+                auto ctx = c.query_indexes().create_index(integration.ctx.bucket, index_name, { "field" }, {}).get();
+                REQUIRE(ctx.ec() == couchbase::errc::common::index_exists);
+            }
+
+            {
+                auto ctx =
+                  c.query_indexes()
+                    .create_index(
+                      integration.ctx.bucket, index_name, { "field" }, couchbase::create_query_index_options().ignore_if_exists(true))
+                    .get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+
+            {
+                auto [ctx, indexes] = c.query_indexes().get_all_indexes(integration.ctx.bucket, {}).get();
+                auto index = std::find_if(
+                  indexes.begin(), indexes.end(), [&index_name](const auto& exp_index) { return exp_index.name == index_name; });
+                REQUIRE(index != indexes.end());
+                REQUIRE(index->name == index_name);
+                REQUIRE_FALSE(index->is_primary);
+                REQUIRE(index->index_key.size() == 3);
+                REQUIRE(index->index_key[0] == "`field`");
+                REQUIRE(index->index_key[1] == "`field2` DESC");
+                REQUIRE(index->index_key[2] == "`two words` DESC");
+                REQUIRE(index->bucket_name == integration.ctx.bucket);
+                REQUIRE(index->state == "online");
+            }
+            {
+                auto ctx = c.query_indexes().drop_index(integration.ctx.bucket, index_name, {}).get();
+                couchbase::core::operations::management::query_index_drop_request req{};
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+
+            {
+                auto ctx = c.query_indexes().drop_index(integration.ctx.bucket, index_name, {}).get();
+                couchbase::core::operations::management::query_index_drop_request req{};
+                REQUIRE(ctx.ec() == couchbase::errc::common::index_not_found);
+            }
+            {
+                auto ctx =
+                  c.query_indexes()
+                    .drop_index(integration.ctx.bucket, index_name, couchbase::drop_query_index_options().ignore_if_not_exists(true))
+                    .get();
+                couchbase::core::operations::management::query_index_drop_request req{};
+                REQUIRE_SUCCESS(ctx.ec());
+            }
         }
     }
 
     SECTION("deferred index")
     {
+        SECTION("public API")
         {
-            couchbase::operations::management::query_index_create_response resp;
-            bool operation_completed = test::utils::wait_until([&integration, &bucket_name, &index_name, &resp]() {
-                couchbase::operations::management::query_index_create_request req{};
-                req.bucket_name = bucket_name;
-                req.index_name = index_name;
-                req.fields = { "field" };
-                req.deferred = true;
-                resp = test::utils::execute(integration.cluster, req);
-                return resp.ctx.ec != couchbase::error::common_errc::bucket_not_found;
-            });
-            REQUIRE(operation_completed);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            couchbase::cluster c(integration.cluster);
+            auto index_name = test::utils::uniq_id("index");
+            {
+                std::error_code ec;
+                bool operation_completed = test::utils::wait_until([c, &ec, &index_name, &integration]() {
+                    auto ctx =
+                      c.query_indexes()
+                        .create_index(
+                          integration.ctx.bucket, index_name, { "field" }, couchbase::create_query_index_options().build_deferred(true))
+                        .get();
+                    ec = ctx.ec();
+                    return ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(ec);
+            }
 
-        {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.indexes.size() == 1);
-            REQUIRE(resp.indexes[0].name == index_name);
-            REQUIRE(resp.indexes[0].state == "deferred");
+            {
+                auto [ctx, indexes] = c.query_indexes().get_all_indexes(integration.ctx.bucket, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+                auto index = std::find_if(
+                  indexes.begin(), indexes.end(), [&index_name](const auto& exp_index) { return exp_index.name == index_name; });
+                REQUIRE(index != indexes.end());
+                REQUIRE(index->name == index_name);
+                REQUIRE(index->state == "deferred");
+            }
+
+            {
+                auto manager = couchbase::cluster(integration.cluster).query_indexes();
+                auto ctx = manager.build_deferred_indexes(integration.ctx.bucket, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                // now wait till it is online before proceeding
+                auto operation_completed = test::utils::wait_until([&integration, &index_name, c]() {
+                    auto [ctx, indexes] = c.query_indexes().get_all_indexes(integration.ctx.bucket, {}).get();
+                    if (indexes.empty()) {
+                        return false;
+                    }
+                    auto index = std::find_if(
+                      indexes.begin(), indexes.end(), [&index_name](const auto& exp_index) { return exp_index.name == index_name; });
+                    return index->state == "online";
+                });
+                REQUIRE(operation_completed);
+            }
         }
 
+        SECTION("core API")
         {
-            couchbase::operations::management::query_index_build_deferred_request req{};
-            req.bucket_name = bucket_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            auto index_name = test::utils::uniq_id("index");
+            {
+                couchbase::core::operations::management::query_index_create_response resp;
+                bool operation_completed = test::utils::wait_until([&integration, &index_name, &resp]() {
+                    couchbase::core::operations::management::query_index_create_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    req.index_name = index_name;
+                    req.fields = { "field" };
+                    req.deferred = true;
+                    resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+            {
+                couchbase::core::operations::management::query_index_build_deferred_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        test::utils::wait_until([&integration, bucket_name]() {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            if (resp.indexes.empty()) {
-                return false;
+            {
+                test::utils::wait_until([&integration, &index_name]() {
+                    couchbase::core::operations::management::query_index_get_all_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    if (resp.indexes.empty()) {
+                        return false;
+                    }
+                    auto index = std::find_if(resp.indexes.begin(), resp.indexes.end(), [&index_name](const auto& exp_index) {
+                        return exp_index.name == index_name;
+                    });
+                    return index->state == "online";
+                });
             }
-            return resp.indexes[0].state == "online";
-        });
+        }
     }
 
     SECTION("create missing bucket")
     {
-        couchbase::operations::management::query_index_create_request req{};
-        req.bucket_name = "missing_bucket";
-        req.is_primary = true;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::bucket_not_found);
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_create_request req{};
+            req.bucket_name = "missing_bucket";
+            req.is_primary = true;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto ctx = c.query_indexes().create_primary_index("missing_bucket", {}).get();
+            REQUIRE(ctx.ec() == couchbase::errc::common::bucket_not_found);
+        }
     }
 
     SECTION("get missing bucket")
     {
-        couchbase::operations::management::query_index_get_all_request req{};
-        req.bucket_name = "missing_bucket";
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.indexes.empty());
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_get_all_request req{};
+            req.bucket_name = "missing_bucket";
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            REQUIRE(resp.indexes.empty());
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto [ctx, indexes] = c.query_indexes().get_all_indexes("missing_bucket", {}).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            REQUIRE(indexes.empty());
+        }
     }
 
     SECTION("drop missing bucket")
     {
-        couchbase::operations::management::query_index_drop_request req{};
-        req.bucket_name = "missing_bucket";
-        req.is_primary = true;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::bucket_not_found);
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_drop_request req{};
+            req.bucket_name = "missing_bucket";
+            req.is_primary = true;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto ctx = c.query_indexes().drop_primary_index("missing_bucket", {}).get();
+            REQUIRE(ctx.ec() == couchbase::errc::common::bucket_not_found);
+        }
     }
 
-    // drop any buckets that haven't already been dropped
+    SECTION("watch missing index")
     {
-        couchbase::operations::management::bucket_drop_request req{ bucket_name };
-        test::utils::execute(integration.cluster, req);
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto start = std::chrono::steady_clock::now();
+            auto ctx = c.query_indexes()
+                         .watch_indexes(integration.ctx.bucket,
+                                        { "idontexist", "neitherdoI" },
+                                        couchbase::watch_query_indexes_options()
+                                          .timeout(std::chrono::milliseconds(10000))
+                                          .polling_interval(std::chrono::milliseconds(1000)))
+                         .get();
+            REQUIRE(ctx.ec() == couchbase::errc::common::ambiguous_timeout);
+            REQUIRE(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count() >= 10000);
+        }
+    }
+    SECTION("watch missing bucket")
+    {
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto start = std::chrono::steady_clock::now();
+            auto ctx = c.query_indexes()
+                         .watch_indexes("missing_buckeet",
+                                        { "idontexist", "neitherdoI" },
+                                        couchbase::watch_query_indexes_options()
+                                          .timeout(std::chrono::milliseconds(10000))
+                                          .polling_interval(std::chrono::milliseconds(1000)))
+                         .get();
+            REQUIRE(ctx.ec() == couchbase::errc::common::ambiguous_timeout);
+            REQUIRE(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count() >= 10000);
+        }
     }
 }
 
@@ -1135,265 +1440,515 @@ TEST_CASE("integration: collections query index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_query_index_management()) {
-        return;
-    }
     if (!integration.cluster_version().supports_collections()) {
         return;
     }
 
-    auto bucket_name = test::utils::uniq_id("collections_bucket");
     auto index_name = test::utils::uniq_id("collections_index");
     auto scope_name = test::utils::uniq_id("indexscope");
     auto collection_name = test::utils::uniq_id("indexcollection");
 
-    {
-        couchbase::operations::management::bucket_create_request req;
-        req.bucket.name = bucket_name;
-        req.bucket.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
-        req.bucket.num_replicas = 0;
-        auto resp = test::utils::execute(integration.cluster, req);
-    }
-
-    REQUIRE(!wait_for_bucket_created(integration, bucket_name).ctx.ec);
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     // create the scope and collection that we'll do index management on.
     {
-        couchbase::operations::management::scope_create_request req{ bucket_name, scope_name };
+        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
     {
-        couchbase::operations::management::collection_create_request req{ bucket_name, scope_name, collection_name };
+        couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
+    auto manager =
+      couchbase::cluster(integration.cluster).bucket(integration.ctx.bucket).scope(scope_name).collection(collection_name).query_indexes();
+
     SECTION("primary index")
     {
+        SECTION("core API")
         {
-            couchbase::operations::management::query_index_create_response resp;
-            bool operation_completed = test::utils::wait_until([&integration, &bucket_name, &scope_name, &collection_name, &resp]() {
-                couchbase::operations::management::query_index_create_request req{};
-                req.bucket_name = bucket_name;
+            {
+                couchbase::core::operations::management::query_index_create_response resp;
+                bool operation_completed = test::utils::wait_until([&integration, &scope_name, &collection_name, &resp]() {
+                    couchbase::core::operations::management::query_index_create_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    req.scope_name = scope_name;
+                    req.collection_name = collection_name;
+                    req.is_primary = true;
+                    resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            {
+                couchbase::core::operations::management::query_index_get_all_request req{};
+                req.bucket_name = integration.ctx.bucket;
                 req.scope_name = scope_name;
                 req.collection_name = collection_name;
-                req.is_primary = true;
-                resp = test::utils::execute(integration.cluster, req);
-                return resp.ctx.ec != couchbase::error::common_errc::bucket_not_found;
-            });
-            REQUIRE(operation_completed);
-            REQUIRE_FALSE(resp.ctx.ec);
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.indexes.size() == 1);
+                REQUIRE(resp.indexes[0].name == "#primary");
+                REQUIRE(resp.indexes[0].is_primary);
+            }
         }
-
+        SECTION("public API")
         {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.indexes.size() == 1);
-            REQUIRE(resp.indexes[0].name == "#primary");
-            REQUIRE(resp.indexes[0].is_primary);
+            {
+                std::error_code ec;
+                bool operation_completed = test::utils::wait_until([&manager, &ec]() {
+                    auto ctx = manager.create_primary_index({}).get();
+                    ec = ctx.ec();
+                    return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                });
+
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(ec);
+            }
+            {
+                auto [ctx, indexes] = manager.get_all_indexes({}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+                REQUIRE(indexes.size() == 1);
+                REQUIRE(indexes[0].name == "#primary");
+                REQUIRE(indexes[0].is_primary);
+            }
         }
     }
 
-    SECTION("non primary index")
+    SECTION("named primary index")
     {
+        SECTION("core API")
         {
-            couchbase::operations::management::query_index_create_response resp;
-            bool operation_completed =
-              test::utils::wait_until([&integration, &bucket_name, &index_name, &scope_name, &collection_name, &resp]() {
-                  couchbase::operations::management::query_index_create_request req{};
-                  req.bucket_name = bucket_name;
-                  req.index_name = index_name;
-                  req.scope_name = scope_name;
-                  req.collection_name = collection_name;
-                  req.fields = { "field" };
-                  resp = test::utils::execute(integration.cluster, req);
-                  return resp.ctx.ec != couchbase::error::common_errc::bucket_not_found;
-              });
-            REQUIRE(operation_completed);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            {
+                couchbase::core::operations::management::query_index_create_response resp;
+                bool operation_completed = test::utils::wait_until([&integration, &index_name, &scope_name, &collection_name, &resp]() {
+                    couchbase::core::operations::management::query_index_create_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    req.scope_name = scope_name;
+                    req.collection_name = collection_name;
+                    req.index_name = index_name;
+                    req.is_primary = true;
+                    resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        {
-            couchbase::operations::management::query_index_create_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            req.fields = { "field" };
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_exists);
-        }
+            {
+                couchbase::core::operations::management::query_index_get_all_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.indexes.size() == 1);
+                REQUIRE(resp.indexes[0].name == index_name);
+                REQUIRE(resp.indexes[0].is_primary);
+            }
 
-        {
-            couchbase::operations::management::query_index_create_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            req.fields = { "field" };
-            req.ignore_if_exists = true;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            {
+                couchbase::core::operations::management::query_index_drop_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                req.scope_name = scope_name;
+                req.is_primary = true;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
         }
-
+        SECTION("public API")
         {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.indexes.size() == 1);
-            REQUIRE(resp.indexes[0].name == index_name);
-            REQUIRE_FALSE(resp.indexes[0].is_primary);
-            REQUIRE(resp.indexes[0].index_key.size() == 1);
-            REQUIRE(resp.indexes[0].index_key[0] == "`field`");
-            REQUIRE(resp.indexes[0].collection_name == collection_name);
-            REQUIRE(resp.indexes[0].scope_name == scope_name);
-            REQUIRE(resp.indexes[0].bucket_name == bucket_name);
-            REQUIRE(resp.indexes[0].state == "online");
+            {
+                std::error_code ec;
+                auto operation_completed = test::utils::wait_until([&index_name, &manager, &ec]() {
+                    auto ctx = manager.create_primary_index(couchbase::create_primary_query_index_options().index_name(index_name)).get();
+                    ec = ctx.ec();
+                    return ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(ec);
+            }
+            {
+                auto [ctx, indexes] = manager.get_all_indexes({}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+                REQUIRE(indexes.size() == 1);
+                REQUIRE(indexes[0].name == index_name);
+                REQUIRE(indexes[0].is_primary);
+            }
+            {
+                auto ctx = manager.watch_indexes({ index_name }, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                auto ctx = manager.drop_index(index_name, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
         }
+    }
 
+    SECTION("non primary index")
+    {
+        SECTION("core API")
         {
-            couchbase::operations::management::query_index_drop_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
 
+            {
+                couchbase::core::operations::management::query_index_create_response resp;
+                bool operation_completed = test::utils::wait_until([&integration, &index_name, &scope_name, &collection_name, &resp]() {
+                    couchbase::core::operations::management::query_index_create_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    req.index_name = index_name;
+                    req.scope_name = scope_name;
+                    req.collection_name = collection_name;
+                    req.fields = { "field" };
+                    resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            {
+                couchbase::core::operations::management::query_index_create_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                req.fields = { "field" };
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE(resp.ctx.ec == couchbase::errc::common::index_exists);
+            }
+
+            {
+                couchbase::core::operations::management::query_index_create_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                req.fields = { "field" };
+                req.ignore_if_exists = true;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            {
+                couchbase::core::operations::management::query_index_get_all_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.indexes.size() == 1);
+                REQUIRE(resp.indexes[0].name == index_name);
+                REQUIRE_FALSE(resp.indexes[0].is_primary);
+                REQUIRE(resp.indexes[0].index_key.size() == 1);
+                REQUIRE(resp.indexes[0].index_key[0] == "`field`");
+                REQUIRE(resp.indexes[0].collection_name == collection_name);
+                REQUIRE(resp.indexes[0].scope_name == scope_name);
+                REQUIRE(resp.indexes[0].bucket_name == integration.ctx.bucket);
+                REQUIRE(resp.indexes[0].state == "online");
+            }
+
+            {
+                couchbase::core::operations::management::query_index_drop_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            {
+                couchbase::core::operations::management::query_index_drop_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.index_name = index_name;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE(resp.ctx.ec == couchbase::errc::common::index_not_found);
+            }
+        }
+        SECTION("public API")
         {
-            couchbase::operations::management::query_index_drop_request req{};
-            req.bucket_name = bucket_name;
-            req.index_name = index_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_not_found);
+            {
+                std::error_code ec;
+                auto operation_complete = test::utils::wait_until([&manager, &ec, &index_name]() {
+                    ec = manager.create_index(index_name, { "field" }, {}).get().ec();
+                    return ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_complete);
+                REQUIRE_SUCCESS(ec);
+            }
+            {
+                REQUIRE(manager.create_index(index_name, { "field" }, {}).get().ec() == couchbase::errc::common::index_exists);
+            }
+            {
+                REQUIRE_SUCCESS(
+                  manager.create_index(index_name, { "field" }, couchbase::create_query_index_options().ignore_if_exists(true)).get().ec());
+            }
+            {
+                REQUIRE_SUCCESS(manager.watch_indexes({ index_name }, {}).get().ec());
+                auto [ctx, indexes] = manager.get_all_indexes({}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+                REQUIRE(indexes.size() == 1);
+                REQUIRE(indexes[0].name == index_name);
+                REQUIRE_FALSE(indexes[0].is_primary);
+                REQUIRE(indexes[0].index_key.size() == 1);
+                REQUIRE(indexes[0].index_key[0] == "`field`");
+                REQUIRE(indexes[0].collection_name == collection_name);
+                REQUIRE(indexes[0].scope_name == scope_name);
+                REQUIRE(indexes[0].bucket_name == integration.ctx.bucket);
+                REQUIRE(indexes[0].state == "online");
+            }
+            {
+                auto ctx = manager.drop_index(index_name, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                REQUIRE(manager.drop_index(index_name, {}).get().ec() == couchbase::errc::common::index_not_found);
+            }
+            {
+                REQUIRE_SUCCESS(
+                  manager.drop_index(index_name, couchbase::drop_query_index_options().ignore_if_not_exists(true)).get().ec());
+            }
         }
     }
 
     SECTION("deferred index")
     {
-        {
-            couchbase::operations::management::query_index_create_response resp;
-            bool operation_completed =
-              test::utils::wait_until([&integration, &bucket_name, &index_name, &scope_name, &collection_name, &resp]() {
-                  couchbase::operations::management::query_index_create_request req{};
-                  req.bucket_name = bucket_name;
-                  req.index_name = index_name;
-                  req.scope_name = scope_name;
-                  req.collection_name = collection_name;
-                  req.fields = { "field" };
-                  req.deferred = true;
-                  resp = test::utils::execute(integration.cluster, req);
-                  return resp.ctx.ec != couchbase::error::common_errc::bucket_not_found;
-              });
-            REQUIRE(operation_completed);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
 
+        SECTION("public API")
         {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-            REQUIRE(resp.indexes.size() == 1);
-            REQUIRE(resp.indexes[0].name == index_name);
-            REQUIRE(resp.indexes[0].state == "deferred");
+            {
+                auto ctx =
+                  manager.create_index(index_name, { "field" }, couchbase::create_query_index_options().build_deferred(true)).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                auto [ctx, indexes] = manager.get_all_indexes({}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+                REQUIRE(indexes.size() == 1);
+                REQUIRE(indexes[0].name == index_name);
+                REQUIRE(indexes[0].state == "deferred");
+            }
+            {
+                auto ctx = manager.build_deferred_indexes({}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                auto ctx = manager.watch_indexes({ index_name }, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
         }
 
+        SECTION("core API")
         {
-            couchbase::operations::management::query_index_build_deferred_request req{};
-            req.bucket_name = bucket_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
-        }
+            {
+                couchbase::core::operations::management::query_index_create_response resp;
+                bool operation_completed = test::utils::wait_until([&integration, &index_name, &scope_name, &collection_name, &resp]() {
+                    couchbase::core::operations::management::query_index_create_request req{};
+                    req.bucket_name = integration.ctx.bucket;
+                    req.index_name = index_name;
+                    req.scope_name = scope_name;
+                    req.collection_name = collection_name;
+                    req.fields = { "field" };
+                    req.deferred = true;
+                    resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(operation_completed);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        test::utils::wait_until([&integration, bucket_name, scope_name, collection_name]() {
-            couchbase::operations::management::query_index_get_all_request req{};
-            req.bucket_name = bucket_name;
-            req.scope_name = scope_name;
-            req.collection_name = collection_name;
-            auto resp = test::utils::execute(integration.cluster, req);
-            if (resp.indexes.empty()) {
-                return false;
+            {
+                couchbase::core::operations::management::query_index_get_all_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.indexes.size() == 1);
+                REQUIRE(resp.indexes[0].name == index_name);
+                REQUIRE(resp.indexes[0].state == "deferred");
             }
-            return resp.indexes[0].state == "online";
-        });
+            {
+                couchbase::core::operations::management::query_index_build_deferred_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            test::utils::wait_until([&integration, scope_name, collection_name]() {
+                couchbase::core::operations::management::query_index_get_all_request req{};
+                req.bucket_name = integration.ctx.bucket;
+                req.scope_name = scope_name;
+                req.collection_name = collection_name;
+                auto resp = test::utils::execute(integration.cluster, req);
+                if (resp.indexes.empty()) {
+                    return false;
+                }
+                return resp.indexes[0].state == "online";
+            });
+        }
     }
 
     SECTION("create missing collection")
     {
-        couchbase::operations::management::query_index_create_request req{};
-        req.bucket_name = bucket_name;
-        req.scope_name = scope_name;
-        req.collection_name = "missing_collection";
-        req.is_primary = true;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::collection_not_found);
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_create_request req{};
+            req.bucket_name = integration.ctx.bucket;
+            req.scope_name = scope_name;
+            req.collection_name = "missing_collection";
+            req.is_primary = true;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::collection_not_found);
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope(scope_name).collection("missing_collection");
+            REQUIRE(coll.query_indexes().create_primary_index({}).get().ec() == couchbase::errc::common::collection_not_found);
+        }
     }
 
     SECTION("create missing scope")
     {
-        couchbase::operations::management::query_index_create_request req{};
-        req.bucket_name = bucket_name;
-        req.scope_name = "missing_scope";
-        req.collection_name = collection_name;
-        req.is_primary = true;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_create_request req{};
+            req.bucket_name = integration.ctx.bucket;
+            req.scope_name = "missing_scope";
+            req.collection_name = collection_name;
+            req.is_primary = true;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::scope_not_found);
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope("missing scope").collection(collection_name);
+            REQUIRE(coll.query_indexes().create_primary_index({}).get().ec() == couchbase::errc::common::scope_not_found);
+        }
     }
 
     SECTION("get missing collection")
     {
-        couchbase::operations::management::query_index_get_all_request req{};
-        req.bucket_name = bucket_name;
-        req.scope_name = scope_name;
-        req.collection_name = "missing_collection";
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.indexes.empty());
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_get_all_request req{};
+            req.bucket_name = integration.ctx.bucket;
+            req.scope_name = scope_name;
+            req.collection_name = "missing_collection";
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            REQUIRE(resp.indexes.empty());
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope(scope_name).collection("missing_collection");
+            auto [ctx, indexes] = coll.query_indexes().get_all_indexes({}).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            REQUIRE(indexes.empty());
+        }
+    }
+    SECTION("get missing scope")
+    {
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_get_all_request req{};
+            req.bucket_name = integration.ctx.bucket;
+            req.scope_name = "missing_scope";
+            req.collection_name = collection_name;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            REQUIRE(resp.indexes.empty());
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope("missing_scope").collection(collection_name);
+            auto [ctx, indexes] = coll.query_indexes().get_all_indexes({}).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            REQUIRE(indexes.empty());
+        }
     }
 
     SECTION("drop missing collection")
     {
-        couchbase::operations::management::query_index_drop_request req{};
-        req.bucket_name = bucket_name;
-        req.scope_name = scope_name;
-        req.collection_name = "missing_collection";
-        req.is_primary = true;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::collection_not_found);
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_drop_request req{};
+            req.bucket_name = integration.ctx.bucket;
+            req.scope_name = scope_name;
+            req.collection_name = "missing_collection";
+            req.is_primary = true;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::collection_not_found);
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope(scope_name).collection("missing_collection");
+            REQUIRE(coll.query_indexes().drop_index(index_name, {}).get().ec() == couchbase::errc::common::collection_not_found);
+        }
     }
-
     SECTION("drop missing scope")
     {
-        couchbase::operations::management::query_index_drop_request req{};
-        req.bucket_name = bucket_name;
-        req.scope_name = "missing_scope";
-        req.collection_name = collection_name;
-        req.is_primary = true;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
+        SECTION("core API")
+        {
+            couchbase::core::operations::management::query_index_drop_request req{};
+            req.bucket_name = integration.ctx.bucket;
+            req.scope_name = "missing_scope";
+            req.collection_name = collection_name;
+            req.is_primary = true;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::scope_not_found);
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope("missing_scope").collection(collection_name);
+            REQUIRE(coll.query_indexes().drop_index(index_name, {}).get().ec() == couchbase::errc::common::scope_not_found);
+        }
     }
-
-    // drop any buckets that haven't already been dropped
+    SECTION("watch missing scope")
     {
-        couchbase::operations::management::bucket_drop_request req{ bucket_name };
-        test::utils::execute(integration.cluster, req);
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope("missing_scope").collection(collection_name);
+            REQUIRE(coll.query_indexes()
+                      .watch_indexes({ index_name }, couchbase::watch_query_indexes_options().timeout(std::chrono::seconds(5)))
+                      .get()
+                      .ec() == couchbase::errc::common::ambiguous_timeout);
+        }
+    }
+    SECTION("watch missing collection")
+    {
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            auto coll = c.bucket(integration.ctx.bucket).scope(scope_name).collection("missing_collection");
+            REQUIRE(coll.query_indexes()
+                      .watch_indexes({ index_name }, couchbase::watch_query_indexes_options().timeout(std::chrono::seconds(5)))
+                      .get()
+                      .ec() == couchbase::errc::common::ambiguous_timeout);
+        }
     }
 }
 
@@ -1406,7 +1961,7 @@ TEST_CASE("integration: analytics index management", "[integration]")
     }
 
     // MB-47718
-    if (integration.storage_backend() == couchbase::management::cluster::bucket_storage_backend::magma) {
+    if (integration.storage_backend() == couchbase::core::management::cluster::bucket_storage_backend::magma) {
         return;
     }
 
@@ -1417,98 +1972,98 @@ TEST_CASE("integration: analytics index management", "[integration]")
         auto index_name = test::utils::uniq_id("index");
 
         {
-            couchbase::operations::management::analytics_dataverse_create_request req{};
+            couchbase::core::operations::management::analytics_dataverse_create_request req{};
             req.dataverse_name = dataverse_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataverse_create_request req{};
+            couchbase::core::operations::management::analytics_dataverse_create_request req{};
             req.dataverse_name = dataverse_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::dataverse_exists);
+            REQUIRE(resp.ctx.ec == couchbase::errc::analytics::dataverse_exists);
         }
 
         {
-            couchbase::operations::management::analytics_dataverse_create_request req{};
+            couchbase::core::operations::management::analytics_dataverse_create_request req{};
             req.dataverse_name = dataverse_name;
             req.ignore_if_exists = true;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_create_request req{};
+            couchbase::core::operations::management::analytics_dataset_create_request req{};
             req.dataset_name = dataset_name;
             req.bucket_name = integration.ctx.bucket;
             req.dataverse_name = dataverse_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_create_request req{};
+            couchbase::core::operations::management::analytics_dataset_create_request req{};
             req.dataset_name = dataset_name;
             req.bucket_name = integration.ctx.bucket;
             req.dataverse_name = dataverse_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::dataset_exists);
+            REQUIRE(resp.ctx.ec == couchbase::errc::analytics::dataset_exists);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_create_request req{};
+            couchbase::core::operations::management::analytics_dataset_create_request req{};
             req.dataset_name = dataset_name;
             req.bucket_name = integration.ctx.bucket;
             req.dataverse_name = dataverse_name;
             req.ignore_if_exists = true;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_index_create_request req{};
+            couchbase::core::operations::management::analytics_index_create_request req{};
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             req.index_name = index_name;
             req.fields["testkey"] = "string";
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_index_create_request req{};
+            couchbase::core::operations::management::analytics_index_create_request req{};
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             req.index_name = index_name;
             req.fields["testkey"] = "string";
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_exists);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::index_exists);
         }
 
         {
-            couchbase::operations::management::analytics_index_create_request req{};
+            couchbase::core::operations::management::analytics_index_create_request req{};
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             req.index_name = index_name;
             req.fields["testkey"] = "string";
             req.ignore_if_exists = true;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_link_connect_request req{};
+            couchbase::core::operations::management::analytics_link_connect_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_get_all_request req{};
+            couchbase::core::operations::management::analytics_dataset_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE_FALSE(resp.datasets.empty());
-            auto dataset = std::find_if(resp.datasets.begin(), resp.datasets.end(), [dataset_name](const auto& exp_dataset) {
+            auto dataset = std::find_if(resp.datasets.begin(), resp.datasets.end(), [&dataset_name](const auto& exp_dataset) {
                 return exp_dataset.name == dataset_name;
             });
             REQUIRE(dataset != resp.datasets.end());
@@ -1518,12 +2073,12 @@ TEST_CASE("integration: analytics index management", "[integration]")
         }
 
         {
-            couchbase::operations::management::analytics_index_get_all_request req{};
+            couchbase::core::operations::management::analytics_index_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE_FALSE(resp.indexes.empty());
             auto index = std::find_if(
-              resp.indexes.begin(), resp.indexes.end(), [index_name](const auto& exp_index) { return exp_index.name == index_name; });
+              resp.indexes.begin(), resp.indexes.end(), [&index_name](const auto& exp_index) { return exp_index.name == index_name; });
             REQUIRE(index != resp.indexes.end());
             REQUIRE(index->dataverse_name == dataverse_name);
             REQUIRE(index->dataset_name == dataset_name);
@@ -1531,91 +2086,91 @@ TEST_CASE("integration: analytics index management", "[integration]")
         }
 
         if (integration.cluster_version().supports_analytics_pending_mutations()) {
-            couchbase::operations::management::analytics_get_pending_mutations_request req{};
+            couchbase::core::operations::management::analytics_get_pending_mutations_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.stats[index_name] == 0);
         }
 
         {
-            couchbase::operations::management::analytics_link_disconnect_request req{};
+            couchbase::core::operations::management::analytics_link_disconnect_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_index_drop_request req{};
+            couchbase::core::operations::management::analytics_index_drop_request req{};
             req.index_name = index_name;
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_index_drop_request req{};
+            couchbase::core::operations::management::analytics_index_drop_request req{};
             req.index_name = index_name;
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::index_not_found);
         }
 
         {
-            couchbase::operations::management::analytics_index_drop_request req{};
+            couchbase::core::operations::management::analytics_index_drop_request req{};
             req.index_name = index_name;
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             req.ignore_if_does_not_exist = true;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_drop_request req{};
+            couchbase::core::operations::management::analytics_dataset_drop_request req{};
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_drop_request req{};
+            couchbase::core::operations::management::analytics_dataset_drop_request req{};
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::dataset_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::analytics::dataset_not_found);
         }
 
         {
-            couchbase::operations::management::analytics_dataset_drop_request req{};
+            couchbase::core::operations::management::analytics_dataset_drop_request req{};
             req.dataverse_name = dataverse_name;
             req.dataset_name = dataset_name;
             req.ignore_if_does_not_exist = true;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataverse_drop_request req{};
+            couchbase::core::operations::management::analytics_dataverse_drop_request req{};
             req.dataverse_name = dataverse_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::analytics_dataverse_drop_request req{};
+            couchbase::core::operations::management::analytics_dataverse_drop_request req{};
             req.dataverse_name = dataverse_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::dataverse_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::analytics::dataverse_not_found);
         }
 
         {
-            couchbase::operations::management::analytics_dataverse_drop_request req{};
+            couchbase::core::operations::management::analytics_dataverse_drop_request req{};
             req.dataverse_name = dataverse_name;
             req.ignore_if_does_not_exist = true;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
     }
 
@@ -1627,115 +2182,117 @@ TEST_CASE("integration: analytics index management", "[integration]")
             auto index_name = test::utils::uniq_id("index");
 
             {
-                couchbase::operations::management::analytics_dataverse_create_request req{};
+                couchbase::core::operations::management::analytics_dataverse_create_request req{};
                 req.dataverse_name = dataverse_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_dataset_create_request req{};
+                couchbase::core::operations::management::analytics_dataset_create_request req{};
                 req.bucket_name = integration.ctx.bucket;
                 req.dataverse_name = dataverse_name;
                 req.dataset_name = dataset_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_index_create_request req{};
+                couchbase::core::operations::management::analytics_index_create_request req{};
                 req.dataverse_name = dataverse_name;
                 req.dataset_name = dataset_name;
                 req.index_name = index_name;
                 req.fields["testkey"] = "string";
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_link_connect_request req{};
+                couchbase::core::operations::management::analytics_link_connect_request req{};
                 req.dataverse_name = dataverse_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_link_disconnect_request req{};
+                couchbase::core::operations::management::analytics_link_disconnect_request req{};
                 req.dataverse_name = dataverse_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_index_drop_request req{};
+                couchbase::core::operations::management::analytics_index_drop_request req{};
                 req.dataverse_name = dataverse_name;
                 req.dataset_name = dataset_name;
                 req.index_name = index_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_dataset_drop_request req{};
+                couchbase::core::operations::management::analytics_dataset_drop_request req{};
                 req.dataverse_name = dataverse_name;
                 req.dataset_name = dataset_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::analytics_dataverse_drop_request req{};
+                couchbase::core::operations::management::analytics_dataverse_drop_request req{};
                 req.dataverse_name = dataverse_name;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
         }
     }
 }
 
 void
-run_s3_link_test(test::utils::integration_test_guard& integration, std::string dataverse_name, std::string link_name)
+run_s3_link_test(test::utils::integration_test_guard& integration, const std::string& dataverse_name, const std::string& link_name)
 {
     {
-        couchbase::operations::management::analytics_dataverse_create_request req{};
+        couchbase::core::operations::management::analytics_dataverse_create_request req{};
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::management::analytics::s3_external_link link{};
+        couchbase::core::management::analytics::s3_external_link link{};
         link.dataverse = dataverse_name;
         link.access_key_id = "access_key";
         link.secret_access_key = "secret_access_key";
         link.region = "us-east-1";
         link.service_endpoint = "service_endpoint";
         link.link_name = link_name;
-        couchbase::operations::management::analytics_link_create_request<couchbase::management::analytics::s3_external_link> req{};
+        couchbase::core::operations::management::analytics_link_create_request<couchbase::core::management::analytics::s3_external_link>
+          req{};
         req.link = link;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::management::analytics::s3_external_link link{};
+        couchbase::core::management::analytics::s3_external_link link{};
         link.dataverse = dataverse_name;
         link.access_key_id = "access_key";
         link.secret_access_key = "secret_access_key";
         link.region = "us-east-1";
         link.service_endpoint = "service_endpoint";
         link.link_name = link_name;
-        couchbase::operations::management::analytics_link_create_request<couchbase::management::analytics::s3_external_link> req{};
+        couchbase::core::operations::management::analytics_link_create_request<couchbase::core::management::analytics::s3_external_link>
+          req{};
         req.link = link;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::link_exists);
+        REQUIRE(resp.ctx.ec == couchbase::errc::analytics::link_exists);
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.s3.size() == 1);
         REQUIRE(resp.s3[0].link_name == link_name);
         REQUIRE(resp.s3[0].dataverse == dataverse_name);
@@ -1746,108 +2303,113 @@ run_s3_link_test(test::utils::integration_test_guard& integration, std::string d
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.link_type = "s3";
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.s3.size() == 1);
         REQUIRE(resp.azure_blob.empty());
         REQUIRE(resp.couchbase.empty());
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.link_type = "couchbase";
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.s3.empty());
         REQUIRE(resp.azure_blob.empty());
         REQUIRE(resp.couchbase.empty());
     }
 
     {
-        couchbase::management::analytics::s3_external_link link{};
+        couchbase::core::management::analytics::s3_external_link link{};
         link.dataverse = dataverse_name;
         link.access_key_id = "access_key";
         link.secret_access_key = "secret_access_key";
         link.region = "eu-west-1";
         link.service_endpoint = "service_endpoint";
         link.link_name = link_name;
-        couchbase::operations::management::analytics_link_replace_request<couchbase::management::analytics::s3_external_link> req{};
+        couchbase::core::operations::management::analytics_link_replace_request<couchbase::core::management::analytics::s3_external_link>
+          req{};
         req.link = link;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.s3.size() == 1);
         REQUIRE(resp.s3[0].region == "eu-west-1");
     }
 
     {
-        couchbase::operations::management::analytics_link_drop_request req{};
+        couchbase::core::operations::management::analytics_link_drop_request req{};
         req.dataverse_name = dataverse_name;
         req.link_name = link_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::analytics_link_drop_request req{};
+        couchbase::core::operations::management::analytics_link_drop_request req{};
         req.dataverse_name = dataverse_name;
         req.link_name = link_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::link_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::analytics::link_not_found);
     }
 }
 
 void
-run_azure_link_test(test::utils::integration_test_guard& integration, std::string dataverse_name, std::string link_name)
+run_azure_link_test(test::utils::integration_test_guard& integration, const std::string& dataverse_name, const std::string& link_name)
 {
     {
-        couchbase::operations::management::analytics_dataverse_create_request req{};
+        couchbase::core::operations::management::analytics_dataverse_create_request req{};
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::management::analytics::azure_blob_external_link link{};
+        couchbase::core::management::analytics::azure_blob_external_link link{};
         link.dataverse = dataverse_name;
         link.connection_string = "connection_string";
         link.blob_endpoint = "blob_endpoint";
         link.endpoint_suffix = "endpoint_suffix";
         link.link_name = link_name;
-        couchbase::operations::management::analytics_link_create_request<couchbase::management::analytics::azure_blob_external_link> req{};
+        couchbase::core::operations::management::analytics_link_create_request<
+          couchbase::core::management::analytics::azure_blob_external_link>
+          req{};
         req.link = link;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::management::analytics::azure_blob_external_link link{};
+        couchbase::core::management::analytics::azure_blob_external_link link{};
         link.dataverse = dataverse_name;
         link.connection_string = "connection_string";
         link.blob_endpoint = "blob_endpoint";
         link.endpoint_suffix = "endpoint_suffix";
         link.link_name = link_name;
-        couchbase::operations::management::analytics_link_create_request<couchbase::management::analytics::azure_blob_external_link> req{};
+        couchbase::core::operations::management::analytics_link_create_request<
+          couchbase::core::management::analytics::azure_blob_external_link>
+          req{};
         req.link = link;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::link_exists);
+        REQUIRE(resp.ctx.ec == couchbase::errc::analytics::link_exists);
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.azure_blob.size() == 1);
         REQUIRE(resp.azure_blob[0].link_name == link_name);
         REQUIRE(resp.azure_blob[0].dataverse == dataverse_name);
@@ -1860,63 +2422,65 @@ run_azure_link_test(test::utils::integration_test_guard& integration, std::strin
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.link_type = "azureblob";
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.azure_blob.size() == 1);
         REQUIRE(resp.s3.empty());
         REQUIRE(resp.couchbase.empty());
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.link_type = "couchbase";
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.s3.empty());
         REQUIRE(resp.azure_blob.empty());
         REQUIRE(resp.couchbase.empty());
     }
 
     {
-        couchbase::management::analytics::azure_blob_external_link link{};
+        couchbase::core::management::analytics::azure_blob_external_link link{};
         link.dataverse = dataverse_name;
         link.connection_string = "connection_string";
         link.blob_endpoint = "new_blob_endpoint";
         link.endpoint_suffix = "endpoint_suffix";
         link.link_name = link_name;
-        couchbase::operations::management::analytics_link_replace_request<couchbase::management::analytics::azure_blob_external_link> req{};
+        couchbase::core::operations::management::analytics_link_replace_request<
+          couchbase::core::management::analytics::azure_blob_external_link>
+          req{};
         req.link = link;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::analytics_link_get_all_request req{};
+        couchbase::core::operations::management::analytics_link_get_all_request req{};
         req.dataverse_name = dataverse_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.azure_blob.size() == 1);
         REQUIRE(resp.azure_blob[0].blob_endpoint == "new_blob_endpoint");
     }
 
     {
-        couchbase::operations::management::analytics_link_drop_request req{};
+        couchbase::core::operations::management::analytics_link_drop_request req{};
         req.dataverse_name = dataverse_name;
         req.link_name = link_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::analytics_link_drop_request req{};
+        couchbase::core::operations::management::analytics_link_drop_request req{};
         req.dataverse_name = dataverse_name;
         req.link_name = link_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::link_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::analytics::link_not_found);
     }
 }
 
@@ -1929,7 +2493,7 @@ TEST_CASE("integration: analytics external link management", "[integration]")
     }
 
     // MB-47718
-    if (integration.storage_backend() == couchbase::management::cluster::bucket_storage_backend::magma) {
+    if (integration.storage_backend() == couchbase::core::management::cluster::bucket_storage_backend::magma) {
         return;
     }
 
@@ -1944,7 +2508,7 @@ TEST_CASE("integration: analytics external link management", "[integration]")
 
     SECTION("missing dataverse")
     {
-        couchbase::management::analytics::s3_external_link link{};
+        couchbase::core::management::analytics::s3_external_link link{};
         link.dataverse = "missing_dataverse";
         link.access_key_id = "access_key";
         link.secret_access_key = "secret_access_key";
@@ -1953,19 +2517,21 @@ TEST_CASE("integration: analytics external link management", "[integration]")
         link.link_name = link_name;
 
         {
-            couchbase::operations::management::analytics_link_create_request<couchbase::management::analytics::s3_external_link> req{};
+            couchbase::core::operations::management::analytics_link_create_request<couchbase::core::management::analytics::s3_external_link>
+              req{};
             req.link = link;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::analytics_errc::dataverse_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::analytics::dataverse_not_found);
         }
     }
 
     SECTION("missing argument")
     {
-        couchbase::operations::management::analytics_link_create_request<couchbase::management::analytics::s3_external_link> req{};
-        req.link = couchbase::management::analytics::s3_external_link{};
+        couchbase::core::operations::management::analytics_link_create_request<couchbase::core::management::analytics::s3_external_link>
+          req{};
+        req.link = couchbase::core::management::analytics::s3_external_link{};
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::invalid_argument);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::invalid_argument);
     }
 
     SECTION("link crud")
@@ -1991,9 +2557,9 @@ TEST_CASE("integration: analytics external link management", "[integration]")
             auto scope_name = test::utils::uniq_id("scope");
 
             {
-                couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+                couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
                 auto created =
                   test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
                 REQUIRE(created);
@@ -2016,6 +2582,9 @@ TEST_CASE("integration: analytics external link management", "[integration]")
     }
 }
 
+// serverless requires 1 partition and 1 replica
+const std::string serverless_plan_params = R"({ "indexPartition": 1, "numReplicas": 1 })";
+
 TEST_CASE("integration: search index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
@@ -2026,121 +2595,166 @@ TEST_CASE("integration: search index management", "[integration]")
 
     SECTION("search indexes crud")
     {
-        auto index1_name = test::utils::uniq_id("index");
-        auto index2_name = test::utils::uniq_id("index");
+        auto index1_name = test::utils::uniq_id("index1");
+        auto index2_name = test::utils::uniq_id("index2");
         auto alias_name = test::utils::uniq_id("alias");
 
         {
-            couchbase::management::search::index index;
+            couchbase::core::management::search::index index;
             index.name = index1_name;
             index.type = "fulltext-index";
             index.source_type = "couchbase";
             index.source_name = integration.ctx.bucket;
-            couchbase::operations::management::search_index_upsert_request req{};
+            if (integration.cluster_version().is_serverless_config_profile()) {
+                index.plan_params_json = serverless_plan_params;
+            }
+            couchbase::core::operations::management::search_index_upsert_request req{};
             req.index = index;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::management::search::index index;
+            couchbase::core::management::search::index index;
             index.name = index1_name;
             index.type = "fulltext-index";
             index.source_type = "couchbase";
             index.source_name = integration.ctx.bucket;
-            couchbase::operations::management::search_index_upsert_request req{};
+            if (integration.cluster_version().is_serverless_config_profile()) {
+                index.plan_params_json = serverless_plan_params;
+            }
+            couchbase::core::operations::management::search_index_upsert_request req{};
             req.index = index;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_exists);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::index_exists);
         }
 
         {
-            couchbase::management::search::index index;
+            couchbase::core::management::search::index index;
             index.name = index2_name;
             index.type = "fulltext-index";
             index.source_type = "couchbase";
             index.source_name = integration.ctx.bucket;
             index.plan_params_json = R"({ "indexPartition": 3 })";
+            if (integration.cluster_version().is_serverless_config_profile()) {
+                index.plan_params_json = serverless_plan_params;
+            }
             index.params_json = R"({ "store": { "indexType": "upside_down", "kvStoreName": "moss" }})";
-            couchbase::operations::management::search_index_upsert_request req{};
+            couchbase::core::operations::management::search_index_upsert_request req{};
             req.index = index;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            if (resp.name != index2_name) {
+                // FIXME: server 7.2 might automatically prepend "{scope}.{collection}." in front of the index name
+                // to workaround it, we "patch" our variable with the name returned by the server
+                index2_name = resp.name;
+            }
         }
 
         {
-            couchbase::management::search::index index;
+            couchbase::core::management::search::index index;
             index.name = alias_name;
             index.type = "fulltext-alias";
             index.source_type = "nil";
-            index.params_json = couchbase::utils::json::generate(
+            index.params_json = couchbase::core::utils::json::generate(
               tao::json::value{ { "targets", { { index1_name, tao::json::empty_object }, { index2_name, tao::json::empty_object } } } });
-            couchbase::operations::management::search_index_upsert_request req{};
+            if (integration.cluster_version().is_serverless_config_profile()) {
+                index.plan_params_json = serverless_plan_params;
+            }
+            couchbase::core::operations::management::search_index_upsert_request req{};
             req.index = index;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::search_index_get_request req{};
+            couchbase::core::operations::management::search_index_get_request req{};
             req.index_name = index1_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.index.name == index1_name);
             REQUIRE(resp.index.type == "fulltext-index");
         }
 
         {
-            couchbase::operations::management::search_index_get_request req{};
+            couchbase::core::operations::management::search_index_get_request req{};
+            req.index_name = index2_name;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            REQUIRE(resp.index.name == index2_name);
+            REQUIRE(resp.index.type == "fulltext-index");
+        }
+
+        {
+            couchbase::core::operations::management::search_index_get_request req{};
+            req.index_name = alias_name;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            REQUIRE(resp.index.name == alias_name);
+            REQUIRE(resp.index.type == "fulltext-alias");
+        }
+
+        {
+            couchbase::core::operations::management::search_index_get_request req{};
             req.index_name = "missing_index";
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::index_not_found);
         }
 
         {
-            couchbase::operations::management::search_index_get_all_request req{};
+            couchbase::core::operations::management::search_index_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE_FALSE(resp.indexes.empty());
+
+            REQUIRE(1 == std::count_if(
+                           resp.indexes.begin(), resp.indexes.end(), [&index1_name](const auto& i) { return i.name == index1_name; }));
+            REQUIRE(1 == std::count_if(
+                           resp.indexes.begin(), resp.indexes.end(), [&index2_name](const auto& i) { return i.name == index2_name; }));
+            REQUIRE(1 ==
+                    std::count_if(resp.indexes.begin(), resp.indexes.end(), [&alias_name](const auto& i) { return i.name == alias_name; }));
         }
 
         {
-            couchbase::operations::management::search_index_drop_request req{};
+            couchbase::core::operations::management::search_index_drop_request req{};
             req.index_name = index1_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::search_index_drop_request req{};
+            couchbase::core::operations::management::search_index_drop_request req{};
             req.index_name = index2_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::search_index_drop_request req{};
+            couchbase::core::operations::management::search_index_drop_request req{};
             req.index_name = alias_name;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        couchbase::operations::management::search_index_drop_request req{};
+        couchbase::core::operations::management::search_index_drop_request req{};
         req.index_name = "missing_index";
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::index_not_found);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::index_not_found);
     }
 
     SECTION("upsert index no name")
     {
-        couchbase::management::search::index index;
+        couchbase::core::management::search::index index;
         index.type = "fulltext-index";
         index.source_type = "couchbase";
         index.source_name = integration.ctx.bucket;
-        couchbase::operations::management::search_index_upsert_request req{};
+        if (integration.cluster_version().is_serverless_config_profile()) {
+            index.plan_params_json = serverless_plan_params;
+        }
+        couchbase::core::operations::management::search_index_upsert_request req{};
         req.index = index;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::invalid_argument);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::invalid_argument);
     }
 
     SECTION("control")
@@ -2148,78 +2762,81 @@ TEST_CASE("integration: search index management", "[integration]")
         auto index_name = test::utils::uniq_id("index");
 
         {
-            couchbase::management::search::index index;
+            couchbase::core::management::search::index index;
             index.name = index_name;
             index.type = "fulltext-index";
             index.source_type = "couchbase";
             index.source_name = integration.ctx.bucket;
-            couchbase::operations::management::search_index_upsert_request req{};
+            if (integration.cluster_version().is_serverless_config_profile()) {
+                index.plan_params_json = serverless_plan_params;
+            }
+            couchbase::core::operations::management::search_index_upsert_request req{};
             req.index = index;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         SECTION("ingest control")
         {
             {
-                couchbase::operations::management::search_index_control_ingest_request req{};
+                couchbase::core::operations::management::search_index_control_ingest_request req{};
                 req.index_name = index_name;
                 req.pause = true;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::search_index_control_ingest_request req{};
+                couchbase::core::operations::management::search_index_control_ingest_request req{};
                 req.index_name = index_name;
                 req.pause = false;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
         }
 
         SECTION("query control")
         {
             {
-                couchbase::operations::management::search_index_control_query_request req{};
+                couchbase::core::operations::management::search_index_control_query_request req{};
                 req.index_name = index_name;
                 req.allow = true;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::search_index_control_query_request req{};
+                couchbase::core::operations::management::search_index_control_query_request req{};
                 req.index_name = index_name;
                 req.allow = false;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
         }
 
         SECTION("partition control")
         {
             {
-                couchbase::operations::management::search_index_control_plan_freeze_request req{};
+                couchbase::core::operations::management::search_index_control_plan_freeze_request req{};
                 req.index_name = index_name;
                 req.freeze = true;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
 
             {
-                couchbase::operations::management::search_index_control_plan_freeze_request req{};
+                couchbase::core::operations::management::search_index_control_plan_freeze_request req{};
                 req.index_name = index_name;
                 req.freeze = false;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
         }
 
-        couchbase::operations::management::search_index_drop_request req{};
+        couchbase::core::operations::management::search_index_drop_request req{};
         req.index_name = index_name;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 }
 
@@ -2228,12 +2845,12 @@ wait_for_search_pindexes_ready(test::utils::integration_test_guard& integration,
 {
     return test::utils::wait_until(
       [&integration, &index_name]() {
-          couchbase::operations::management::search_index_stats_request req{};
+          couchbase::core::operations::management::search_index_stats_request req{};
           auto resp = test::utils::execute(integration.cluster, req);
           if (resp.ctx.ec || resp.stats.empty()) {
               return false;
           }
-          auto stats = couchbase::utils::json::parse(resp.stats);
+          auto stats = couchbase::core::utils::json::parse(resp.stats);
           const auto* num_pindexes_actual = stats.find(fmt::format("{}:{}:num_pindexes_actual", integration.ctx.bucket, index_name));
           if (num_pindexes_actual == nullptr || !num_pindexes_actual->is_number()) {
               return false;
@@ -2258,29 +2875,32 @@ TEST_CASE("integration: search index management analyze document", "[integration
     auto index_name = test::utils::uniq_id("index");
 
     {
-        couchbase::management::search::index index;
+        couchbase::core::management::search::index index;
         index.name = index_name;
         index.type = "fulltext-index";
         index.source_type = "couchbase";
         index.source_name = integration.ctx.bucket;
-        couchbase::operations::management::search_index_upsert_request req{};
+        if (integration.cluster_version().is_serverless_config_profile()) {
+            index.plan_params_json = serverless_plan_params;
+        }
+        couchbase::core::operations::management::search_index_upsert_request req{};
         req.index = index;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     REQUIRE(wait_for_search_pindexes_ready(integration, index_name));
 
-    couchbase::operations::management::search_index_analyze_document_response resp;
+    couchbase::core::operations::management::search_index_analyze_document_response resp;
     bool operation_completed = test::utils::wait_until([&integration, &index_name, &resp]() {
-        couchbase::operations::management::search_index_analyze_document_request req{};
+        couchbase::core::operations::management::search_index_analyze_document_request req{};
         req.index_name = index_name;
         req.encoded_document = R"({ "name": "hello world" })";
         resp = test::utils::execute(integration.cluster, req);
-        return resp.ctx.ec != couchbase::error::common_errc::internal_server_failure;
+        return resp.ctx.ec != couchbase::errc::common::internal_server_failure;
     });
     REQUIRE(operation_completed);
-    REQUIRE_FALSE(resp.ctx.ec);
+    REQUIRE_SUCCESS(resp.ctx.ec);
     REQUIRE_FALSE(resp.analysis.empty());
 }
 
@@ -2294,37 +2914,37 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
 
     SECTION("key_value")
     {
-        couchbase::operations::management::freeform_request req{};
-        req.type = couchbase::service_type::key_value;
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::key_value;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::invalid_argument);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::invalid_argument);
     }
 
     if (integration.cluster_version().supports_analytics() && integration.has_analytics_service()) {
         SECTION("analytics")
         {
-            couchbase::operations::management::freeform_request req{};
-            req.type = couchbase::service_type::analytics;
+            couchbase::core::operations::management::freeform_request req{};
+            req.type = couchbase::core::service_type::analytics;
             req.method = "GET";
             req.path = "/admin/ping";
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.status == 200);
             REQUIRE_FALSE(resp.body.empty());
             INFO(resp.body)
-            auto result = couchbase::utils::json::parse(resp.body);
+            auto result = couchbase::core::utils::json::parse(resp.body);
             REQUIRE(result.is_object());
         }
     }
 
     SECTION("search")
     {
-        couchbase::operations::management::freeform_request req{};
-        req.type = couchbase::service_type::search;
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::search;
         req.method = "GET";
         req.path = "/api/ping";
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.status == 200);
         REQUIRE(resp.body.empty());
         REQUIRE_FALSE(resp.headers.empty());
@@ -2333,49 +2953,51 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
 
     SECTION("query")
     {
-        couchbase::operations::management::freeform_request req{};
-        req.type = couchbase::service_type::query;
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::query;
         req.method = "GET";
         req.path = "/admin/ping";
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.status == 200);
         REQUIRE_FALSE(resp.body.empty());
         INFO(resp.body)
-        auto result = couchbase::utils::json::parse(resp.body);
+        auto result = couchbase::core::utils::json::parse(resp.body);
         REQUIRE(result.is_object());
     }
 
-    SECTION("view")
-    {
-        auto document_name = test::utils::uniq_id("design_document");
-        auto view_name = test::utils::uniq_id("view");
+    if (integration.cluster_version().supports_views()) {
+        SECTION("view")
+        {
+            auto document_name = test::utils::uniq_id("design_document");
+            auto view_name = test::utils::uniq_id("view");
 
-        couchbase::operations::management::freeform_request req{};
-        req.type = couchbase::service_type::view;
-        req.method = "POST";
-        req.path = fmt::format("/{}/_design/{}/_view/{}", integration.ctx.bucket, document_name, view_name);
-        req.body = R"({"keys":["foo","bar"]})";
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.status == 404);
-        REQUIRE_FALSE(resp.body.empty());
-        auto result = couchbase::utils::json::parse(resp.body);
-        INFO(resp.body)
-        REQUIRE(result["error"].get_string() == "not_found");
+            couchbase::core::operations::management::freeform_request req{};
+            req.type = couchbase::core::service_type::view;
+            req.method = "POST";
+            req.path = fmt::format("/{}/_design/{}/_view/{}", integration.ctx.bucket, document_name, view_name);
+            req.body = R"({"keys":["foo","bar"]})";
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            REQUIRE(resp.status == 404);
+            REQUIRE_FALSE(resp.body.empty());
+            auto result = couchbase::core::utils::json::parse(resp.body);
+            INFO(resp.body)
+            REQUIRE(result["error"].get_string() == "not_found");
+        }
     }
 
     SECTION("management")
     {
-        couchbase::operations::management::freeform_request req{};
-        req.type = couchbase::service_type::management;
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::management;
         req.method = "GET";
         req.path = "/pools";
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.status == 200);
         REQUIRE_FALSE(resp.body.empty());
-        auto result = couchbase::utils::json::parse(resp.body);
+        auto result = couchbase::core::utils::json::parse(resp.body);
         INFO(resp.body)
         REQUIRE(result.find("uuid") != nullptr);
     }
@@ -2385,18 +3007,18 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
         {
             auto scope_name = test::utils::uniq_id("freeform_scope");
 
-            couchbase::operations::management::freeform_request req{};
-            req.type = couchbase::service_type::management;
+            couchbase::core::operations::management::freeform_request req{};
+            req.type = couchbase::core::service_type::management;
             req.method = "POST";
             req.path = fmt::format("/pools/default/buckets/{}/scopes", integration.ctx.bucket);
             req.headers["content-type"] = "application/x-www-form-urlencoded";
-            req.body = fmt::format("name={}", couchbase::utils::string_codec::form_encode(scope_name));
+            req.body = fmt::format("name={}", couchbase::core::utils::string_codec::form_encode(scope_name));
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.status == 200);
             REQUIRE_FALSE(resp.headers.empty());
             REQUIRE(resp.headers["content-type"].find("application/json") != std::string::npos);
-            auto result = couchbase::utils::json::parse(resp.body);
+            auto result = couchbase::core::utils::json::parse(resp.body);
             REQUIRE(result.is_object());
             REQUIRE(result.find("uid") != nullptr);
         }
@@ -2406,27 +3028,27 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
         SECTION("eventing")
         {
 
-            couchbase::operations::management::freeform_request req{};
-            req.type = couchbase::service_type::eventing;
+            couchbase::core::operations::management::freeform_request req{};
+            req.type = couchbase::core::service_type::eventing;
             req.method = "GET";
             req.path = "/api/v1/functions";
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.status == 200);
             REQUIRE_FALSE(resp.body.empty());
-            auto result = couchbase::utils::json::parse(resp.body);
+            auto result = couchbase::core::utils::json::parse(resp.body);
             INFO(resp.body)
             REQUIRE(result.is_array());
         }
     }
 }
 
-static couchbase::operations::management::eventing_get_function_response
+static couchbase::core::operations::management::eventing_get_function_response
 wait_for_function_created(test::utils::integration_test_guard& integration, const std::string& function_name)
 {
-    couchbase::operations::management::eventing_get_function_response resp{};
+    couchbase::core::operations::management::eventing_get_function_response resp{};
     test::utils::wait_until([&integration, &resp, function_name]() {
-        couchbase::operations::management::eventing_get_function_request req{ function_name };
+        couchbase::core::operations::management::eventing_get_function_request req{ function_name };
         resp = test::utils::execute(integration.cluster, req);
         return !resp.ctx.ec;
     });
@@ -2436,11 +3058,11 @@ wait_for_function_created(test::utils::integration_test_guard& integration, cons
 static bool
 wait_for_function_reach_status(test::utils::integration_test_guard& integration,
                                const std::string& function_name,
-                               couchbase::management::eventing::function_status status)
+                               couchbase::core::management::eventing::function_status status)
 {
     return test::utils::wait_until(
       [&integration, function_name, status]() {
-          couchbase::operations::management::eventing_get_status_request req{};
+          couchbase::core::operations::management::eventing_get_status_request req{};
           auto resp = test::utils::execute(integration.cluster, req);
           if (resp.ctx.ec) {
               return false;
@@ -2473,39 +3095,39 @@ TEST_CASE("integration: eventing functions management", "[integration]")
         auto function_name = test::utils::uniq_id("name");
 
         {
-            couchbase::operations::management::eventing_drop_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_drop_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
             if (integration.cluster_version().is_cheshire_cat()) {
-                REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_not_deployed);
+                REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_not_deployed);
             } else {
-                REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_not_found);
+                REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_not_found);
             }
         }
 
         {
-            couchbase::operations::management::eventing_get_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_get_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_not_found);
         }
 
         auto meta_bucket_name = test::utils::uniq_id("meta");
         {
 
-            couchbase::management::cluster::bucket_settings bucket_settings;
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
             bucket_settings.name = meta_bucket_name;
             bucket_settings.ram_quota_mb = 256;
 
             {
-                couchbase::operations::management::bucket_create_request req;
+                couchbase::core::operations::management::bucket_create_request req;
                 req.bucket = bucket_settings;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_FALSE(resp.ctx.ec);
+                REQUIRE_SUCCESS(resp.ctx.ec);
             }
         }
 
         {
             auto resp = wait_for_bucket_created(integration, meta_bucket_name);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         std::string source_code = R"(
@@ -2519,38 +3141,38 @@ function OnDelete(meta, options) {
 )";
 
         {
-            couchbase::operations::management::eventing_upsert_function_request req{};
+            couchbase::core::operations::management::eventing_upsert_function_request req{};
             req.function.source_keyspace.bucket = integration.ctx.bucket;
             req.function.metadata_keyspace.bucket = meta_bucket_name;
             req.function.name = function_name;
             req.function.code = source_code;
             req.function.settings.handler_headers = { "// generated by Couchbase C++ SDK" };
-            req.function.constant_bindings.emplace_back(couchbase::management::eventing::function_constant_binding{ "PI", "3.14" });
-            req.function.bucket_bindings.emplace_back(couchbase::management::eventing::function_bucket_binding{
-              "data", { integration.ctx.bucket }, couchbase::management::eventing::function_bucket_access::read_write });
+            req.function.constant_bindings.emplace_back(couchbase::core::management::eventing::function_constant_binding{ "PI", "3.14" });
+            req.function.bucket_bindings.emplace_back(couchbase::core::management::eventing::function_bucket_binding{
+              "data", { integration.ctx.bucket }, couchbase::core::management::eventing::function_bucket_access::read_write });
             req.function.url_bindings.emplace_back(
-              couchbase::management::eventing::function_url_binding{ "home", "https://couchbase.com" });
+              couchbase::core::management::eventing::function_url_binding{ "home", "https://couchbase.com" });
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
             auto resp = wait_for_function_created(integration, function_name);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::eventing_get_all_functions_request req{};
+            couchbase::core::operations::management::eventing_get_all_functions_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             auto function = std::find_if(
-              resp.functions.begin(), resp.functions.end(), [function_name](const auto& fun) { return function_name == fun.name; });
+              resp.functions.begin(), resp.functions.end(), [&function_name](const auto& fun) { return function_name == fun.name; });
             REQUIRE(function != resp.functions.end());
             REQUIRE(function->code == source_code);
             REQUIRE(function->source_keyspace.bucket == integration.ctx.bucket);
             REQUIRE(function->metadata_keyspace.bucket == meta_bucket_name);
-            REQUIRE(function->settings.deployment_status == couchbase::management::eventing::function_deployment_status::undeployed);
-            REQUIRE(function->settings.processing_status == couchbase::management::eventing::function_processing_status::paused);
+            REQUIRE(function->settings.deployment_status == couchbase::core::management::eventing::function_deployment_status::undeployed);
+            REQUIRE(function->settings.processing_status == couchbase::core::management::eventing::function_processing_status::paused);
             REQUIRE(!function->settings.handler_headers.empty());
             REQUIRE(function->settings.handler_headers[0] == "// generated by Couchbase C++ SDK");
             REQUIRE(!function->constant_bindings.empty());
@@ -2559,99 +3181,102 @@ function OnDelete(meta, options) {
             REQUIRE(!function->bucket_bindings.empty());
             REQUIRE(function->bucket_bindings[0].alias == "data");
             REQUIRE(function->bucket_bindings[0].name.bucket == "default");
-            REQUIRE(function->bucket_bindings[0].access == couchbase::management::eventing::function_bucket_access::read_write);
+            REQUIRE(function->bucket_bindings[0].access == couchbase::core::management::eventing::function_bucket_access::read_write);
             REQUIRE(!function->url_bindings.empty());
             REQUIRE(function->url_bindings[0].alias == "home");
             REQUIRE(function->url_bindings[0].hostname == "https://couchbase.com");
-            REQUIRE(std::holds_alternative<couchbase::management::eventing::function_url_no_auth>(function->url_bindings[0].auth));
+            REQUIRE(std::holds_alternative<couchbase::core::management::eventing::function_url_no_auth>(function->url_bindings[0].auth));
         }
 
         {
-            couchbase::operations::management::eventing_get_status_request req{};
+            couchbase::core::operations::management::eventing_get_status_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
             REQUIRE(resp.status.num_eventing_nodes > 0);
-            auto function = std::find_if(resp.status.functions.begin(), resp.status.functions.end(), [function_name](const auto& fun) {
+            auto function = std::find_if(resp.status.functions.begin(), resp.status.functions.end(), [&function_name](const auto& fun) {
                 return function_name == fun.name;
             });
             REQUIRE(function != resp.status.functions.end());
-            REQUIRE(function->status == couchbase::management::eventing::function_status::undeployed);
-            REQUIRE(function->deployment_status == couchbase::management::eventing::function_deployment_status::undeployed);
-            REQUIRE(function->processing_status == couchbase::management::eventing::function_processing_status::paused);
+            REQUIRE(function->status == couchbase::core::management::eventing::function_status::undeployed);
+            REQUIRE(function->deployment_status == couchbase::core::management::eventing::function_deployment_status::undeployed);
+            REQUIRE(function->processing_status == couchbase::core::management::eventing::function_processing_status::paused);
         }
 
         {
-            couchbase::operations::management::eventing_undeploy_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_undeploy_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_not_deployed);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_not_deployed);
         }
 
         {
-            couchbase::operations::management::eventing_deploy_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_deploy_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        REQUIRE(wait_for_function_reach_status(integration, function_name, couchbase::management::eventing::function_status::deployed));
+        REQUIRE(
+          wait_for_function_reach_status(integration, function_name, couchbase::core::management::eventing::function_status::deployed));
 
         {
-            couchbase::operations::management::eventing_drop_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_drop_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_deployed);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_deployed);
         }
 
         {
-            couchbase::operations::management::eventing_resume_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_resume_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_deployed);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_deployed);
         }
 
         {
-            couchbase::operations::management::eventing_pause_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_pause_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        REQUIRE(wait_for_function_reach_status(integration, function_name, couchbase::management::eventing::function_status::paused));
+        REQUIRE(wait_for_function_reach_status(integration, function_name, couchbase::core::management::eventing::function_status::paused));
 
         {
-            couchbase::operations::management::eventing_pause_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_pause_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_paused);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_paused);
         }
 
         {
-            couchbase::operations::management::eventing_resume_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_resume_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        REQUIRE(wait_for_function_reach_status(integration, function_name, couchbase::management::eventing::function_status::deployed));
+        REQUIRE(
+          wait_for_function_reach_status(integration, function_name, couchbase::core::management::eventing::function_status::deployed));
 
         {
-            couchbase::operations::management::eventing_undeploy_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_undeploy_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
-        REQUIRE(wait_for_function_reach_status(integration, function_name, couchbase::management::eventing::function_status::undeployed));
+        REQUIRE(
+          wait_for_function_reach_status(integration, function_name, couchbase::core::management::eventing::function_status::undeployed));
 
         {
-            couchbase::operations::management::eventing_drop_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_drop_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
 
         {
-            couchbase::operations::management::eventing_get_function_request req{ function_name };
+            couchbase::core::operations::management::eventing_get_function_request req{ function_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::management_errc::eventing_function_not_found);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::eventing_function_not_found);
         }
 
         {
-            couchbase::operations::management::bucket_drop_request req{ meta_bucket_name };
+            couchbase::core::operations::management::bucket_drop_request req{ meta_bucket_name };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec);
         }
     }
 }