couchbase 4.0.0 → 4.1.0

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_index_create.hxx

@@ -20,20 +20,16 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
+#include <couchbase/operations/management/analytics_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations::management
 {
 struct analytics_index_create_response {
-    struct problem {
-        std::uint32_t code;
-        std::string message;
-    };
-
     error_context::http ctx;
     std::string status{};
-    std::vector<problem> errors{};
+    std::vector<analytics_problem> errors{};
 };
 
 struct analytics_index_create_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_index_drop.cxx

@@ -61,7 +61,7 @@ analytics_index_drop_request::make_response(error_context::http&& ctx, const enc
 
             if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
-                    analytics_index_drop_response::problem err{
+                    analytics_problem err{
                         error.at("code").as<std::uint32_t>(),
                         error.at("msg").get_string(),
                     };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_index_drop.hxx

@@ -17,23 +17,19 @@
 
 #pragma once
 
-#include <couchbase/platform/uuid.h>
+#include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
+#include <couchbase/operations/management/analytics_problem.hxx>
+#include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
-#include <couchbase/error_context/http.hxx>
 
 namespace couchbase::operations::management
 {
 struct analytics_index_drop_response {
-    struct problem {
-        std::uint32_t code;
-        std::string message;
-    };
-
     error_context::http ctx;
     std::string status{};
-    std::vector<problem> errors{};
+    std::vector<analytics_problem> errors{};
 };
 
 struct analytics_index_drop_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_index_get_all.cxx

@@ -54,7 +54,7 @@ analytics_index_get_all_request::make_response(error_context::http&& ctx, const
         if (response.status == "success") {
             if (auto* results = payload.find("results"); results != nullptr && results->is_array()) {
                 for (const auto& res : results->get_array()) {
-                    analytics_index_get_all_response::index idx;
+                    couchbase::management::analytics::index idx;
                     idx.name = res.at("IndexName").get_string();
                     idx.dataverse_name = res.at("DataverseName").get_string();
                     idx.dataset_name = res.at("DatasetName").get_string();
@@ -65,7 +65,7 @@ analytics_index_get_all_request::make_response(error_context::http&& ctx, const
         } else {
             if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
-                    analytics_index_get_all_response::problem err{
+                    analytics_problem err{
                         error.at("code").as<std::uint32_t>(),
                         error.at("msg").get_string(),
                     };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_index_get_all.hxx

@@ -20,28 +20,18 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
+#include <couchbase/management/analytics_index.hxx>
+#include <couchbase/operations/management/analytics_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations::management
 {
 struct analytics_index_get_all_response {
-    struct index {
-        std::string name;
-        std::string dataverse_name;
-        std::string dataset_name;
-        bool is_primary;
-    };
-
-    struct problem {
-        std::uint32_t code;
-        std::string message;
-    };
-
     error_context::http ctx;
     std::string status{};
-    std::vector<index> indexes{};
-    std::vector<problem> errors{};
+    std::vector<couchbase::management::analytics::index> indexes{};
+    std::vector<analytics_problem> errors{};
 };
 
 struct analytics_index_get_all_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_link_create.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/analytics_link.hxx>
+#include <couchbase/operations/management/analytics_link_utils.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -64,7 +64,7 @@ struct analytics_link_create_request {
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
         encoded.headers["accept"] = "application/json";
         encoded.method = "POST";
-        encoded.path = analytics_link::endpoint_from_link(link);
+        encoded.path = endpoint_from_analytics_link(link);
         encoded.body = link.encode();
         return {};
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_link_get_all.cxx

@@ -18,9 +18,9 @@
 #include <couchbase/operations/management/analytics_link_get_all.hxx>
 
 #include <couchbase/errors.hxx>
-#include <couchbase/operations/management/analytics_link_azure_blob_external_json.hxx>
-#include <couchbase/operations/management/analytics_link_couchbase_remote_json.hxx>
-#include <couchbase/operations/management/analytics_link_s3_external_json.hxx>
+#include <couchbase/management/analytics_link_azure_blob_external_json.hxx>
+#include <couchbase/management/analytics_link_couchbase_remote_json.hxx>
+#include <couchbase/management/analytics_link_s3_external_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
 #include <couchbase/utils/json.hxx>
 #include <couchbase/utils/url_codec.hxx>
@@ -97,11 +97,11 @@ analytics_link_get_all_request::make_response(error_context::http&& ctx, const e
             for (const auto& link : payload.get_array()) {
                 const std::string& type_ = link.at("type").get_string();
                 if (type_ == "couchbase") {
-                    response.couchbase.emplace_back(link.as<analytics_link::couchbase_remote>());
+                    response.couchbase.emplace_back(link.as<couchbase::management::analytics::couchbase_remote_link>());
                 } else if (type_ == "s3") {
-                    response.s3.emplace_back(link.as<analytics_link::s3_external>());
+                    response.s3.emplace_back(link.as<couchbase::management::analytics::s3_external_link>());
                 } else if (type_ == "azureblob") {
-                    response.azure_blob.emplace_back(link.as<analytics_link::azure_blob_external>());
+                    response.azure_blob.emplace_back(link.as<couchbase::management::analytics::azure_blob_external_link>());
                 }
             }
         }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_link_get_all.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/analytics_link.hxx>
+#include <couchbase/management/analytics_link.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -36,9 +36,9 @@ struct analytics_link_get_all_response {
     std::string status{};
     std::vector<problem> errors{};
 
-    std::vector<analytics_link::couchbase_remote> couchbase{};
-    std::vector<analytics_link::s3_external> s3{};
-    std::vector<analytics_link::azure_blob_external> azure_blob{};
+    std::vector<couchbase::management::analytics::couchbase_remote_link> couchbase{};
+    std::vector<couchbase::management::analytics::s3_external_link> s3{};
+    std::vector<couchbase::management::analytics::azure_blob_external_link> azure_blob{};
 };
 
 struct analytics_link_get_all_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_link_replace.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/analytics_link.hxx>
+#include <couchbase/operations/management/analytics_link_utils.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -65,7 +65,7 @@ struct analytics_link_replace_request {
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
         encoded.headers["accept"] = "application/json";
         encoded.method = "PUT";
-        encoded.path = analytics_link::endpoint_from_link(link);
+        encoded.path = endpoint_from_analytics_link(link);
         encoded.body = link.encode();
         return {};
     }

package/deps/{couchbase-cxx-client/couchbase/operations/management/analytics_link.hxx → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_link_utils.hxx}

@@ -17,24 +17,21 @@
 
 #pragma once
 
-#include <couchbase/operations/management/analytics_link_azure_blob_external.hxx>
-#include <couchbase/operations/management/analytics_link_couchbase_remote.hxx>
-#include <couchbase/operations/management/analytics_link_s3_external.hxx>
 #include <couchbase/utils/url_codec.hxx>
 
 #include <algorithm>
 #include <fmt/core.h>
 #include <string>
 
-namespace couchbase::operations::management::analytics_link
+namespace couchbase::operations::management
 {
 template<typename analytics_link_type>
 std::string
-endpoint_from_link(const analytics_link_type& link)
+endpoint_from_analytics_link(const analytics_link_type& link)
 {
     if (std::count(link.dataverse.begin(), link.dataverse.end(), '/') > 0) {
         return fmt::format("/analytics/link/{}/{}", utils::string_codec::v2::path_escape(link.dataverse), link.link_name);
     }
     return "/analytics/link";
 }
-} // namespace couchbase::operations::management::analytics_link
+} // namespace couchbase::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_problem.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace couchbase::operations::management
+{
+
+struct analytics_problem {
+    std::uint32_t code;
+    std::string message;
+};
+
+} // namespace couchbase::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_create.cxx

@@ -36,69 +36,69 @@ bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /*
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
     encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));
     switch (bucket.bucket_type) {
-        case bucket_settings::bucket_type::couchbase:
+        case couchbase::management::cluster::bucket_type::couchbase:
             encoded.body.append("&bucketType=couchbase");
             break;
-        case bucket_settings::bucket_type::memcached:
+        case couchbase::management::cluster::bucket_type::memcached:
             encoded.body.append("&bucketType=memcached");
             break;
-        case bucket_settings::bucket_type::ephemeral:
+        case couchbase::management::cluster::bucket_type::ephemeral:
             encoded.body.append("&bucketType=ephemeral");
             break;
-        case bucket_settings::bucket_type::unknown:
+        case couchbase::management::cluster::bucket_type::unknown:
             break;
     }
     encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
-    if (bucket.bucket_type != bucket_settings::bucket_type::memcached) {
+    if (bucket.bucket_type != couchbase::management::cluster::bucket_type::memcached) {
         encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
     }
     if (bucket.max_expiry > 0) {
         encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
     }
-    if (bucket.bucket_type != bucket_settings::bucket_type::ephemeral) {
+    if (bucket.bucket_type != couchbase::management::cluster::bucket_type::ephemeral) {
         encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
     }
     encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
     switch (bucket.eviction_policy) {
-        case bucket_settings::eviction_policy::full:
+        case couchbase::management::cluster::bucket_eviction_policy::full:
             encoded.body.append("&evictionPolicy=fullEviction");
             break;
-        case bucket_settings::eviction_policy::value_only:
+        case couchbase::management::cluster::bucket_eviction_policy::value_only:
             encoded.body.append("&evictionPolicy=valueOnly");
             break;
-        case bucket_settings::eviction_policy::no_eviction:
+        case couchbase::management::cluster::bucket_eviction_policy::no_eviction:
             encoded.body.append("&evictionPolicy=noEviction");
             break;
-        case bucket_settings::eviction_policy::not_recently_used:
+        case couchbase::management::cluster::bucket_eviction_policy::not_recently_used:
             encoded.body.append("&evictionPolicy=nruEviction");
             break;
-        case bucket_settings::eviction_policy::unknown:
+        case couchbase::management::cluster::bucket_eviction_policy::unknown:
             break;
     }
     switch (bucket.compression_mode) {
-        case bucket_settings::compression_mode::off:
+        case couchbase::management::cluster::bucket_compression::off:
             encoded.body.append("&compressionMode=off");
             break;
-        case bucket_settings::compression_mode::active:
+        case couchbase::management::cluster::bucket_compression::active:
             encoded.body.append("&compressionMode=active");
             break;
-        case bucket_settings::compression_mode::passive:
+        case couchbase::management::cluster::bucket_compression::passive:
             encoded.body.append("&compressionMode=passive");
             break;
-        case bucket_settings::compression_mode::unknown:
+        case couchbase::management::cluster::bucket_compression::unknown:
             break;
     }
     switch (bucket.conflict_resolution_type) {
-        case bucket_settings::conflict_resolution_type::timestamp:
+        case couchbase::management::cluster::bucket_conflict_resolution::timestamp:
             encoded.body.append("&conflictResolutionType=lww");
             break;
-        case bucket_settings::conflict_resolution_type::sequence_number:
+        case couchbase::management::cluster::bucket_conflict_resolution::sequence_number:
             encoded.body.append("&conflictResolutionType=seqno");
             break;
-        case bucket_settings::conflict_resolution_type::custom:
+        case couchbase::management::cluster::bucket_conflict_resolution::custom:
             encoded.body.append("&conflictResolutionType=custom");
             break;
-        case bucket_settings::conflict_resolution_type::unknown:
+        case couchbase::management::cluster::bucket_conflict_resolution::unknown:
             break;
     }
     if (bucket.minimum_durability_level) {
@@ -118,12 +118,12 @@ bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /*
         }
     }
     switch (bucket.storage_backend) {
-        case bucket_settings::storage_backend_type::unknown:
+        case couchbase::management::cluster::bucket_storage_backend::unknown:
             break;
-        case bucket_settings::storage_backend_type::couchstore:
+        case couchbase::management::cluster::bucket_storage_backend::couchstore:
             encoded.body.append("&storageBackend=couchstore");
             break;
-        case bucket_settings::storage_backend_type::magma:
+        case couchbase::management::cluster::bucket_storage_backend::magma:
             encoded.body.append("&storageBackend=magma");
             break;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_create.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/bucket_settings.hxx>
+#include <couchbase/management/bucket_settings.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -39,7 +39,7 @@ struct bucket_create_request {
 
     static const inline service_type type = service_type::management;
 
-    bucket_settings bucket{};
+    couchbase::management::cluster::bucket_settings bucket{};
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_describe.cxx

@@ -56,9 +56,9 @@ bucket_describe_request::make_response(error_context::http&& ctx, const encoded_
     }
     if (const auto* storage_backend = payload.find("storageBackend"); storage_backend != nullptr && storage_backend->is_string()) {
         if (const auto& str = storage_backend->get_string(); str == "couchstore") {
-            response.info.storage_backend = bucket_settings::storage_backend_type::couchstore;
+            response.info.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
         } else if (str == "magma") {
-            response.info.storage_backend = bucket_settings::storage_backend_type::magma;
+            response.info.storage_backend = couchbase::management::cluster::bucket_storage_backend::magma;
         }
     }
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_describe.hxx

@@ -20,21 +20,23 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/bucket_settings.hxx>
+#include <couchbase/management/bucket_settings.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations::management
 {
-struct bucket_info {
-    std::string name{};
-    std::string uuid{};
-    std::size_t number_of_nodes{ 0 };
-    std::size_t number_of_replicas{ 0 };
-    bucket_settings::storage_backend_type storage_backend{ bucket_settings::storage_backend_type::unknown };
-};
-
 struct bucket_describe_response {
+    struct bucket_info {
+        std::string name{};
+        std::string uuid{};
+        std::size_t number_of_nodes{ 0 };
+        std::size_t number_of_replicas{ 0 };
+        couchbase::management::cluster::bucket_storage_backend storage_backend{
+            couchbase::management::cluster::bucket_storage_backend::unknown
+        };
+    };
+
     error_context::http ctx;
     bucket_info info{};
 };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_get.cxx

@@ -18,7 +18,7 @@
 #include <couchbase/operations/management/bucket_get.hxx>
 
 #include <couchbase/errors.hxx>
-#include <couchbase/operations/management/bucket_settings_json.hxx>
+#include <couchbase/management/bucket_settings_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
 #include <couchbase/utils/json.hxx>
 
@@ -43,7 +43,7 @@ bucket_get_request::make_response(error_context::http&& ctx, const encoded_respo
                 break;
             case 200:
                 try {
-                    response.bucket = utils::json::parse(encoded.body.data()).as<bucket_settings>();
+                    response.bucket = utils::json::parse(encoded.body.data()).as<couchbase::management::cluster::bucket_settings>();
                 } catch (const tao::pegtl::parse_error&) {
                     response.ctx.ec = error::common_errc::parsing_failure;
                     return response;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_get.hxx

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/platform/uuid.h>
+#include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
+#include <couchbase/management/bucket_settings.hxx>
+#include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
-#include <couchbase/error_context/http.hxx>
-#include <couchbase/operations/management/bucket_settings.hxx>
 
 namespace couchbase::operations::management
 {
 struct bucket_get_response {
     error_context::http ctx;
-    bucket_settings bucket{};
+    couchbase::management::cluster::bucket_settings bucket{};
 };
 
 struct bucket_get_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_get_all.cxx

@@ -18,7 +18,7 @@
 #include <couchbase/operations/management/bucket_get_all.hxx>
 
 #include <couchbase/errors.hxx>
-#include <couchbase/operations/management/bucket_settings_json.hxx>
+#include <couchbase/management/bucket_settings_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
 #include <couchbase/utils/json.hxx>
 
@@ -51,7 +51,7 @@ bucket_get_all_request::make_response(error_context::http&& ctx, const encoded_r
         const auto& entries = payload.get_array();
         response.buckets.reserve(entries.size());
         for (const auto& entry : entries) {
-            response.buckets.emplace_back(entry.as<bucket_settings>());
+            response.buckets.emplace_back(entry.as<couchbase::management::cluster::bucket_settings>());
         }
     }
     return response;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_get_all.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/bucket_settings.hxx>
+#include <couchbase/management/bucket_settings.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -28,7 +28,7 @@ namespace couchbase::operations::management
 {
 struct bucket_get_all_response {
     error_context::http ctx;
-    std::vector<bucket_settings> buckets{};
+    std::vector<couchbase::management::cluster::bucket_settings> buckets{};
 };
 
 struct bucket_get_all_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_update.cxx

@@ -18,6 +18,7 @@
 #include <couchbase/operations/management/bucket_update.hxx>
 
 #include <couchbase/errors.hxx>
+#include <couchbase/management/bucket_settings.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
 #include <couchbase/protocol/durability_level.hxx>
 #include <couchbase/utils/join_strings.hxx>
@@ -34,36 +35,38 @@ bucket_update_request::encode_to(encoded_request_type& encoded, http_context& /*
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
     encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
     encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
-    encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+    if (bucket.max_expiry > 0) {
+        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+    }
     encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
     encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
     switch (bucket.eviction_policy) {
-        case bucket_settings::eviction_policy::full:
+        case couchbase::management::cluster::bucket_eviction_policy::full:
             encoded.body.append("&evictionPolicy=fullEviction");
             break;
-        case bucket_settings::eviction_policy::value_only:
+        case couchbase::management::cluster::bucket_eviction_policy::value_only:
             encoded.body.append("&evictionPolicy=valueOnly");
             break;
-        case bucket_settings::eviction_policy::no_eviction:
+        case couchbase::management::cluster::bucket_eviction_policy::no_eviction:
             encoded.body.append("&evictionPolicy=noEviction");
             break;
-        case bucket_settings::eviction_policy::not_recently_used:
+        case couchbase::management::cluster::bucket_eviction_policy::not_recently_used:
             encoded.body.append("&evictionPolicy=nruEviction");
             break;
-        case bucket_settings::eviction_policy::unknown:
+        case couchbase::management::cluster::bucket_eviction_policy::unknown:
             break;
     }
     switch (bucket.compression_mode) {
-        case bucket_settings::compression_mode::off:
+        case couchbase::management::cluster::bucket_compression::off:
             encoded.body.append("&compressionMode=off");
             break;
-        case bucket_settings::compression_mode::active:
+        case couchbase::management::cluster::bucket_compression::active:
             encoded.body.append("&compressionMode=active");
             break;
-        case bucket_settings::compression_mode::passive:
+        case couchbase::management::cluster::bucket_compression::passive:
             encoded.body.append("&compressionMode=passive");
             break;
-        case bucket_settings::compression_mode::unknown:
+        case couchbase::management::cluster::bucket_compression::unknown:
             break;
     }
     if (bucket.minimum_durability_level) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/bucket_update.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/bucket_settings.hxx>
+#include <couchbase/management/bucket_settings.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -28,7 +28,7 @@ namespace couchbase::operations::management
 {
 struct bucket_update_response {
     error_context::http ctx;
-    bucket_settings bucket{};
+    couchbase::management::cluster::bucket_settings bucket{};
     std::string error_message{};
 };
 
@@ -40,7 +40,7 @@ struct bucket_update_request {
 
     static const inline service_type type = service_type::management;
 
-    bucket_settings bucket{};
+    couchbase::management::cluster::bucket_settings bucket{};
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/cluster_describe.cxx

@@ -46,7 +46,7 @@ cluster_describe_request::make_response(error_context::http&& ctx, const encoded
 
     if (auto* nodes = payload.find("nodes"); nodes != nullptr && nodes->is_array()) {
         for (auto& node : nodes->get_array()) {
-            cluster_info::node entry{};
+            cluster_describe_response::cluster_info::node entry{};
             entry.hostname = node.at("hostname").get_string();
             entry.otp_node = node.at("otpNode").get_string();
             if (auto* uuid = node.find("nodeUUID"); uuid != nullptr && uuid->is_string()) {
@@ -78,7 +78,7 @@ cluster_describe_request::make_response(error_context::http&& ctx, const encoded
     }
     if (auto* buckets = payload.find("bucketNames"); buckets != nullptr && buckets->is_array()) {
         for (auto& node : buckets->get_array()) {
-            cluster_info::bucket entry{};
+            cluster_describe_response::cluster_info::bucket entry{};
             entry.name = node.at("bucketName").get_string();
             entry.uuid = node.at("uuid").get_string();
             response.info.buckets.emplace_back(entry);