couchbase 4.2.10 → 4.2.11

package/deps/couchbase-cxx-client/core/range_scan_orchestrator.hxx

@@ -22,8 +22,8 @@
 
 #include <tl/expected.hpp>
 
-#include <memory>
-#include <optional>
+#include <cstdint>
+#include <system_error>
 
 namespace asio
 {
@@ -39,10 +39,10 @@ class scan_stream_manager
 {
   public:
     virtual ~scan_stream_manager() = default;
-    virtual void stream_start_failed(std::int16_t node_id, bool fatal) = 0;
     virtual void stream_start_failed_awaiting_retry(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
-    virtual void stream_continue_failed(std::int16_t node_id, bool fatal) = 0;
-    virtual void stream_completed(std::int16_t node_id) = 0;
+    virtual void stream_received_item(range_scan_item item) = 0;
+    virtual void stream_failed(std::int16_t node_id, std::uint16_t vbucket_id, std::error_code ec, bool fatal) = 0;
+    virtual void stream_completed(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
 };
 
 class range_scan_orchestrator
@@ -61,5 +61,4 @@ class range_scan_orchestrator
   private:
     std::shared_ptr<range_scan_orchestrator_impl> impl_;
 };
-
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/range_scan_orchestrator_options.hxx

@@ -15,17 +15,16 @@
 
 #pragma once
 
-#include "scan_options.hxx"
+#include "range_scan_options.hxx"
 #include "timeout_defaults.hxx"
 
 #include <couchbase/mutation_token.hxx>
 #include <couchbase/retry_strategy.hxx>
 
-#include <cinttypes>
+#include <chrono>
+#include <cstdint>
 #include <memory>
 #include <optional>
-#include <system_error>
-#include <variant>
 #include <vector>
 
 namespace couchbase
@@ -39,6 +38,9 @@ class request_span;
 
 namespace couchbase::core
 {
+struct mutation_state {
+    std::vector<couchbase::mutation_token> tokens;
+};
 
 struct range_scan_orchestrator_options {
     static constexpr std::uint16_t default_concurrency{ 1 };

package/deps/couchbase-cxx-client/core/scan_result.hxx

@@ -15,26 +15,16 @@
 
 #pragma once
 
-#include "scan_options.hxx"
-
+#include "range_scan_options.hxx"
 #include "utils/movable_function.hxx"
 
-#include <couchbase/mutation_token.hxx>
-#include <couchbase/retry_strategy.hxx>
-
 #include <tl/expected.hpp>
 
-#include <cinttypes>
 #include <future>
-#include <memory>
-#include <optional>
 #include <system_error>
-#include <variant>
-#include <vector>
 
 namespace couchbase::core
 {
-
 class scan_result_impl;
 
 class range_scan_item_iterator

package/deps/couchbase-cxx-client/core/topology/capabilities.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <set>
+
 namespace couchbase::core
 {
 enum class bucket_capability {
@@ -32,8 +34,15 @@ enum class bucket_capability {
     durable_write,
     tombstoned_user_xattrs,
     range_scan,
-    replica_read,
     non_deduped_history,
+    subdoc_replace_body_with_xattr,
+    subdoc_document_macro_support,
+    subdoc_revive_document,
+    dcp_ignore_purged_tombstones,
+    preserve_expiry,
+    query_system_collection,
+    mobile_system_collection,
+    subdoc_replica_read,
 };
 
 enum class cluster_capability {
@@ -43,5 +52,65 @@ enum class cluster_capability {
     n1ql_inline_functions,
     n1ql_enhanced_prepared_statements,
     n1ql_read_from_replica,
+    search_vector_search,
+    search_scoped_search_index,
+};
+
+struct configuration_capabilities {
+    std::set<bucket_capability> bucket{};
+    std::set<cluster_capability> cluster{};
+
+    [[nodiscard]] bool has_cluster_capability(cluster_capability cap) const
+    {
+        return cluster.find(cap) != cluster.end();
+    }
+
+    [[nodiscard]] bool has_bucket_capability(bucket_capability cap) const
+    {
+        return bucket.find(cap) != bucket.end();
+    }
+
+    [[nodiscard]] bool supports_enhanced_prepared_statements() const
+    {
+        return has_cluster_capability(cluster_capability::n1ql_enhanced_prepared_statements);
+    }
+
+    [[nodiscard]] bool supports_read_from_replica() const
+    {
+        return has_cluster_capability(cluster_capability::n1ql_read_from_replica);
+    }
+
+    [[nodiscard]] bool supports_range_scan() const
+    {
+        return has_bucket_capability(bucket_capability::range_scan);
+    }
+
+    [[nodiscard]] bool ephemeral() const
+    {
+        // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then
+        // we are running an old version of couchbase which doesn't have ephemeral buckets at all.
+        return has_bucket_capability(bucket_capability::couchapi);
+    }
+
+    [[nodiscard]] bool supports_subdoc_read_replica() const
+    {
+        return has_bucket_capability(bucket_capability::subdoc_replica_read);
+    }
+
+    [[nodiscard]] bool supports_non_deduped_history() const
+    {
+        return has_bucket_capability(bucket_capability::non_deduped_history);
+    }
+
+    [[nodiscard]] bool supports_scoped_search_indexes() const
+    {
+        return has_cluster_capability(cluster_capability::search_scoped_search_index);
+    }
+
+    [[nodiscard]] bool supports_vector_search() const
+    {
+        return has_cluster_capability(cluster_capability::search_vector_search);
+    }
 };
+
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/topology/capabilities_fmt.hxx

@@ -70,12 +70,33 @@ struct fmt::formatter<couchbase::core::bucket_capability> {
             case couchbase::core::bucket_capability::range_scan:
                 name = "range_scan";
                 break;
-            case couchbase::core::bucket_capability::replica_read:
-                name = "replica_read";
+            case couchbase::core::bucket_capability::subdoc_replica_read:
+                name = "subdoc_replica_read";
                 break;
             case couchbase::core::bucket_capability::non_deduped_history:
                 name = "non_deduped_history";
                 break;
+            case couchbase::core::bucket_capability::subdoc_replace_body_with_xattr:
+                name = "subdoc_replace_body_with_xattr";
+                break;
+            case couchbase::core::bucket_capability::subdoc_document_macro_support:
+                name = "subdoc_document_macro_support";
+                break;
+            case couchbase::core::bucket_capability::subdoc_revive_document:
+                name = "subdoc_revive_document";
+                break;
+            case couchbase::core::bucket_capability::dcp_ignore_purged_tombstones:
+                name = "dcp_ignore_purged_tombstones";
+                break;
+            case couchbase::core::bucket_capability::preserve_expiry:
+                name = "preserve_expiry";
+                break;
+            case couchbase::core::bucket_capability::query_system_collection:
+                name = "query_system_collection";
+                break;
+            case couchbase::core::bucket_capability::mobile_system_collection:
+                name = "mobile_system_collection";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }
@@ -111,6 +132,13 @@ struct fmt::formatter<couchbase::core::cluster_capability> {
                 break;
             case couchbase::core::cluster_capability::n1ql_read_from_replica:
                 name = "n1ql_read_from_replica";
+                break;
+            case couchbase::core::cluster_capability::search_vector_search:
+                name = "search_vector_search";
+                break;
+            case couchbase::core::cluster_capability::search_scoped_search_index:
+                name = "search_scoped_search_index";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -89,8 +89,7 @@ struct configuration {
     std::optional<std::string> bucket{};
     std::optional<vbucket_map> vbmap{};
     std::optional<std::uint64_t> collections_manifest_uid{};
-    std::set<bucket_capability> bucket_capabilities{};
-    std::set<cluster_capability> cluster_capabilities{};
+    configuration_capabilities capabilities{};
     node_locator_type node_locator{ node_locator_type::unknown };
     bool force{ false };
 
@@ -111,38 +110,6 @@ struct configuration {
 
     [[nodiscard]] std::string rev_str() const;
 
-    [[nodiscard]] bool supports_enhanced_prepared_statements() const
-    {
-        return cluster_capabilities.find(cluster_capability::n1ql_enhanced_prepared_statements) != cluster_capabilities.end();
-    }
-
-    [[nodiscard]] bool supports_read_from_replica() const
-    {
-        return cluster_capabilities.find(cluster_capability::n1ql_read_from_replica) != cluster_capabilities.end();
-    }
-
-    [[nodiscard]] bool supports_range_scan() const
-    {
-        return bucket_capabilities.find(bucket_capability::range_scan) != bucket_capabilities.end();
-    }
-
-    [[nodiscard]] bool ephemeral() const
-    {
-        // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then
-        // we are running an old version of couchbase which doesn't have ephemeral buckets at all.
-        return bucket_capabilities.count(couchbase::core::bucket_capability::couchapi) == 0;
-    }
-
-    [[nodiscard]] bool supports_subdoc_read_replica() const
-    {
-        return bucket_capabilities.find(bucket_capability::replica_read) != bucket_capabilities.end();
-    }
-
-    [[nodiscard]] bool supports_non_deduped_history() const
-    {
-        return bucket_capabilities.find(bucket_capability::non_deduped_history) != bucket_capabilities.end();
-    }
-
     [[nodiscard]] std::size_t index_for_this_node() const;
     [[nodiscard]] bool has_node(const std::string& network,
                                 service_type type,

package/deps/couchbase-cxx-client/core/topology/configuration_fmt.hxx

@@ -160,7 +160,7 @@ struct fmt::formatter<couchbase::core::topology::configuration> {
                          config.vbmap.has_value() ? fmt::format(", partitions={}", config.vbmap->size()) : "",
                          config.nodes.size(),
                          couchbase::core::utils::join_strings_fmt(config.nodes, ", "),
-                         couchbase::core::utils::join_strings_fmt(config.bucket_capabilities, ", "),
-                         couchbase::core::utils::join_strings_fmt(config.cluster_capabilities, ", "));
+                         couchbase::core::utils::join_strings_fmt(config.capabilities.bucket, ", "),
+                         couchbase::core::utils::join_strings_fmt(config.capabilities.cluster, ", "));
     }
 };

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -213,33 +213,47 @@ struct traits<couchbase::core::topology::configuration> {
             for (const auto& entry : m->get_array()) {
                 const auto& name = entry.get_string();
                 if (name == "couchapi") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::couchapi);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::couchapi);
                 } else if (name == "collections") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::collections);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::collections);
                 } else if (name == "durableWrite") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::durable_write);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::durable_write);
                 } else if (name == "tombstonedUserXAttrs") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::tombstoned_user_xattrs);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::tombstoned_user_xattrs);
                 } else if (name == "dcp") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::dcp);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::dcp);
                 } else if (name == "cbhello") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::cbhello);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::cbhello);
                 } else if (name == "touch") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::touch);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::touch);
                 } else if (name == "cccp") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::cccp);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::cccp);
                 } else if (name == "xdcrCheckpointing") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::xdcr_checkpointing);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::xdcr_checkpointing);
                 } else if (name == "nodesExt") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::nodes_ext);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::nodes_ext);
                 } else if (name == "xattr") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::xattr);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::xattr);
                 } else if (name == "rangeScan") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::range_scan);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::range_scan);
                 } else if (name == "subdoc.ReplicaRead") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::replica_read);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_replica_read);
                 } else if (name == "nonDedupedHistory") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::non_deduped_history);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::non_deduped_history);
