couchbase 4.0.0 → 4.1.0

package/deps/couchbase-cxx-client/couchbase/management/bucket_settings.hxx

@@ -0,0 +1,134 @@
+/* -*- 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 <couchbase/protocol/durability_level.hxx>
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::management::cluster
+{
+enum class bucket_type { unknown, couchbase, memcached, ephemeral };
+enum class bucket_compression { unknown, off, active, passive };
+enum class bucket_eviction_policy {
+    unknown,
+
+    /**
+     * During ejection, everything (including key, metadata, and value) will be ejected.
+     *
+     * Full Ejection reduces the memory overhead requirement, at the cost of performance.
+     *
+     * This value is only valid for buckets of type COUCHBASE.
+     */
+    full,
+
+    /**
+     * During ejection, only the value will be ejected (key and metadata will remain in memory).
+     *
+     * Value Ejection needs more system memory, but provides better performance than Full Ejection.
+     *
+     * This value is only valid for buckets of type COUCHBASE.
+     */
+    value_only,
+
+    /**
+     * Couchbase Server keeps all data until explicitly deleted, but will reject
+     * any new data if you reach the quota (dedicated memory) you set for your bucket.
+     *
+     * This value is only valid for buckets of type EPHEMERAL.
+     */
+    no_eviction,
+
+    /**
+     * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
+     *
+     * This value is only valid for buckets of type EPHEMERAL.
+     */
+    not_recently_used,
+};
+enum class bucket_conflict_resolution {
+    unknown,
+    /**
+     * Use timestamp conflict resolution.
+     *
+     * Timestamp-based conflict resolution (often referred to as Last Write Wins, or LWW) uses the document
+     * timestamp (stored in the CAS) to resolve conflicts. The timestamps associated with the most recent
+     * updates of source and target documents are compared. The document whose update has the more recent
+     * timestamp prevails.
+     */
+    timestamp,
+
+    /**
+     * Use sequence number conflict resolution
+     *
+     * Conflicts can be resolved by referring to documents' sequence numbers. Sequence numbers are maintained
+     * per document, and are incremented on every document-update. The sequence numbers of source and
+     * target documents are compared; and the document with the higher sequence number prevails.
+     */
+    sequence_number,
+
+    /**
+     * VOLATILE: This API is subject to change at any time.
+     *
+     * In Couchbase Server 7.1, this feature is only available in "developer-preview" mode. See the UI XDCR settings.
+     */
+    custom,
+};
+enum class bucket_storage_backend { unknown, couchstore, magma };
+
+struct bucket_settings {
+    struct node {
+        std::string hostname;
+        std::string status;
+        std::string version;
+        std::vector<std::string> services;
+        std::map<std::string, std::uint16_t> ports;
+    };
+
+    std::string name;
+    std::string uuid;
+    cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
+    std::uint64_t ram_quota_mb{ 100 };
+    std::uint32_t max_expiry{ 0 };
+    bucket_compression compression_mode{ bucket_compression::unknown };
+    std::optional<protocol::durability_level> minimum_durability_level{};
+    std::uint32_t num_replicas{ 1 };
+    bool replica_indexes{ false };
+    bool flush_enabled{ false };
+    bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
+    bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
+
+    /**
+     * UNCOMMITTED: This API may change in the future
+     */
+    bucket_storage_backend storage_backend{ bucket_storage_backend::unknown };
+
+    /**
+     * UNCOMMITTED: read-only attribute
+     */
+    std::vector<std::string> capabilities{};
+
+    /**
+     * UNCOMMITTED: read-only attribute
+     */
+    std::vector<node> nodes{};
+};
+} // namespace couchbase::management::cluster

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

@@ -17,56 +17,61 @@
 
 #pragma once
 
-#include <couchbase/operations/management/bucket_settings.hxx>
+#include <couchbase/management/bucket_settings.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::bucket_settings> {
+struct traits<couchbase::management::cluster::bucket_settings> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::bucket_settings as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::cluster::bucket_settings as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::bucket_settings result;
+        couchbase::management::cluster::bucket_settings result;
         result.name = v.at("name").get_string();
         result.uuid = v.at("uuid").get_string();
         const static std::uint64_t megabyte = 1024LLU * 1024LLU;
         result.ram_quota_mb = v.at("quota").at("rawRAM").get_unsigned() / megabyte;
