couchbase 4.2.11 → 4.3.0

package/deps/couchbase-cxx-client/core/transactions/transactions.cxx

@@ -26,6 +26,8 @@
 #include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 
+#include <system_error>
+
 namespace couchbase::core::transactions
 {
 transactions::transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config)
@@ -38,35 +40,60 @@ transactions::transactions(core::cluster cluster, const couchbase::transactions:
   , config_(config)
   , cleanup_(new transactions_cleanup(cluster_, config_))
 {
-    CB_TXN_LOG_DEBUG(
-      "couchbase transactions {} ({}) creating new transaction object", couchbase::core::meta::sdk_id(), couchbase::core::meta::os());
-    // if the config specifies custom metadata collection, lets be sure to open that bucket
-    // on the cluster before we start.  NOTE: we actually do call get_and_open_buckets which opens all the buckets
-    // on the cluster (that we have permissions to open) in the cleanup.   However, that is happening asynchronously
-    // so there's a chance we will fail to have opened the custom metadata collection bucket before trying to make a
-    // transaction.   We have to open this one _now_.
-    if (config_.metadata_collection) {
-        auto barrier = std::make_shared<std::promise<std::error_code>>();
-        auto f = barrier->get_future();
-        std::atomic<bool> callback_called{ false };
-        cluster_.open_bucket(config_.metadata_collection->bucket, [&callback_called, barrier](std::error_code ec) {
-            if (callback_called.load()) {
-                return;
+}
+
+transactions::~transactions() = default;
+
+void
+transactions::create(core::cluster cluster,
+                     const couchbase::transactions::transactions_config::built& config,
+                     utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb)
+{
+    if (config.metadata_collection) {
+        // if the config specifies custom metadata collection, lets be sure to open that bucket
+        // on the cluster before we start.  NOTE: we actually do call get_and_open_buckets which opens all the buckets
+        // on the cluster (that we have permissions to open) in the cleanup.   However, that is happening asynchronously
+        // so there's a chance we will fail to have opened the custom metadata collection bucket before trying to make a
+        // transaction. We have to open this one _now_.
+
+        auto bucket_name = config.metadata_collection->bucket;
+        return cluster.open_bucket(bucket_name, [cluster, config, bucket_name, cb = std::move(cb)](std::error_code ec) mutable {
+            if (ec) {
+                CB_TXN_LOG_ERROR("error opening metadata_collection bucket '{}' specified in the config!", bucket_name);
+                return cb(ec, {});
             }
-            callback_called = true;
-            barrier->set_value(ec);
+
+            CB_TXN_LOG_DEBUG("couchbase transactions {} ({}) creating new transaction object",
+                             couchbase::core::meta::sdk_id(),
+                             couchbase::core::meta::os());
+            return cb({}, std::make_shared<transactions>(std::move(cluster), config));
         });
-        auto err = f.get();
-        if (err) {
-            auto err_msg =
-              fmt::format("error opening metadata_collection bucket '{}' specified in the config!", config_.metadata_collection->bucket);
-            CB_TXN_LOG_DEBUG("{}", err_msg);
-            throw std::runtime_error(err_msg);
-        }
     }
+
+    return cb({}, std::make_shared<transactions>(std::move(cluster), config));
 }
 
-transactions::~transactions() = default;
+void
+transactions::create(core::cluster cluster,
+                     const couchbase::transactions::transactions_config& config,
+                     utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb)
+{
+    return create(std::move(cluster), config.build(), std::move(cb));
+}
+
+std::future<std::pair<std::error_code, std::shared_ptr<transactions>>>
+transactions::create(core::cluster cluster, const couchbase::transactions::transactions_config::built& config)
+{
+    auto barrier = std::make_shared<std::promise<std::pair<std::error_code, std::shared_ptr<transactions>>>>();
+    create(std::move(cluster), config, [barrier](auto ec, auto txns) mutable { barrier->set_value({ ec, txns }); });
+    return barrier->get_future();
+}
+
+std::future<std::pair<std::error_code, std::shared_ptr<transactions>>>
+transactions::create(core::cluster cluster, const couchbase::transactions::transactions_config& config)
+{
+    return create(std::move(cluster), config.build());
+}
 
 template<typename Handler>
 ::couchbase::transactions::transaction_result
@@ -175,6 +202,16 @@ transactions::run(async_logic&& code, txn_complete_callback&& cb)
     return run(config, std::move(code), std::move(cb));
 }
 
+void
+transactions::notify_fork(fork_event event)
+{
+    if (event == fork_event::prepare) {
+        cleanup_->stop();
+    } else {
+        cleanup_->start();
+    }
+}
+
 void
 transactions::close()
 {

package/deps/couchbase-cxx-client/core/transactions/transactions_cleanup.cxx

@@ -45,18 +45,8 @@ transactions_cleanup::transactions_cleanup(core::cluster cluster, const couchbas
   : cluster_(std::move(cluster))
   , config_(config)
   , client_uuid_(uid_generator::next())
-  , running_(config.cleanup_config.cleanup_client_attempts || config.cleanup_config.cleanup_lost_attempts)
 {
-    if (config.cleanup_config.cleanup_client_attempts) {
-        cleanup_thr_ = std::thread(std::bind(&transactions_cleanup::attempts_loop, this));
-    }
-    if (config_.metadata_collection) {
-        add_collection(
-          { config_.metadata_collection->bucket, config_.metadata_collection->scope, config_.metadata_collection->collection });
-    }
-    for (auto& k : config_.cleanup_config.collections) {
-        add_collection(k);
-    }
+    start();
 }
 
 static std::uint64_t
@@ -249,7 +239,9 @@ transactions_cleanup::create_client_record(const couchbase::transactions::transa
         wrap_durable_request(req, config_);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        auto ec = config_.cleanup_hooks->client_record_before_create(keyspace.bucket);
+        auto ec = wait_for_hook([this, bucket = keyspace.bucket](auto handler) mutable {
+            return config_.cleanup_hooks->client_record_before_create(bucket, std::move(handler));
+        });
         if (ec) {
             throw client_error(*ec, "client_record_before_create hook raised error");
         }
@@ -285,7 +277,9 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
             .specs();
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        auto ec = config_.cleanup_hooks->client_record_before_get(keyspace.bucket);
+        auto ec = wait_for_hook([this, bucket = keyspace.bucket](auto handler) mutable {
+            return config_.cleanup_hooks->client_record_before_get(bucket, std::move(handler));
+        });
         if (ec) {
             throw client_error(*ec, "client_record_before_get hook raised error");
         }
@@ -363,7 +357,9 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
             mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
         }
         mutate_req.specs = mut_specs.specs();
-        ec = config_.cleanup_hooks->client_record_before_update(keyspace.bucket);
+        ec = wait_for_hook([this, bucket = keyspace.bucket](auto handler) mutable {
+            return config_.cleanup_hooks->client_record_before_update(bucket, std::move(handler));
+        });
         if (ec) {
             throw client_error(*ec, "client_record_before_update hook raised error");
         }
@@ -401,7 +397,9 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
               std::chrono::milliseconds(10), std::chrono::milliseconds(250), std::chrono::milliseconds(500), [this, keyspace, uuid]() {
                   try {
                       // proceed to remove the client uuid if it exists
-                      auto ec = config_.cleanup_hooks->client_record_before_remove_client(keyspace.bucket);
+                      auto ec = wait_for_hook([this, bucket = keyspace.bucket](auto handler) mutable {
+                          return config_.cleanup_hooks->client_record_before_remove_client(bucket, std::move(handler));
+                      });
                       if (ec) {
                           throw client_error(*ec, "client_record_before_remove_client hook raised error");
                       }
@@ -546,7 +544,23 @@ transactions_cleanup::add_collection(couchbase::transactions::transaction_keyspa
 }
 
 void
-transactions_cleanup::close()
+transactions_cleanup::start()
+{
+    running_ = config_.cleanup_config.cleanup_client_attempts || config_.cleanup_config.cleanup_lost_attempts;
+    if (config_.cleanup_config.cleanup_client_attempts) {
+        cleanup_thr_ = std::thread(std::bind(&transactions_cleanup::attempts_loop, this));
+    }
+    if (config_.metadata_collection) {
+        add_collection(
+          { config_.metadata_collection->bucket, config_.metadata_collection->scope, config_.metadata_collection->collection });
+    }
+    for (const auto& k : config_.cleanup_config.collections) {
+        add_collection(k);
+    }
+}
+
+void
+transactions_cleanup::stop()
 {
     {
         std::unique_lock<std::mutex> lock(mutex_);
@@ -563,6 +577,12 @@ transactions_cleanup::close()
             t.join();
         }
     }
+}
+
+void
+transactions_cleanup::close()
+{
+    stop();
     CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("all lost attempt cleanup threads closed");
     remove_client_record_from_all_buckets(client_uuid_);
 }

package/deps/couchbase-cxx-client/core/transactions/utils.cxx

@@ -92,6 +92,15 @@ wrap_operation_future(std::future<result>& fut, bool ignore_subdoc_errors)
     return res;
 }
 
+std::optional<error_class>
+wait_for_hook(std::function<void(utils::movable_function<void(std::optional<error_class>)>)> hook)
+{
+    auto hook_barrier = std::make_shared<std::promise<std::optional<error_class>>>();
+    auto hook_future = hook_barrier->get_future();
+    hook([hook_barrier](std::optional<error_class> ec) mutable { return hook_barrier->set_value(ec); });
+    return hook_future.get();
+}
+
 template<>
 bool
 is_error(const core::operations::mutate_in_response& resp)

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

@@ -18,20 +18,24 @@
 
 #include <couchbase/transactions.hxx>
 
-#include "couchbase/transactions/transaction_options.hxx"
-#include "couchbase/transactions/transaction_result.hxx"
-#include "couchbase/transactions/transactions_config.hxx"
+#include <couchbase/fork_event.hxx>
+#include <couchbase/transactions/transaction_options.hxx>
+#include <couchbase/transactions/transaction_result.hxx>
+#include <couchbase/transactions/transactions_config.hxx>
+
 #include "transactions/async_attempt_context.hxx"
 #include "transactions/attempt_context.hxx"
 #include "transactions/exceptions.hxx"
 
 #include "core/cluster.hxx"
 #include "core/logger/logger.hxx"
+#include "core/utils/movable_function.hxx"
 
 #include <spdlog/common.h>
 
 #include <cmath>
 #include <functional>
+#include <system_error>
 #include <thread>
 
 // workaround for MSVC define overlap with log levels
@@ -127,6 +131,11 @@ using txn_complete_callback =
 class transactions : public couchbase::transactions::transactions
 {
   public:
+    /**
+     * @brief Destructor
+     */
+    ~transactions();
+
     /**
      * @brief Create a transactions object.
      *
@@ -134,14 +143,30 @@ class transactions : public couchbase::transactions::transactions
      *
      * @param cluster The cluster to use for the transactions.
      * @param config The configuration parameters to use for the transactions.
+     * @param cb Called when the transactions object has been created or an error has occurred during the creation.
      */
-    transactions(core::cluster cluster, const couchbase::transactions::transactions_config::built& config);
-    transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
+    static void create(core::cluster cluster,
+                       const couchbase::transactions::transactions_config::built&,
+                       utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb);
+    static void create(core::cluster cluster,
+                       const couchbase::transactions::transactions_config&,
+                       utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb);
 
     /**
-     * @brief Destructor
+     * @brief Create a transactions object.
+     *
+     * Creates a transactions object, which can be used to run transactions within the current thread.
+     *
+     * @param cluster The cluster to use for the transactions.
+     * @param config The configuration parameters to use for the transactions.
+     * @return a future containing the error that occurred or the transactions object.
      */
-    ~transactions();
+    static std::future<std::pair<std::error_code, std::shared_ptr<transactions>>> create(
+      core::cluster cluster,
+      const couchbase::transactions::transactions_config::built& config);
+    static std::future<std::pair<std::error_code, std::shared_ptr<transactions>>> create(
+      core::cluster cluster,
+      const couchbase::transactions::transactions_config& config);
 
     /**
      * @brief Run a transaction
@@ -199,6 +224,8 @@ class transactions : public couchbase::transactions::transactions
         ctx.rollback();
     }
 
+    void notify_fork(fork_event event);
+
     /**
      * @brief Shut down the transactions object
      *
@@ -245,6 +272,12 @@ class transactions : public couchbase::transactions::transactions
         return cluster_;
     }
 
+    /**
+     * @internal
+     */
+    transactions(core::cluster cluster, const couchbase::transactions::transactions_config::built& config);
+    transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
+
   private:
     core::cluster cluster_;
     couchbase::transactions::transactions_config::built config_;

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

@@ -23,6 +23,7 @@
 #include <couchbase/bucket_manager.hxx>
 #include <couchbase/cluster_options.hxx>
 #include <couchbase/diagnostics_options.hxx>
+#include <couchbase/fork_event.hxx>
 #include <couchbase/ping_options.hxx>
 #include <couchbase/query_index_manager.hxx>
 #include <couchbase/query_options.hxx>
@@ -40,6 +41,11 @@ namespace couchbase
 namespace core
 {
 class cluster;
+
+namespace transactions
+{
+class transactions;
+}
 } // namespace core
 class cluster_impl;
 #endif
@@ -90,6 +96,8 @@ class cluster
     auto operator=(const cluster& other) -> cluster& = default;
     auto operator=(cluster&& other) -> cluster& = default;
 
+    void notify_fork(fork_event event);
+
     void close() const;
 
     /**
@@ -102,6 +110,17 @@ class cluster
      */
     explicit cluster(core::cluster core);
 
+    /**
+     * Wraps low-level implementation of the SDK & transactions
+     *
+     * @param core pointer to the low-level SDK handle
+     * @param transactions pointer to the lowe-level transactions handle
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    explicit cluster(core::cluster core, std::shared_ptr<core::transactions::transactions> transactions);
+
     /**
      * Opens a {@link bucket} with the given name.
      *

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

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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
+
+namespace couchbase
+{
+enum class fork_event {
+    /**
+     * Notify the cluster that the process is about to fork.
+     */
+    prepare,
+
+    /**
+     * Notify the context that the process has forked and is the parent.
+     */
+    parent,
+
+    /**
+     * Notify the context that the process has forked and is the child.
+     */
+    child,
+};
+
+} // namespace couchbase

package/dist/binding.d.ts

@@ -885,6 +885,8 @@ export interface CppSearchRequest {
     };
     client_context_id?: string;
     timeout?: CppMilliseconds;
+    log_request?: boolean;
+    log_response?: boolean;
     body_str: string;
 }
 export interface CppTouchResponse {
@@ -2670,6 +2672,11 @@ export interface CppConnection extends CppConnectionAutogen {
         result: CppScanIterator;
     };
 }
+export interface CppTransactionKeyspace {
+    bucket_name: string;
+    scope_name?: string;
+    collection_name?: string;
+}
 export interface CppTransactionsConfig {
     durability_level?: CppDurabilityLevel;
     timeout?: CppMilliseconds;
@@ -2677,6 +2684,7 @@ export interface CppTransactionsConfig {
     cleanup_window?: CppMilliseconds;
     cleanup_lost_attempts?: boolean;
     cleanup_client_attempts?: boolean;
+    metadata_collection?: CppTransactionKeyspace;
 }
 export interface CppTransactionOptions {
     durability_level?: CppDurabilityLevel;

package/dist/bindingutilities.d.ts

@@ -1,5 +1,5 @@
 import { AnalyticsScanConsistency, AnalyticsStatus } from './analyticstypes';
-import { CppAnalyticsResponseAnalyticsStatus, CppAnalyticsScanConsistency, CppDesignDocumentNamespace, CppDiagEndpointState, CppDiagPingState, CppDurabilityLevel, CppError, CppManagementClusterBucketCompression, CppManagementClusterBucketConflictResolution, CppManagementClusterBucketEvictionPolicy, CppManagementClusterBucketStorageBackend, CppManagementClusterBucketType, CppMutationState, CppPersistTo, CppPrefixScan, CppQueryProfile, CppQueryScanConsistency, CppRangeScan, CppReplicateTo, CppSamplingScan, CppSearchHighlightStyle, CppSearchScanConsistency, CppServiceType, CppStoreSemantics, CppTxnExternalException, CppTxnOpException, CppVectorQueryCombination, CppViewScanConsistency, CppViewSortOrder } from './binding';
+import { CppAnalyticsResponseAnalyticsStatus, CppAnalyticsScanConsistency, CppDesignDocumentNamespace, CppDiagEndpointState, CppDiagPingState, CppDurabilityLevel, CppError, CppManagementClusterBucketCompression, CppManagementClusterBucketConflictResolution, CppManagementClusterBucketEvictionPolicy, CppManagementClusterBucketStorageBackend, CppManagementClusterBucketType, CppMutationState, CppPersistTo, CppPrefixScan, CppQueryProfile, CppQueryScanConsistency, CppRangeScan, CppReplicateTo, CppSamplingScan, CppSearchHighlightStyle, CppSearchScanConsistency, CppServiceType, CppStoreSemantics, CppTransactionKeyspace, CppTxnExternalException, CppTxnOpException, CppVectorQueryCombination, CppViewScanConsistency, CppViewSortOrder } from './binding';
 import { BucketType, CompressionMode, ConflictResolutionType, EvictionPolicy, StorageBackend } from './bucketmanager';
 import { EndpointState, PingState } from './diagnosticstypes';
 import { ErrorContext } from './errorcontexts';
@@ -8,6 +8,7 @@ import { MutationState } from './mutationstate';
 import { QueryProfileMode, QueryScanConsistency } from './querytypes';
 import { PrefixScan, RangeScan, SamplingScan } from './rangeScan';
 import { HighlightStyle, SearchScanConsistency } from './searchtypes';
+import { TransactionKeyspace } from './transactions';
 import { VectorQueryCombination } from './vectorsearch';
 import { DesignDocumentNamespace, ViewOrdering, ViewScanConsistency } from './viewtypes';
 /**
@@ -154,3 +155,7 @@ export declare function designDocumentNamespaceFromCpp(namespace: CppDesignDocum
  * @internal
  */
 export declare function designDocumentNamespaceToCpp(namespace: DesignDocumentNamespace): CppDesignDocumentNamespace;
+/**
+ * @internal
+ */
+export declare function transactionKeyspaceToCpp(keyspace?: TransactionKeyspace): CppTransactionKeyspace | undefined;

package/dist/bindingutilities.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.designDocumentNamespaceToCpp = exports.designDocumentNamespaceFromCpp = exports.vectorQueryCombinationToCpp = exports.bucketConflictResolutionTypeFromCpp = exports.bucketConflictResolutionTypeToCpp = exports.bucketStorageBackendFromCpp = exports.bucketStorageBackendToCpp = exports.bucketEvictionPolicyFromCpp = exports.bucketEvictionPolicyToCpp = exports.bucketCompressionModeFromCpp = exports.bucketCompressionModeToCpp = exports.bucketTypeFromCpp = exports.bucketTypeToCpp = exports.scanTypeToCpp = exports.errorFromCpp = exports.contextFromCpp = exports.pingStateFromCpp = exports.txnOpExeptionFromCpp = exports.txnExternalExceptionStringFromCpp = exports.endpointStateFromCpp = exports.serviceTypeFromCpp = exports.serviceTypeToCpp = exports.mutationStateToCpp = exports.searchHighlightStyleToCpp = exports.searchScanConsistencyToCpp = exports.analyticsStatusFromCpp = exports.analyticsScanConsistencyToCpp = exports.queryProfileToCpp = exports.queryScanConsistencyToCpp = exports.viewOrderingToCpp = exports.viewScanConsistencyToCpp = exports.storeSemanticToCpp = exports.replicateToToCpp = exports.persistToToCpp = exports.durabilityFromCpp = exports.durabilityToCpp = void 0;
+exports.transactionKeyspaceToCpp = exports.designDocumentNamespaceToCpp = exports.designDocumentNamespaceFromCpp = exports.vectorQueryCombinationToCpp = exports.bucketConflictResolutionTypeFromCpp = exports.bucketConflictResolutionTypeToCpp = exports.bucketStorageBackendFromCpp = exports.bucketStorageBackendToCpp = exports.bucketEvictionPolicyFromCpp = exports.bucketEvictionPolicyToCpp = exports.bucketCompressionModeFromCpp = exports.bucketCompressionModeToCpp = exports.bucketTypeFromCpp = exports.bucketTypeToCpp = exports.scanTypeToCpp = exports.errorFromCpp = exports.contextFromCpp = exports.pingStateFromCpp = exports.txnOpExeptionFromCpp = exports.txnExternalExceptionStringFromCpp = exports.endpointStateFromCpp = exports.serviceTypeFromCpp = exports.serviceTypeToCpp = exports.mutationStateToCpp = exports.searchHighlightStyleToCpp = exports.searchScanConsistencyToCpp = exports.analyticsStatusFromCpp = exports.analyticsScanConsistencyToCpp = exports.queryProfileToCpp = exports.queryScanConsistencyToCpp = exports.viewOrderingToCpp = exports.viewScanConsistencyToCpp = exports.storeSemanticToCpp = exports.replicateToToCpp = exports.persistToToCpp = exports.durabilityFromCpp = exports.durabilityToCpp = void 0;
 const analyticstypes_1 = require("./analyticstypes");
 const binding_1 = __importDefault(require("./binding"));
 const bucketmanager_1 = require("./bucketmanager");
@@ -1051,3 +1051,17 @@ function designDocumentNamespaceToCpp(namespace) {
     throw new errs.InvalidArgumentError(new Error('Unrecognized DesignDocumentNamespace.'));
 }
 exports.designDocumentNamespaceToCpp = designDocumentNamespaceToCpp;
+/**
+ * @internal
+ */
+function transactionKeyspaceToCpp(keyspace) {
+    var _a, _b;
+    if (!keyspace)
+        return undefined;
+    return {
+        bucket_name: keyspace.bucket,
+        scope_name: (_a = keyspace.scope) !== null && _a !== void 0 ? _a : '_default',
+        collection_name: (_b = keyspace.collection) !== null && _b !== void 0 ? _b : '_default',
+    };
+}
+exports.transactionKeyspaceToCpp = transactionKeyspaceToCpp;

package/dist/bucketmanager.d.ts

@@ -163,8 +163,6 @@ export interface IBucketSettings {
      */
     minimumDurabilityLevel?: DurabilityLevel | string;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies the default history retention on all collections in this bucket.
      * Only available on Magma Buckets.
      *
@@ -172,14 +170,10 @@ export interface IBucketSettings {
      */
     historyRetentionCollectionDefault?: boolean;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies the maximum history retention in bytes on all collections in this bucket.
      */
     historyRetentionBytes?: number;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies the maximum duration in seconds to be covered by the change history that is written
      * to disk for all collections in this bucket.
      */
@@ -261,8 +255,6 @@ export declare class BucketSettings implements IBucketSettings {
      */
     minimumDurabilityLevel?: DurabilityLevel;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies the default history retention on all collections in this bucket.
      * Only available on Magma Buckets.
      *
@@ -270,14 +262,10 @@ export declare class BucketSettings implements IBucketSettings {
      */
     historyRetentionCollectionDefault?: boolean;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies the maximum history retention in bytes on all collections in this bucket.
      */
     historyRetentionBytes?: number;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies the maximum duration in seconds to be covered by the change history that is written
      * to disk for all collections in this bucket.
      */

package/dist/cluster.d.ts

@@ -303,8 +303,6 @@ export declare class Cluster {
     /**
      * Executes a search query against the cluster.
      *
-     * Volatile: This API is subject to change at any time.
-     *
      * @param indexName The name of the index to query.
      * @param request The SearchRequest describing the search to execute.
      * @param options Optional parameters for this operation.

package/dist/cluster.js

@@ -320,8 +320,6 @@ class Cluster {
     /**
      * Executes a search query against the cluster.
      *
-     * Volatile: This API is subject to change at any time.
-     *
      * @param indexName The name of the index to query.
      * @param request The SearchRequest describing the search to execute.
      * @param options Optional parameters for this operation.

package/dist/collection.d.ts

@@ -345,8 +345,6 @@ export interface MutateInOptions {
     upsertDocument?: boolean;
 }
 /**
- * Volatile: This API is subject to change at any time.
- *
  * @category Key-Value
  */
 export interface ScanOptions {
@@ -574,7 +572,9 @@ export declare class Collection {
     /**
      * Performs a key-value scan operation.
      *
-     * Volatile: This API is subject to change at any time.
+     * Use this API for low concurrency batch queries where latency is not a critical as the system
+     * may have to scan a lot of documents to find the matching documents.
+     * For low latency range queries, it is recommended that you use SQL++ with the necessary indexes.
      *
      * @param scanType The type of scan to execute.
      * @param options Optional parameters for the scan operation.

package/dist/collection.js

@@ -876,7 +876,9 @@ class Collection {
     /**
      * Performs a key-value scan operation.
      *
-     * Volatile: This API is subject to change at any time.
+     * Use this API for low concurrency batch queries where latency is not a critical as the system
+     * may have to scan a lot of documents to find the matching documents.
+     * For low latency range queries, it is recommended that you use SQL++ with the necessary indexes.
      *
      * @param scanType The type of scan to execute.
      * @param options Optional parameters for the scan operation.

package/dist/querytypes.d.ts

@@ -281,8 +281,6 @@ export interface QueryOptions {
      */
     readOnly?: boolean;
     /**
-     * Uncommitted: This API is subject to change in the future.
-     *
      * Specifies whether the query engine should use replica nodes for kv fetches,
      * if the active node is down.
      */

package/dist/rangeScan.d.ts

@@ -1,8 +1,6 @@
 /**
  * Represents a search term for a RangeScan.
  *
- * Volatile: This API is subject to change at any time.
- *
  * @see {@link RangeScan}
  * @category Key-Value
  */
@@ -36,8 +34,6 @@ export interface ScanType {
  * A RangeScan performs a scan on a range of keys with the range specified through
  * a start and end ScanTerm.
  *
- * Volatile: This API is subject to change at any time.
- *
  * @category Key-Value
  */
 export declare class RangeScan implements ScanType {
@@ -62,8 +58,6 @@ export declare class RangeScan implements ScanType {
  * A SamplingScan performs a scan on a random sampling of keys with the sampling bounded by
  * a limit.
  *
- * Volatile: This API is subject to change at any time.
- *
  * @category Key-Value
  */
 export declare class SamplingScan implements ScanType {
@@ -87,8 +81,6 @@ export declare class SamplingScan implements ScanType {
 /**
  * A PrefixScan scan type selects every document whose ID starts with a certain prefix.
  *
- * Volatile: This API is subject to change at any time.
- *
  * @category key-value
  */
 export declare class PrefixScan implements ScanType {