+                } else if (name == "subdoc.ReplaceBodyWithXattr") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_replace_body_with_xattr);
+                } else if (name == "subdoc.DocumentMacroSupport") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_document_macro_support);
+                } else if (name == "subdoc.ReviveDocument") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_revive_document);
+                } else if (name == "dcp.IgnorePurgedTombstones") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::dcp_ignore_purged_tombstones);
+                } else if (name == "preserve_expiry") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::preserve_expiry);
+                } else if (name == "querySystemCollection") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::query_system_collection);
+                } else if (name == "mobileSystemCollection") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::mobile_system_collection);
                 }
             }
         }
@@ -247,17 +261,26 @@ struct traits<couchbase::core::topology::configuration> {
             if (const auto nc = m->find("n1ql"); nc != nullptr && nc->is_array()) {
                 for (const auto& entry : nc->get_array()) {
                     if (const auto& name = entry.get_string(); name == "costBasedOptimizer") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_cost_based_optimizer);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_cost_based_optimizer);
                     } else if (name == "indexAdvisor") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_index_advisor);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_index_advisor);
                     } else if (name == "javaScriptFunctions") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_javascript_functions);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_javascript_functions);
                     } else if (name == "inlineFunctions") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
                     } else if (name == "enhancedPreparedStatements") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
                     } else if (name == "readFromReplica") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