-        result.max_expiry = v.at("maxTTL").template as<std::uint32_t>();
         result.num_replicas = v.at("replicaNumber").template as<std::uint32_t>();
 
+        if (auto* max_ttl = v.find("maxTTL"); max_ttl != nullptr) {
+            result.max_expiry = max_ttl->template as<std::uint32_t>();
+        }
+
         if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
-            result.bucket_type = couchbase::operations::management::bucket_settings::bucket_type::couchbase;
+            result.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
         } else if (str == "ephemeral") {
-            result.bucket_type = couchbase::operations::management::bucket_settings::bucket_type::ephemeral;
+            result.bucket_type = couchbase::management::cluster::bucket_type::ephemeral;
         } else if (str == "memcached") {
-            result.bucket_type = couchbase::operations::management::bucket_settings::bucket_type::memcached;
+            result.bucket_type = couchbase::management::cluster::bucket_type::memcached;
         }
 
-        if (auto& str = v.at("compressionMode").get_string(); str == "active") {
-            result.compression_mode = couchbase::operations::management::bucket_settings::compression_mode::active;
-        } else if (str == "passive") {
-            result.compression_mode = couchbase::operations::management::bucket_settings::compression_mode::passive;
-        } else if (str == "off") {
-            result.compression_mode = couchbase::operations::management::bucket_settings::compression_mode::off;
+        if (auto* compression_mode = v.find("compressionMode"); compression_mode != nullptr && compression_mode->is_string()) {
+            if (auto& str = compression_mode->get_string(); str == "active") {
+                result.compression_mode = couchbase::management::cluster::bucket_compression::active;
+            } else if (str == "passive") {
+                result.compression_mode = couchbase::management::cluster::bucket_compression::passive;
+            } else if (str == "off") {
+                result.compression_mode = couchbase::management::cluster::bucket_compression::off;
+            }
         }
 
         if (auto& str = v.at("evictionPolicy").get_string(); str == "valueOnly") {
-            result.eviction_policy = couchbase::operations::management::bucket_settings::eviction_policy::value_only;
+            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::value_only;
         } else if (str == "fullEviction") {
-            result.eviction_policy = couchbase::operations::management::bucket_settings::eviction_policy::full;
+            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::full;
         } else if (str == "noEviction") {
-            result.eviction_policy = couchbase::operations::management::bucket_settings::eviction_policy::no_eviction;
+            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::no_eviction;
         } else if (str == "nruEviction") {
-            result.eviction_policy = couchbase::operations::management::bucket_settings::eviction_policy::not_recently_used;
+            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::not_recently_used;
         }
 
         if (auto* storage_backend = v.find("storageBackend"); storage_backend != nullptr && storage_backend->is_string()) {
             if (const auto& str = storage_backend->get_string(); str == "couchstore") {
-                result.storage_backend = couchbase::operations::management::bucket_settings::storage_backend_type::couchstore;
+                result.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
             } else if (str == "magma") {
-                result.storage_backend = couchbase::operations::management::bucket_settings::storage_backend_type::magma;
+                result.storage_backend = couchbase::management::cluster::bucket_storage_backend::magma;
             }
         }
 
@@ -83,11 +88,11 @@ struct traits<couchbase::operations::management::bucket_settings> {
         }
 
         if (auto& str = v.at("conflictResolutionType").get_string(); str == "lww") {
-            result.conflict_resolution_type = couchbase::operations::management::bucket_settings::conflict_resolution_type::timestamp;
+            result.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::timestamp;
         } else if (str == "seqno") {
-            result.conflict_resolution_type = couchbase::operations::management::bucket_settings::conflict_resolution_type::sequence_number;
+            result.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::sequence_number;
         } else if (str == "custom") {
-            result.conflict_resolution_type = couchbase::operations::management::bucket_settings::conflict_resolution_type::custom;
+            result.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::custom;
         }
 
         result.flush_enabled = v.at("controllers").find("flush") != nullptr;
@@ -100,7 +105,7 @@ struct traits<couchbase::operations::management::bucket_settings> {
             }
         }
         for (auto& n : v.at("nodes").get_array()) {
-            couchbase::operations::management::bucket_settings::node node;
+            couchbase::management::cluster::bucket_settings::node node;
             node.status = n.at("status").get_string();
             node.hostname = n.at("hostname").get_string();
             node.version = n.at("version").get_string();

package/deps/couchbase-cxx-client/couchbase/{operations/management → management}/design_document.hxx

@@ -21,14 +21,11 @@
 #include <optional>
 #include <string>
 
-namespace couchbase::operations
+#include <couchbase/design_document_namespace.hxx>
+
+namespace couchbase::management::views
 {
 struct design_document {
-    enum class name_space {
-        development,
-        production,
-    };
-
     struct view {
         std::string name;
         std::optional<std::string> map{};
@@ -37,8 +34,8 @@ struct design_document {
 
     std::string rev;
     std::string name;
-    design_document::name_space ns;
+    design_document_namespace ns;
     std::map<std::string, view> views;
 };
 
-} // namespace couchbase::operations
+} // namespace couchbase::management::views

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

@@ -17,7 +17,8 @@
 
 #pragma once
 
-#include <couchbase/operations/management/eventing_status.hxx>
+#include <couchbase/management/eventing_status.hxx>
+#include <couchbase/query_scan_consistency.hxx>
 
 #include <chrono>
 #include <optional>
@@ -25,7 +26,7 @@
 #include <variant>
 #include <vector>
 
-namespace couchbase::operations::management::eventing
+namespace couchbase::management::eventing
 {
 
 struct function_keyspace {
@@ -53,11 +54,6 @@ enum class function_log_level {
     trace,
 };
 
-enum class query_scan_consistency {
-    not_bounded,
-    request_plus,
-};
-
 struct function_settings {
     /** number of threads each worker utilizes */
     std::optional<std::int64_t> cpp_worker_count{};
@@ -82,7 +78,7 @@ struct function_settings {
     /** maximum time the lcb command is waited until completion before we terminate the request */
     std::optional<std::chrono::seconds> lcb_timeout{};
     /** consistency level used by n1ql statements in the handler */
-    std::optional<query_scan_consistency> query_consistency{};
+    std::optional<couchbase::query_scan_consistency> query_consistency{};
     /** number of timer shards. defaults to number of vbuckets */
     std::optional<std::int64_t> num_timer_partitions{};
     /** batch size for messages from producer to consumer */
@@ -131,7 +127,7 @@ struct function_bucket_binding {
     /** name of the bucket with optional scope and collection */
     function_keyspace name;
     /** bucket access level (read or read+write) */
-    function_bucket_access access{ couchbase::operations::management::eventing::function_bucket_access::read_write };
+    function_bucket_access access{ function_bucket_access::read_write };
 };
 
 struct function_url_no_auth {
@@ -189,4 +185,4 @@ struct function {
     std::vector<function_constant_binding> constant_bindings{};
     function_settings settings{};
 };
-} // namespace couchbase::operations::management::eventing
+} // namespace couchbase::management::eventing

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

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::eventing::function> {
+struct traits<couchbase::management::eventing::function> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::eventing::function as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::eventing::function as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::eventing::function result;
+        couchbase::management::eventing::function result;
         result.version = v.at("version").get_string();
         result.name = v.at("appname").get_string();
         result.code = v.at("appcode").get_string();
@@ -46,7 +46,7 @@ struct traits<couchbase::operations::management::eventing::function> {
 
             if (const auto* constants = depcfg->find("constants"); constants != nullptr && constants->is_array()) {
                 for (const auto& constant : constants->get_array()) {
-                    couchbase::operations::management::eventing::function_constant_binding binding;
+                    couchbase::management::eventing::function_constant_binding binding;
                     binding.alias = constant.at("value").get_string();
                     binding.literal = constant.at("literal").get_string();
                     result.constant_bindings.emplace_back(binding);
@@ -55,15 +55,15 @@ struct traits<couchbase::operations::management::eventing::function> {
 
             if (const auto* buckets = depcfg->find("buckets"); buckets != nullptr && buckets->is_array()) {
                 for (const auto& bucket : buckets->get_array()) {
-                    couchbase::operations::management::eventing::function_bucket_binding binding;
+                    couchbase::management::eventing::function_bucket_binding binding;
                     binding.alias = bucket.at("alias").get_string();
                     binding.name.bucket = bucket.at("bucket_name").get_string();
                     binding.name.scope = bucket.template optional<std::string>("scope_name");
                     binding.name.collection = bucket.template optional<std::string>("collection_name");
                     if (const auto& access = bucket.at("access").get_string(); access == "rw") {
-                        binding.access = couchbase::operations::management::eventing::function_bucket_access::read_write;
+                        binding.access = couchbase::management::eventing::function_bucket_access::read_write;
                     } else if (access == "r") {
-                        binding.access = couchbase::operations::management::eventing::function_bucket_access::read_only;
+                        binding.access = couchbase::management::eventing::function_bucket_access::read_only;
                     }
                     result.bucket_bindings.emplace_back(binding);
                 }
@@ -71,22 +71,19 @@ struct traits<couchbase::operations::management::eventing::function> {
 
             if (const auto* urls = depcfg->find("curl"); urls != nullptr && urls->is_array()) {
                 for (const auto& url : urls->get_array()) {
-                    couchbase::operations::management::eventing::function_url_binding binding;
+                    couchbase::management::eventing::function_url_binding binding;
                     binding.alias = url.at("value").get_string();
                     binding.hostname = url.at("hostname").get_string();
                     binding.allow_cookies = url.at("allow_cookies").get_boolean();
                     binding.validate_ssl_certificate = url.at("validate_ssl_certificate").get_boolean();
                     if (const auto& auth_type = url.at("auth_type").get_string(); auth_type == "no-auth") {
-                        binding.auth = couchbase::operations::management::eventing::function_url_no_auth{};
+                        binding.auth = couchbase::management::eventing::function_url_no_auth{};
                     } else if (auth_type == "basic") {
-                        binding.auth =
-                          couchbase::operations::management::eventing::function_url_auth_basic{ url.at("username").get_string() };
+                        binding.auth = couchbase::management::eventing::function_url_auth_basic{ url.at("username").get_string() };
                     } else if (auth_type == "digest") {
-                        binding.auth =
-                          couchbase::operations::management::eventing::function_url_auth_digest{ url.at("username").get_string() };
+                        binding.auth = couchbase::management::eventing::function_url_auth_digest{ url.at("username").get_string() };
                     } else if (auth_type == "bearer") {
-                        binding.auth =
-                          couchbase::operations::management::eventing::function_url_auth_bearer{ url.at("bearer_key").get_string() };
+                        binding.auth = couchbase::management::eventing::function_url_auth_bearer{ url.at("bearer_key").get_string() };
                     }
                     result.url_bindings.emplace_back(binding);
                 }
@@ -133,36 +130,36 @@ struct traits<couchbase::operations::management::eventing::function> {
 
             if (const auto* status = settings->find("deployment_status"); status != nullptr && status->is_boolean()) {
                 result.settings.deployment_status = status->get_boolean()
-                                                      ? couchbase::operations::management::eventing::function_deployment_status::deployed
-                                                      : couchbase::operations::management::eventing::function_deployment_status::undeployed;
+                                                      ? couchbase::management::eventing::function_deployment_status::deployed
+                                                      : couchbase::management::eventing::function_deployment_status::undeployed;
             }
 
             if (const auto* status = settings->find("processing_status"); status != nullptr && status->is_boolean()) {
                 result.settings.processing_status = status->get_boolean()
-                                                      ? couchbase::operations::management::eventing::function_processing_status::running
-                                                      : couchbase::operations::management::eventing::function_processing_status::paused;
+                                                      ? couchbase::management::eventing::function_processing_status::running
+                                                      : couchbase::management::eventing::function_processing_status::paused;
             }
 
             if (const auto* boundary = settings->find("dcp_stream_boundary"); boundary != nullptr && boundary->is_string()) {
                 const auto& boundary_string = boundary->get_string();
                 if (boundary_string == "everything") {
-                    result.settings.dcp_stream_boundary = couchbase::operations::management::eventing::function_dcp_boundary::everything;
+                    result.settings.dcp_stream_boundary = couchbase::management::eventing::function_dcp_boundary::everything;
                 } else if (boundary_string == "from_now") {
-                    result.settings.dcp_stream_boundary = couchbase::operations::management::eventing::function_dcp_boundary::from_now;
+                    result.settings.dcp_stream_boundary = couchbase::management::eventing::function_dcp_boundary::from_now;
                 }
             }
 
             if (const auto* log_level = settings->find("log_level"); log_level != nullptr && log_level->is_string()) {
                 if (const auto& log_level_string = log_level->get_string(); log_level_string == "DEBUG") {
-                    result.settings.log_level = couchbase::operations::management::eventing::function_log_level::debug;
+                    result.settings.log_level = couchbase::management::eventing::function_log_level::debug;
                 } else if (log_level_string == "TRACE") {
-                    result.settings.log_level = couchbase::operations::management::eventing::function_log_level::trace;
+                    result.settings.log_level = couchbase::management::eventing::function_log_level::trace;
                 } else if (log_level_string == "INFO") {
-                    result.settings.log_level = couchbase::operations::management::eventing::function_log_level::info;
+                    result.settings.log_level = couchbase::management::eventing::function_log_level::info;
                 } else if (log_level_string == "WARNING") {
-                    result.settings.log_level = couchbase::operations::management::eventing::function_log_level::warning;
+                    result.settings.log_level = couchbase::management::eventing::function_log_level::warning;
                 } else if (log_level_string == "ERROR") {
-                    result.settings.log_level = couchbase::operations::management::eventing::function_log_level::error;
+                    result.settings.log_level = couchbase::management::eventing::function_log_level::error;
                 }
             }
 
@@ -171,22 +168,22 @@ struct traits<couchbase::operations::management::eventing::function> {
                 if (const auto& language_compatibility_string = language_compatibility->get_string();
                     language_compatibility_string == "6.0.0") {
                     result.settings.language_compatibility =
-                      couchbase::operations::management::eventing::function_language_compatibility::version_6_0_0;
+                      couchbase::management::eventing::function_language_compatibility::version_6_0_0;
                 } else if (language_compatibility_string == "6.5.0") {
                     result.settings.language_compatibility =
-                      couchbase::operations::management::eventing::function_language_compatibility::version_6_5_0;
+                      couchbase::management::eventing::function_language_compatibility::version_6_5_0;
                 } else if (language_compatibility_string == "6.6.2") {
                     result.settings.language_compatibility =
-                      couchbase::operations::management::eventing::function_language_compatibility::version_6_6_2;
+                      couchbase::management::eventing::function_language_compatibility::version_6_6_2;
                 }
             }
 
             if (const auto* query_consistency = settings->find("n1ql_consistency");
                 query_consistency != nullptr && query_consistency->is_string()) {
                 if (const auto& query_consistency_string = query_consistency->get_string(); query_consistency_string == "request") {
-                    result.settings.query_consistency = couchbase::operations::management::eventing::query_scan_consistency::request_plus;
+                    result.settings.query_consistency = couchbase::query_scan_consistency::request_plus;
                 } else if (query_consistency_string == "none") {
-                    result.settings.query_consistency = couchbase::operations::management::eventing::query_scan_consistency::not_bounded;
+                    result.settings.query_consistency = couchbase::query_scan_consistency::not_bounded;
                 }
             }
 

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

@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-namespace couchbase::operations::management::eventing
+namespace couchbase::management::eventing
 {
 
 enum class function_status {
@@ -81,4 +81,4 @@ struct status {
     std::vector<function_state> functions{};
 };
 
-} // namespace couchbase::operations::management::eventing
+} // namespace couchbase::management::eventing

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

@@ -17,36 +17,36 @@
 
 #pragma once
 
-#include <couchbase/operations/management/eventing_status.hxx>
+#include <couchbase/management/eventing_status.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::eventing::status> {
+struct traits<couchbase::management::eventing::status> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::eventing::status as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::eventing::status as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::eventing::status result;
+        couchbase::management::eventing::status result;
         result.num_eventing_nodes = v.at("num_eventing_nodes").get_unsigned();
         if (const auto* apps = v.find("apps"); apps != nullptr && apps->is_array()) {
             for (const auto& app : apps->get_array()) {
-                couchbase::operations::management::eventing::function_state function{};
+                couchbase::management::eventing::function_state function{};
                 function.name = app.at("name").get_string();
                 function.num_deployed_nodes = app.at("num_deployed_nodes").get_unsigned();
                 function.num_bootstrapping_nodes = app.at("num_bootstrapping_nodes").get_unsigned();
 
                 if (app.at("deployment_status").get_boolean()) {
-                    function.deployment_status = couchbase::operations::management::eventing::function_deployment_status::deployed;
+                    function.deployment_status = couchbase::management::eventing::function_deployment_status::deployed;
                 } else {
-                    function.deployment_status = couchbase::operations::management::eventing::function_deployment_status::undeployed;
+                    function.deployment_status = couchbase::management::eventing::function_deployment_status::undeployed;
                 }
 
                 if (app.at("processing_status").get_boolean()) {
-                    function.processing_status = couchbase::operations::management::eventing::function_processing_status::running;
+                    function.processing_status = couchbase::management::eventing::function_processing_status::running;
                 } else {
-                    function.processing_status = couchbase::operations::management::eventing::function_processing_status::paused;
+                    function.processing_status = couchbase::management::eventing::function_processing_status::paused;
                 }
 
                 if (const auto* redeploy = app.find("redeploy_required"); redeploy != nullptr && redeploy->is_boolean()) {
@@ -54,17 +54,17 @@ struct traits<couchbase::operations::management::eventing::status> {
                 }
 
                 if (auto composite_status = app.at("composite_status").get_string(); composite_status == "undeployed") {
-                    function.status = couchbase::operations::management::eventing::function_status::undeployed;
+                    function.status = couchbase::management::eventing::function_status::undeployed;
                 } else if (composite_status == "undeploying") {
-                    function.status = couchbase::operations::management::eventing::function_status::undeploying;
+                    function.status = couchbase::management::eventing::function_status::undeploying;
                 } else if (composite_status == "deploying") {
-                    function.status = couchbase::operations::management::eventing::function_status::deploying;
+                    function.status = couchbase::management::eventing::function_status::deploying;
                 } else if (composite_status == "deployed") {
-                    function.status = couchbase::operations::management::eventing::function_status::deployed;
+                    function.status = couchbase::management::eventing::function_status::deployed;
                 } else if (composite_status == "paused") {
-                    function.status = couchbase::operations::management::eventing::function_status::paused;
+                    function.status = couchbase::management::eventing::function_status::paused;
                 } else if (composite_status == "pausing") {
-                    function.status = couchbase::operations::management::eventing::function_status::pausing;
+                    function.status = couchbase::management::eventing::function_status::pausing;
                 }
 
                 result.functions.emplace_back(function);

package/deps/couchbase-cxx-client/couchbase/management/query_index.hxx

@@ -0,0 +1,39 @@
+/* -*- 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 <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::management::query
+{
+struct index {
+    bool is_primary{ false };
+    std::string name;
+    std::string state;
+    std::string type;
+    std::vector<std::string> index_key{};
+    std::optional<std::string> partition{};
+    std::optional<std::string> condition{};
+    std::string bucket_name;
+    std::optional<std::string> scope_name{};
+    std::optional<std::string> collection_name{};
+};
+
+} // namespace couchbase::management::query

package/deps/couchbase-cxx-client/couchbase/{operations/management → management}/rbac.hxx

@@ -20,8 +20,9 @@
 #include <optional>
 #include <set>
 #include <string>
+#include <vector>
 
-namespace couchbase::operations::management::rbac
+namespace couchbase::management::rbac
 {
 struct role {
     std::string name;
@@ -73,4 +74,4 @@ struct group {
     std::optional<std::string> ldap_group_reference{};
 };
 
-} // namespace couchbase::operations::management::rbac
+} // namespace couchbase::management::rbac