+                    }
+                }
+            }
+            if (const auto sc = m->find("search"); sc != nullptr && sc->is_array()) {
+                for (const auto& entry : sc->get_array()) {
+                    if (const auto& name = entry.get_string(); name == "vectorSearch") {
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::search_vector_search);
+                    } else if (name == "scopedSearchIndex") {
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::search_scoped_search_index);
                     }
                 }
             }

package/deps/couchbase-cxx-client/core/transactions/internal/exceptions_internal.hxx

@@ -230,6 +230,11 @@ class transaction_operation_failed : public std::runtime_error
         return cause_;
     }
 
+    final_error to_raise() const
+    {
+        return to_raise_;
+    }
+
     void do_throw(const transaction_context& context) const
     {
         if (to_raise_ == FAILED_POST_COMMIT) {

package/deps/couchbase-cxx-client/couchbase/bucket.hxx

@@ -79,7 +79,7 @@ class bucket
      * Performs application-level ping requests against services in the Couchbase cluster.
      *
      * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
-     * wish to performs I/O, consider using @ref diagnostics() instead.
+     * wish to performs I/O, consider using @ref cluster::diagnostics() instead.
      *
      * @param options custom options to change the default behavior.
      * @param handler the handler that implements @ref ping_handler.
@@ -93,7 +93,7 @@ class bucket
      * Performs application-level ping requests against services in the Couchbase cluster.
      *
      * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
-     * wish to performs I/O, consider using @ref diagnostics() instead.
+     * wish to performs I/O, consider using @ref cluster::diagnostics() instead.
      *
      * @param options custom options to change the default behavior.
      * @return future object that carries result of the operation.

package/deps/couchbase-cxx-client/couchbase/cluster.hxx

@@ -222,7 +222,7 @@ class cluster
      * @since 1.0.0
      * @volatile
      */
-    [[nodiscard]] auto search(std::string index_name, search_request request, const search_options& = {}) const
+    [[nodiscard]] auto search(std::string index_name, search_request request, const search_options& options = {}) const
       -> std::future<std::pair<search_error_context, search_result>>;
 
     /**

package/deps/couchbase-cxx-client/couchbase/collection.hxx

@@ -791,6 +791,7 @@ class collection
      * @param document_id the outer document ID
      * @param specs an object that specifies the types of lookups to perform
      * @param options custom options to modify the lookup options
+     * @param handler callable that implements @ref lookup_in_any_replica_handler
      *
      * @exception errc::key_value::document_not_found the given document id is not found in the collection.
      * @exception errc::common::ambiguous_timeout

package/deps/couchbase-cxx-client/couchbase/collection_query_index_manager.hxx

@@ -53,8 +53,7 @@ class collection_query_index_manager
 {
   public:
     /**
-     * Get all indexes within a collection.
-     *
+     * Get all indexes within the collection.
      *
      * @param options optional parameters
      * @param handler the handler that implements @ref get_all_query_indexes_handler
@@ -64,13 +63,23 @@ class collection_query_index_manager
      */
     void get_all_indexes(const get_all_query_indexes_options& options, get_all_query_indexes_handler&& handler) const;
 
+    /**
+     * Get all indexes within the collection.
+     *
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto get_all_indexes(const get_all_query_indexes_options& options) const
       -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query_index>>>;
+
     /**
      * Create an index on the collection.
      *
      * @param index_name name of the index
-     * @param fields the fields to create the index over
+     * @param keys the keys to create the index over
      * @param options optional parameters
      * @param handler the handler that implements @ref create_query_index_handler
      *
@@ -78,16 +87,26 @@ class collection_query_index_manager
      * @committed
      */
     void create_index(std::string index_name,
-                      std::vector<std::string> fields,
+                      std::vector<std::string> keys,
                       const create_query_index_options& options,
                       create_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto create_index(std::string index_name,
-                                    std::vector<std::string> fields,
-                                    const create_query_index_options& options) const -> std::future<manager_error_context>;
+    /**
+     * Create an index on the collection.
+     *
+     * @param index_name name of the index
+     * @param keys the keys to create the index over
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto create_index(std::string index_name, std::vector<std::string> keys, const create_query_index_options& options) const
+      -> std::future<manager_error_context>;
 
     /**
-     * Create a primary index on a collection.
+     * Create a primary index on the collection.
      *
      * @param options optional parameters
      * @param handler the handler that implements @ref create_query_index_handler
@@ -97,10 +116,19 @@ class collection_query_index_manager
      */
     void create_primary_index(const create_primary_query_index_options& options, create_query_index_handler&& handler) const;
 
+    /**
+     * Create a primary index on the collection.
+     *
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto create_primary_index(const create_primary_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
-     * Drop primary index on a collection.
+     * Drop primary index on the collection.
      *
      * @param options optional parameters
      * @param handler the handler that implements @ref drop_query_index_handler
@@ -110,10 +138,19 @@ class collection_query_index_manager
      */
     void drop_primary_index(const drop_primary_query_index_options& options, drop_query_index_handler&& handler) const;
 
+    /**
+     * Drop primary index on the collection.
+     *
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto drop_primary_index(const drop_primary_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
-     * Drop index in collection.
+     * Drop specified query index in the collection.
      *
      * @param index_name name of the index to drop
      * @param options optional parameters
@@ -124,14 +161,25 @@ class collection_query_index_manager
      */
     void drop_index(std::string index_name, const drop_query_index_options& options, drop_query_index_handler&& handler) const;
 
+    /**
+     * Drop specified query index in the collection.
+     *
+     * @param index_name name of the index to drop
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto drop_index(std::string index_name, const drop_query_index_options& options) const
       -> std::future<manager_error_context>;
+
     /**
      * Builds all currently deferred indexes in this collection.
      *
      * By default, this method will build the indexes on the collection.
      *
-     * @param options the custom options
+     * @param options optional parameters
      * @param handler the handler that implements @ref build_deferred_query_indexes_handler
      *
      * @since 1.0.0
@@ -139,6 +187,17 @@ class collection_query_index_manager
      */
     void build_deferred_indexes(const build_query_index_options& options, build_deferred_query_indexes_handler&& handler) const;
 
+    /**
+     * Builds all currently deferred indexes in this collection.
+     *
+     * By default, this method will build the indexes on the collection.
+     *
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto build_deferred_indexes(const build_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
@@ -155,6 +214,16 @@ class collection_query_index_manager
                        const watch_query_indexes_options& options,
                        watch_query_indexes_handler&& handler) const;
 
+    /**
+     * Polls the state of a set of indexes, until they all are online.
+     *
+     * @param index_names names of the indexes to watch
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto watch_indexes(std::vector<std::string> index_names, const watch_query_indexes_options& options) const
       -> std::future<manager_error_context>;
 

package/deps/couchbase-cxx-client/couchbase/error_context.hxx

@@ -48,6 +48,7 @@ class error_context
     /**
      * Creates and initializes error context with given parameters.
      *
+     * @param operation_id
      * @param ec
      * @param last_dispatched_to
      * @param last_dispatched_from

package/deps/couchbase-cxx-client/couchbase/fmt/key_value_status_code.hxx

@@ -257,7 +257,9 @@ struct fmt::formatter<couchbase::key_value_status_code> {
             case key_value_status_code::range_scan_vb_uuid_not_equal:
                 name = "range_scan_vb_uuid_not_equal (0xa8)";
                 break;
-
+            case key_value_status_code::config_only:
+                name = "config_only (0x0d)";
+                break;
             case key_value_status_code::unknown:
                 name = "unknown (0xffff)";
                 break;

package/deps/couchbase-cxx-client/couchbase/get_links_analytics_options.hxx

@@ -50,7 +50,7 @@ class get_links_analytics_options : public common_options<get_links_analytics_op
     /**
      * The name of the link to fetch.
      *
-     * @param link_name
+     * @param name link name
      * @return reference to this object, for use in chaining
      *
      * @since 1.0.0
@@ -65,7 +65,7 @@ class get_links_analytics_options : public common_options<get_links_analytics_op
     /**
      * The type of links to restrict returned links to.
      *
-     * @param link_type
+     * @param link_type link type
      * @return reference to this object, for use in chaining
      *
      * @since 1.0.0

package/deps/couchbase-cxx-client/couchbase/key_value_status_code.hxx

@@ -35,6 +35,7 @@ enum class key_value_status_code : std::uint16_t {
     opaque_no_match = 0x0b,
     locked = 0x09,
     not_locked = 0x0e,
+    config_only = 0x0d,
     auth_stale = 0x1f,
     auth_error = 0x20,
     auth_continue = 0x21,