couchbase 3.1.1 → 3.2.0

data/ext/third_party/hdr_histogram_c/src/hdr_writer_reader_phaser.c

@@ -0,0 +1,143 @@
+/**
+ * hdr_writer_reader_phaser.h
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+
+#include "hdr_atomic.h"
+#include "hdr_thread.h"
+
+#include "hdr_writer_reader_phaser.h"
+
+#ifndef HDR_MALLOC_INCLUDE
+#define HDR_MALLOC_INCLUDE "hdr_malloc.h"
+#endif
+
+#include HDR_MALLOC_INCLUDE
+
+static int64_t _hdr_phaser_get_epoch(int64_t* field)
+{
+    return hdr_atomic_load_64(field);
+}
+
+static void _hdr_phaser_set_epoch(int64_t* field, int64_t val)
+{
+    hdr_atomic_store_64(field, val);
+}
+
+static int64_t _hdr_phaser_reset_epoch(int64_t* field, int64_t initial_value)
+{
+    return hdr_atomic_exchange_64(field, initial_value);
+}
+
+int hdr_writer_reader_phaser_init(struct hdr_writer_reader_phaser* p)
+{
+    int rc;
+    if (NULL == p)
+    {
+        return EINVAL;
+    }
+
+    p->start_epoch = 0;
+    p->even_end_epoch = 0;
+    p->odd_end_epoch = INT64_MIN;
+    p->reader_mutex = hdr_mutex_alloc();
+
+    if (!p->reader_mutex)
+    {
+        return ENOMEM;
+    }
+
+    rc = hdr_mutex_init(p->reader_mutex);
+    if (0 != rc)
+    {
+        return rc;
+    }
+
+    /* TODO: Should I fence here. */
+
+    return 0;
+}
+
+void hdr_writer_reader_phaser_destroy(struct hdr_writer_reader_phaser* p)
+{
+    hdr_mutex_destroy(p->reader_mutex);
+    hdr_mutex_free(p->reader_mutex);
+}
+
+int64_t hdr_phaser_writer_enter(struct hdr_writer_reader_phaser* p)
+{
+    return hdr_atomic_add_fetch_64(&p->start_epoch, 1);
+}
+
+void hdr_phaser_writer_exit(
+    struct hdr_writer_reader_phaser* p, int64_t critical_value_at_enter)
+{
+    int64_t* end_epoch = 
+        (critical_value_at_enter < 0) ? &p->odd_end_epoch : &p->even_end_epoch;
+    hdr_atomic_add_fetch_64(end_epoch, 1);
+}
+
+void hdr_phaser_reader_lock(struct hdr_writer_reader_phaser* p)
+{
+    hdr_mutex_lock(p->reader_mutex);
+}
+
+void hdr_phaser_reader_unlock(struct hdr_writer_reader_phaser* p)
+{
+    hdr_mutex_unlock(p->reader_mutex);
+}
+
+void hdr_phaser_flip_phase(
+    struct hdr_writer_reader_phaser* p, int64_t sleep_time_ns)
+{
+    bool caught_up;
+    int64_t start_value_at_flip;
+    /* TODO: is_held_by_current_thread */
+    unsigned int sleep_time_us = sleep_time_ns < 1000000000 ? (unsigned int) (sleep_time_ns / 1000) : 1000000;
+
+    int64_t start_epoch = _hdr_phaser_get_epoch(&p->start_epoch);
+
+    bool next_phase_is_even = (start_epoch < 0);
+
+    /* Clear currently used phase end epoch.*/
+    int64_t initial_start_value;
+    if (next_phase_is_even)
+    {
+        initial_start_value = 0;
+        _hdr_phaser_set_epoch(&p->even_end_epoch, initial_start_value);
+    }
+    else
+    {
+        initial_start_value = INT64_MIN;
+        _hdr_phaser_set_epoch(&p->odd_end_epoch, initial_start_value);
+    }
+
+    /* Reset start value, indicating new phase.*/
+    start_value_at_flip = _hdr_phaser_reset_epoch(&p->start_epoch, initial_start_value);
+
+    do
+    {
+        int64_t* end_epoch =
+            next_phase_is_even ? &p->odd_end_epoch : &p->even_end_epoch;
+
+        caught_up = _hdr_phaser_get_epoch(end_epoch) == start_value_at_flip;
+
+        if (!caught_up)
+        {
+            if (sleep_time_us <= 0)
+            {
+                hdr_yield();
+            }
+            else
+            {
+                hdr_usleep(sleep_time_us);
+            }
+        }
+    }
+    while (!caught_up);
+}

data/ext/third_party/hdr_histogram_c/src/hdr_writer_reader_phaser.h

@@ -0,0 +1,51 @@
+/**
+ * hdr_writer_reader_phaser.h
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#ifndef HDR_WRITER_READER_PHASER_H
+#define HDR_WRITER_READER_PHASER_H 1
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "hdr_thread.h"
+
+HDR_ALIGN_PREFIX(8) 
+struct hdr_writer_reader_phaser
+{
+    int64_t start_epoch;
+    int64_t even_end_epoch;
+    int64_t odd_end_epoch;
+    hdr_mutex* reader_mutex;
+} 
+HDR_ALIGN_SUFFIX(8);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    int hdr_writer_reader_phaser_init(struct hdr_writer_reader_phaser* p);
+
+    void hdr_writer_reader_phaser_destroy(struct hdr_writer_reader_phaser* p);
+
+    int64_t hdr_phaser_writer_enter(struct hdr_writer_reader_phaser* p);
+
+    void hdr_phaser_writer_exit(
+    struct hdr_writer_reader_phaser* p, int64_t critical_value_at_enter);
+
+    void hdr_phaser_reader_lock(struct hdr_writer_reader_phaser* p);
+
+    void hdr_phaser_reader_unlock(struct hdr_writer_reader_phaser* p);
+
+    void hdr_phaser_flip_phase(
+    struct hdr_writer_reader_phaser* p, int64_t sleep_time_ns);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/lib/couchbase/cluster.rb

@@ -387,6 +387,7 @@ module Couchbase
 
           open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
         when Options::Cluster
+          open_options = options&.to_backend || {}
           authenticator = options&.authenticator
           case authenticator
           when PasswordAuthenticator

data/lib/couchbase/errors.rb

@@ -293,6 +293,9 @@ module Couchbase
     class LinkNotFound < CouchbaseError
     end
 
+    class LinkExists < CouchbaseError
+    end
+
     # Search exceptions
 
     class IndexNotReady < CouchbaseError

data/lib/couchbase/management/analytics_index_manager.rb

@@ -13,9 +13,616 @@
 #  limitations under the License.
 
 require "couchbase/errors"
+require "couchbase/options"
 
 module Couchbase
   module Management
+    module Options
+      module Analytics
+        # Options for {AnalyticsIndexManager#create_dataverse}
+        class CreateDataverse < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_exists # @return [Boolean]
+
+          # Creates an instance of options for {AnalyticsIndexManager#create_dataverse}
+          #
+          # @param [Boolean] ignore_if_exists if +true+, the exception {Error::DataverseExists} will not be raised if the
+          #  dataverse with the specified name already exists.
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateDataverse] self
+          def initialize(ignore_if_exists: false,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_exists = ignore_if_exists
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              ignore_if_exists: @ignore_if_exists,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#drop_dataverse}
+        class DropDataverse < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_does_not_exist # @return [Boolean]
+
+          # Creates an instance of options for {AnalyticsIndexManager#create_dataverse}
+          #
+          # @param [Boolean] ignore_if_does_not_exist if +true+, the exception {Error::DataverseNotFound} will not be raised
+          #  if the dataverse with the specified name does not exist.
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropDataverse] self
+          def initialize(ignore_if_does_not_exist: false,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_does_not_exist = ignore_if_does_not_exist
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              ignore_if_does_not_exist: @ignore_if_does_not_exist,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#create_dataset}
+        class CreateDataset < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_exists # @return [Boolean]
+          attr_accessor :condition # @return [String]
+          attr_accessor :dataverse_name # @return [String]
+
+          # Creates an instance of options for {AnalyticsIndexManager#create_dataset}
+          #
+          # @param [Boolean] ignore_if_exists if +true+, the exception {Error::DatasetExists} will not be raised
+          #  if the dataset with the specified name already exists.
+          # @param [String] condition WHERE clause to use for creating dataset
+          # @param [String] dataverse_name the name of the dataverse to use (defaults to +nil+)
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateDataset] self
+          def initialize(ignore_if_exists: false,
+                         condition: nil,
+                         dataverse_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_exists = ignore_if_exists
+            @condition = condition
+            @dataverse_name = dataverse_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              condition: @condition,
+              dataverse_name: @dataverse_name,
+              ignore_if_exists: @ignore_if_exists,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#drop_dataset}
+        class DropDataset < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_does_not_exist # @return [Boolean]
+          attr_accessor :dataverse_name # @return [String]
+
+          # Creates an instance of options for {AnalyticsIndexManager#drop_dataset}
+          #
+          # @param [Boolean] ignore_if_does_not_exist if +true+, the exception {Error::DatasetNotFound} will not be raised
+          #  if the dataset with the specified name does not exist.
+          # @param [String] dataverse_name the name of the dataverse to use (defaults to +nil+)
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropDataset] self
+          def initialize(ignore_if_does_not_exist: false,
+                         dataverse_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_does_not_exist = ignore_if_does_not_exist
+            @dataverse_name = dataverse_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              dataverse_name: @dataverse_name,
+              ignore_if_does_not_exist: @ignore_if_does_not_exist,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#get_all_datasets}
+        class GetAllDatasets < ::Couchbase::Options::Base
+          # Creates an instance of options for {AnalyticsIndexManager#get_all_datasets}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllDatasets] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#create_index}
+        class CreateIndex < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_exists # @return [Boolean]
+          attr_accessor :dataverse_name # @return [String]
+
+          # Creates an instance of options for {AnalyticsIndexManager#create_index}
+          #
+          # @param [Boolean] ignore_if_exists if +true+, the exception {Error::DatasetExists} will not be raised
+          #  if the dataset with the specified name already exists.
+          # @param [String] dataverse_name the name of the dataverse to use (defaults to +nil+)
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateIndex] self
+          def initialize(ignore_if_exists: false,
+                         dataverse_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_exists = ignore_if_exists
+            @dataverse_name = dataverse_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              dataverse_name: @dataverse_name,
+              ignore_if_exists: @ignore_if_exists,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#drop_index}
+        class DropIndex < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_does_not_exist # @return [Boolean]
+          attr_accessor :dataverse_name # @return [String]
+
+          # Creates an instance of options for {AnalyticsIndexManager#drop_index}
+          #
+          # @param [Boolean] ignore_if_does_not_exist if +true+, the exception {Error::DatasetNotFound} will not be raised
+          #  if the dataset with the specified name does not exist.
+          # @param [String] dataverse_name the name of the dataverse to use (defaults to +nil+)
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropIndex] self
+          def initialize(ignore_if_does_not_exist: false,
+                         dataverse_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_does_not_exist = ignore_if_does_not_exist
+            @dataverse_name = dataverse_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              dataverse_name: @dataverse_name,
+              ignore_if_does_not_exist: @ignore_if_does_not_exist,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#get_all_indexes}
+        class GetAllIndexes < ::Couchbase::Options::Base
+          # Creates an instance of options for {AnalyticsIndexManager#get_all_indexes}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllIndexes] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#connect_link}
+        class ConnectLink < ::Couchbase::Options::Base
+          attr_accessor :link_name # @return [String]
+          attr_accessor :force # @return [Boolean]
+          attr_accessor :dataverse_name # @return [String]
+
+          # Creates an instance of options for {AnalyticsIndexManager#connect_link}
+          #
+          # @param [String] link_name the name of the link
+          # @param [Boolean] force if +true+, link creation will be forced even if the bucket UUID changed, for example
+          #   due to the bucket being deleted and recreated
+          # @param [String] dataverse_name the name of the dataverse to use (defaults to +nil+)
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [ConnectLink] self
+          def initialize(link_name: "Local",
+                         force: false,
+                         dataverse_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @link_name = link_name
+            @force = force
+            @dataverse_name = dataverse_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              link_name: @link_name,
+              force: @force,
+              dataverse_name: @dataverse_name,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#connect_link}
+        class DisconnectLink < ::Couchbase::Options::Base
+          attr_accessor :link_name # @return [String]
+          attr_accessor :dataverse_name # @return [String]
+
+          # Creates an instance of options for {AnalyticsIndexManager#disconnect_link}
+          #
+          # @param [String] link_name the name of the link
+          # @param [String] dataverse_name the name of the dataverse to use (defaults to +nil+)
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DisconnectLink] self
+          def initialize(link_name: "Local",
+                         dataverse_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @link_name = link_name
+            @dataverse_name = dataverse_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              link_name: @link_name,
+              dataverse_name: @dataverse_name,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#get_pending_mutations}
+        class GetPendingMutations < ::Couchbase::Options::Base
+          # Creates an instance of options for {AnalyticsIndexManager#get_pending_mutations}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetPendingMutations] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#create_link}
+        class CreateLink < ::Couchbase::Options::Base
+          # Creates an instance of options for {AnalyticsIndexManager#create_link}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateLink] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#replace_link}
+        class ReplaceLink < ::Couchbase::Options::Base
+          # Creates an instance of options for {AnalyticsIndexManager#replace_link}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [ReplaceLink] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#drop_link}
+        class DropLink < ::Couchbase::Options::Base
+          # Creates an instance of options for {AnalyticsIndexManager#drop_link}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropLink] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+            }
+          end
+        end
+
+        # Options for {AnalyticsIndexManager#get_links}
+        class GetLinks < ::Couchbase::Options::Base
+          attr_accessor :dataverse # @return [String, nil]
+          attr_accessor :link_type # @return [Symbol, nil]
+          attr_accessor :name # @return [String, nil]
+
+          # Creates an instance of options for {AnalyticsIndexManager#get_links}
+          #
+          # @param [:s3, :azureblob, :couchbase, nil] link_type restricts the results to the given link type.
+          # @param [String, nil] dataverse restricts the results to a given dataverse, can be given in the form of
+          #   "namepart" or "namepart1/namepart2".
+          # @param [String, nil] name restricts the results to the link with the specified name. If set then dataverse
+          #   must also be set.
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to
+          #   complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetLinks] self
+          def initialize(link_type: nil,
+                         dataverse: nil,
+                         name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @link_type = link_type
+            @dataverse = dataverse
+            @name = name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              link_type: @link_type.to_s,
+              dataverse: @dataverse,
+              name: @name,
+            }
+          end
+        end
+
+        # rubocop:disable Naming/MethodName constructor shortcuts
+        module_function
+
+        # Construct {CreateDataverse} options for {AnalyticsIndexManager#create_dataverse}
+        #
+        # @return [CreateDataverse]
+        def CreateDataverse(**args)
+          CreateDataverse.new(**args)
+        end
+
+        # Construct {DropDataverse} options for {AnalyticsIndexManager#drop_dataverse}
+        #
+        # @return [DropDataverse]
+        def DropDataverse(**args)
+          DropDataverse.new(**args)
+        end
+
+        # Construct {CreateDataset} options for {AnalyticsIndexManager#create_dataset}
+        #
+        # @return [CreateDataset]
+        def CreateDataset(**args)
+          CreateDataset.new(**args)
+        end
+
+        # Construct {DropDataset} options for {AnalyticsIndexManager#drop_dataset}
+        #
+        # @return [DropDataset]
+        def DropDataset(**args)
+          DropDataset.new(**args)
+        end
+
+        # Construct {GetAllDatasets} options for {AnalyticsIndexManager#get_all_datasets}
+        #
+        # @return [GetAllDatasets]
+        def GetAllDatasets(**args)
+          GetAllDatasets.new(**args)
+        end
+
+        # Construct {CreateIndex} options for {AnalyticsIndexManager#create_index}
+        #
+        # @return [CreateIndex]
+        def CreateIndex(**args)
+          CreateIndex.new(**args)
+        end
+
+        # Construct {DropIndex} options for {AnalyticsIndexManager#drop_index}
+        #
+        # @return [DropIndex]
+        def DropIndex(**args)
+          DropIndex.new(**args)
+        end
+
+        # Construct {GetAllIndexes} options for {AnalyticsIndexManager#get_all_indexes}
+        #
+        # @return [GetAllIndexes]
+        def GetAllIndexes(**args)
+          GetAllIndexes.new(**args)
+        end
+
+        # Construct {ConnectLink} options for {AnalyticsIndexManager#connect_link}
+        #
+        # @return [ConnectLink]
+        def ConnectLink(**args)
+          ConnectLink.new(**args)
+        end
+
+        # Construct {DisconnectLink} options for {AnalyticsIndexManager#disconnect_link}
+        #
+        # @return [DisconnectLink]
+        def DisconnectLink(**args)
+          DisconnectLink.new(**args)
+        end
+
+        # Construct {GetPendingMutations} options for {AnalyticsIndexManager#get_pending_mutations}
+        #
+        # @return [GetPendingMutations]
+        def GetPendingMutations(**args)
+          GetPendingMutations.new(**args)
+        end
+
+        # Construct {CreateLink} options for {AnalyticsIndexManager#create_link}
+        #
+        # @return [CreateLink]
+        def CreateLink(**args)
+          CreateLink.new(**args)
+        end
+
+        # Construct {ReplaceLink} options for {AnalyticsIndexManager#replace_link}
+        #
+        # @return [ReplaceLink]
+        def ReplaceLink(**args)
+          ReplaceLink.new(**args)
+        end
+
+        # Construct {DropLink} options for {AnalyticsIndexManager#drop_link}
+        #
+        # @return [DropLink]
+        def DropLink(**args)
+          DropLink.new(**args)
+        end
+
+        # Construct {GetLinks} options for {AnalyticsIndexManager#get_links}
+        #
+        # @return [GetLinks]
+        def GetLinks(**args)
+          GetLinks.new(**args)
+        end
+
+        # rubocop:enable Naming/MethodName
+      end
+    end
+
     class AnalyticsIndexManager
       alias inspect to_s
 
@@ -27,84 +634,64 @@ module Couchbase
       # Creates a new dataverse
       #
       # @param [String] dataverse_name
-      # @param [CreateDataverseOptions] options
+      # @param [Options::Analytics::CreateDataverse] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::DataverseExists]
-      def create_dataverse(dataverse_name, options = CreateDataverseOptions.new)
-        @backend.analytics_dataverse_create(
-          dataverse_name,
-          options.ignore_if_exists,
-          options.timeout
-        )
+      def create_dataverse(dataverse_name, options = Options::Analytics::CreateDataverse.new)
+        @backend.analytics_dataverse_create(dataverse_name, options.to_backend)
       end
 
       # Drops a dataverse
       #
       # @param [String] dataverse_name name of the dataverse
-      # @param [DropDataverseOptions] options
+      # @param [Options::Analytics::DropDataverse] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::DataverseNotFound]
-      def drop_dataverse(dataverse_name, options = DropDataverseOptions.new)
-        @backend.analytics_dataverse_drop(
-          dataverse_name,
-          options.ignore_if_does_not_exist,
-          options.timeout
-        )
+      def drop_dataverse(dataverse_name, options = Options::Analytics::DropDataverse.new)
+        @backend.analytics_dataverse_drop(dataverse_name, options.to_backend)
       end
 
       # Creates a new dataset
       #
       # @param [String] dataset_name name of dataset
       # @param [String] bucket_name name of the bucket
-      # @param [CreateDatasetOptions] options
+      # @param [Options::Analytics::CreateDataset] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::DatasetExists]
       # @raise [Error::LinkNotFound]
-      def create_dataset(dataset_name, bucket_name, options = CreateDatasetOptions.new)
-        @backend.analytics_dataset_create(
-          dataset_name,
-          bucket_name,
-          options.condition,
-          options.dataverse_name,
-          options.ignore_if_exists,
-          options.timeout
-        )
+      def create_dataset(dataset_name, bucket_name, options = Options::Analytics::CreateDataset.new)
+        @backend.analytics_dataset_create(dataset_name, bucket_name, options.to_backend)
       end
 
       # Drops a dataset
       #
       # @param [String] dataset_name name of the dataset
-      # @param [DropDatasetOptions] options
+      # @param [Options::Analytics::DropDataset] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::DatasetNotFound]
-      def drop_dataset(dataset_name, options = DropDatasetOptions.new)
-        @backend.analytics_dataset_drop(
-          dataset_name,
-          options.dataverse_name,
-          options.ignore_if_does_not_exist,
-          options.timeout
-        )
+      def drop_dataset(dataset_name, options = Options::Analytics::DropDataset.new)
+        @backend.analytics_dataset_drop(dataset_name, options.to_backend)
       end
 
       # Gets all datasets
       #
-      # @param [GetAllDatasetsOptions] options
+      # @param [Options::Analytics::GetAllDatasets] options
       #
       # @return [Array<AnalyticsDataset>]
-      def get_all_datasets(options = GetAllDatasetsOptions.new)
-        resp = @backend.analytics_dataset_get_all(options.timeout)
+      def get_all_datasets(options = Options::Analytics::GetAllDatasets.new)
+        resp = @backend.analytics_dataset_get_all(options.to_backend)
         resp.map do |entry|
           AnalyticsDataset.new do |dataset|
             dataset.name = entry[:name]
@@ -120,50 +707,37 @@ module Couchbase
       # @param [String] index_name name of the index
       # @param [String] dataset_name name of the dataset
       # @param [Hash<String => String>] fields mapping of the field name to field type
-      # @param [CreateIndexOptions] options
+      # @param [Options::Analytics::CreateIndex] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexExists]
-      def create_index(index_name, dataset_name, fields, options = CreateIndexOptions.new)
-        @backend.analytics_index_create(
-          index_name,
-          dataset_name,
-          fields.entries,
-          options.dataverse_name,
-          options.ignore_if_exists,
-          options.timeout
-        )
+      def create_index(index_name, dataset_name, fields, options = Options::Analytics::CreateIndex.new)
+        @backend.analytics_index_create(index_name, dataset_name, fields.entries, options.to_backend)
       end
 
       # Drops an index
       #
       # @param [String] index_name name of the index
       # @param [String] dataset_name name of the dataset
-      # @param [DropIndexOptions] options
+      # @param [Options::Analytics::DropIndex] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def drop_index(index_name, dataset_name, options = DropIndexOptions.new)
-        @backend.analytics_index_drop(
-          index_name,
-          dataset_name,
-          options.dataverse_name,
-          options.ignore_if_does_not_exist,
-          options.timeout
-        )
+      def drop_index(index_name, dataset_name, options = Options::Analytics::DropIndex.new)
+        @backend.analytics_index_drop(index_name, dataset_name, options.to_backend)
       end
 
       # Gets all indexes
       #
-      # @param [GetAllIndexesOptions] options
+      # @param [Options::Analytics::GetAllIndexes] options
       #
       # @return [Array<AnalyticsIndex>]
-      def get_all_indexes(options = GetAllIndexesOptions.new)
-        resp = @backend.analytics_index_get_all(options.timeout)
+      def get_all_indexes(options = Options::Analytics::GetAllIndexes.new)
+        resp = @backend.analytics_index_get_all(options.to_backend)
         resp.map do |entry|
           AnalyticsIndex.new do |dataset|
             dataset.name = entry[:name]
@@ -176,35 +750,26 @@ module Couchbase
 
       # Connects a link
       #
-      # @param [ConnectLinkOptions] options
+      # @param [Options::Analytics::ConnectLink] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::LinkNotFound]
-      def connect_link(options = ConnectLinkOptions.new)
-        @backend.analytics_link_connect(
-          options.link_name,
-          options.force,
-          options.dataverse_name,
-          options.timeout
-        )
+      def connect_link(options = Options::Analytics::ConnectLink.new)
+        @backend.analytics_link_connect(options.to_backend)
       end
 
       # Disconnects a link,
       #
-      # @param [DisconnectLinkOptions] options
+      # @param [Options::Analytics::DisconnectLink] options
       #
       # @return [void]
       #
       # @raise [ArgumentError]
       # @raise [Error::LinkNotFound]
-      def disconnect_link(options = DisconnectLinkOptions.new)
-        @backend.analytics_link_disconnect(
-          options.link_name,
-          options.dataverse_name,
-          options.timeout
-        )
+      def disconnect_link(options = Options::Analytics::DisconnectLink.new)
+        @backend.analytics_link_disconnect(options.to_backend)
       end
 
       # Gets the pending mutations for all datasets.
@@ -212,183 +777,138 @@ module Couchbase
       # @note If a link is disconnected then it will return no results. If all links are disconnected, then
       # an empty object is returned.
       #
-      # @param [GetPendingMutationsOptions] options
+      # @param [Options::Analytics::GetPendingMutations] options
       #
       # @return [Hash<String => Integer>] dictionary, where keys are dataset coordinates encoded as +"dataverse.dataset"+
       #   and values are number of mutations for given dataset.
-      def get_pending_mutations(options = GetPendingMutationsOptions.new)
-        @backend.analytics_get_pending_mutations(
-          options.timeout
-        )
-      end
-
-      class CreateDataverseOptions
-        # @return [Boolean] ignore if the dataverse already exists
-        attr_accessor :ignore_if_exists
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [CreateDataverseOptions]
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
-      end
-
-      class DropDataverseOptions
-        # @return [Boolean] ignore if the dataverse does not exists
-        attr_accessor :ignore_if_does_not_exist
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropDataverseOptions]
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
-      end
-
-      class CreateDatasetOptions
-        # @return [Boolean] ignore if the dataset already exists
-        attr_accessor :ignore_if_exists
-
-        # @return [String] WHERE clause to use for creating dataset
-        attr_accessor :condition
-
-        # @return [String] The name of the dataverse to use (defaults to +nil+)
-        attr_accessor :dataverse_name
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [CreateDatasetOptions]
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
-      end
-
-      class DropDatasetOptions
-        # @return [Boolean] ignore if the dataset does not exists
-        attr_accessor :ignore_if_does_not_exist
-
-        # @return [String] The name of the dataverse to use (defaults to +nil+)
-        attr_accessor :dataverse_name
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropDatasetOptions]
-        def initialize
-          @ignore_if_does_not_exist = false
-          yield self if block_given?
-        end
+      def get_pending_mutations(options = Options::Analytics::GetPendingMutations.new)
+        @backend.analytics_get_pending_mutations(options.to_backend)
       end
 
-      class GetAllDatasetsOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetAllDatasetsOptions]
-        def initialize
-          yield self if block_given?
-        end
+      # Creates a link
+      #
+      # @param [CouchbaseRemoteAnalyticsLink, AzureBlobExternalAnalyticsLink, S3ExternalAnalyticsLink] link
+      # @param [Options::Analytics::CreateLink] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::LinkExists]
+      def create_link(link, options = Options::Analytics::CreateLink.new)
+        @backend.analytics_link_create(link.to_backend, options.to_backend)
       end
 
-      class CreateIndexOptions
-        # @return [Boolean] ignore if the index already exists
-        attr_accessor :ignore_if_exists
-
-        # @return [String] The name of the dataverse to use (defaults to +nil+)
-        attr_accessor :dataverse_name
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [CreateIndexOptions]
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
+      # Replaces the link
+      #
+      # @param [CouchbaseRemoteAnalyticsLink, AzureBlobExternalAnalyticsLink, S3ExternalAnalyticsLink] link
+      # @param [Options::Analytics::ReplaceLink] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::LinkNotFound]
+      def replace_link(link, options = Options::Analytics::ReplaceLink.new)
+        @backend.analytics_link_replace(link.to_backend, options.to_backend)
       end
 
-      class DropIndexOptions
-        # @return [Boolean] ignore if the index does not exists
-        attr_accessor :ignore_if_does_not_exist
-
-        # @return [String] The name of the dataverse to use (defaults to +nil+)
-        attr_accessor :dataverse_name
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropIndexOptions]
-        def initialize
-          @ignore_if_does_not_exist = false
-          yield self if block_given?
-        end
+      # Drops the link
+      #
+      # @param [String] link_name name of the link
+      # @param [String] dataverse_name dataverse where the link belongs
+      # @param [Options::Analytics::DropLink] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::LinkNotFound]
+      def drop_link(link_name, dataverse_name, options = Options::Analytics::DropLink.new)
+        @backend.analytics_link_drop(link_name, dataverse_name, options.to_backend)
       end
 
-      class GetAllIndexesOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetAllIndexesOptions]
-        def initialize
-          yield self if block_given?
+      # Retrieves the links
+      #
+      # @param [Options::Analytics::GetLinks] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::LinkNotFound]
+      def get_links(options = Options::Analytics::GetLinks.new)
+        resp = @backend.analytics_link_get_all(options.to_backend)
+        resp.map do |entry|
+          case entry[:type]
+          when :s3
+            S3ExternalAnalyticsLink.new(
+              entry[:link_name],
+              entry[:dataverse],
+              entry[:access_key_id],
+              nil,
+              entry[:region],
+              service_endpoint: entry[:service_endpoint]
+            )
+          when :couchbase
+            CouchbaseRemoteAnalyticsLink.new(
+              entry[:link_name],
+              entry[:dataverse],
+              entry[:hostname],
+              username: entry[:username],
+              encryption: EncryptionSettings.new(
+                level: entry[:encryption_level],
+                certificate: entry[:certificate],
+                client_certificate: entry[:client_certificate]
+              )
+            )
+          when :azureblob
+            AzureBlobExternalAnalyticsLink.new(
+              entry[:link_name],
+              entry[:dataverse],
+              account_name: entry[:account_name],
+              blob_endpoint: entry[:blob_endpoint],
+              endpoint_suffix: entry[:endpoint_suffix]
+            )
+          end
         end
       end
 
-      class ConnectLinkOptions
-        # @return [String] The name of the link (defaults to +"Local"+)
-        attr_accessor :link_name
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateDataverseOptions = ::Couchbase::Management::Options::Analytics::CreateDataverse
 
-        # @return [Boolean] Whether to force link creation even if the bucket UUID changed, for example due to the
-        #  bucket being deleted and recreated (defaults to +false+)
-        attr_accessor :force
+      # @api private
+      # TODO: deprecate after 3.2
+      DropDataverseOptions = ::Couchbase::Management::Options::Analytics::DropDataverse
 
-        # @return [String] The name of the dataverse to use (defaults to +nil+)
-        attr_accessor :dataverse_name
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateDatasetOptions = ::Couchbase::Management::Options::Analytics::CreateDataset
 
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      DropDatasetOptions = ::Couchbase::Management::Options::Analytics::DropDataset
 
-        # @yieldparam [ConnectLinkOptions]
-        def initialize
-          @link_name = "Local"
-          @force = false
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      GetAllDatasetsOptions = ::Couchbase::Management::Options::Analytics::GetAllDatasets
 
-      class DisconnectLinkOptions
-        # @return [String] The name of the link (defaults to +"Local"+)
-        attr_accessor :link_name
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateIndexOptions = ::Couchbase::Management::Options::Analytics::CreateIndex
 
-        # @return [String] The name of the dataverse to use (defaults to +nil+)
-        attr_accessor :dataverse_name
+      # @api private
+      # TODO: deprecate after 3.2
+      DropIndexOptions = ::Couchbase::Management::Options::Analytics::DropIndex
 
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DisconnectLinkOptions]
-        def initialize
-          @link_name = "Local"
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      GetAllIndexesOptions = ::Couchbase::Management::Options::Analytics::GetAllIndexes
 
-      class GetPendingMutationsOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      ConnectLinkOptions = ::Couchbase::Management::Options::Analytics::ConnectLink
 
-        # @yieldparam [GetPendingMutationsOptions]
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      GetPendingMutationsOptions = ::Couchbase::Management::Options::Analytics::GetPendingMutations
     end
 
     class AnalyticsDataset
@@ -429,5 +949,179 @@ module Couchbase
         yield self if block_given?
       end
     end
+
+    class EncryptionSettings
+      attr_accessor :level # @return [Symbol]
+      attr_accessor :certificate # @return [String, nil]
+      attr_accessor :client_certificate # @return [String, nil]
+      attr_accessor :client_key # @return [String, nil]
+
+      # @param [:none, :half, :full] level Specifies what level of encryption should be used.
+      # @param [String, nil] certificate
+      # @param [String, nil] client_certificate
+      # @param [String, nil] client_key
+      #
+      # @yieldparam [EncryptionSettings] self
+      def initialize(level: :none,
+                     certificate: nil,
+                     client_certificate: nil,
+                     client_key: nil)
+        @level = level
+        @certificate = certificate
+        @client_certificate = client_certificate
+        @client_key = client_key
+        yield self if block_given?
+      end
+    end
+
+    class CouchbaseRemoteAnalyticsLink
+      attr_accessor :name # @return [String]
+      attr_accessor :dataverse # @return [String]
+      attr_accessor :hostname # @return [String]
+      attr_accessor :username # @return [String, nil]
+      attr_accessor :password # @return [String, nil]
+      attr_accessor :encryption # @return [EncryptionSettings]
+
+      # @param [String] name the name of this link
+      # @param [String] dataverse the dataverse this link belongs to
+      # @param [String] hostname the hostname of the target Couchbase cluster
+      # @param [String, nil] username the username to use for authentication with the remote cluster. Optional if
+      #   client-certificate authentication is being used.
+      # @param [String, nil] password the password to use for authentication with the remote cluster. Optional if
+      #   client-certificate authentication is being used.
+      # @param [EncryptionSettings] encryption settings for connection encryption
+      #
+      # @yieldparam [CouchbaseRemoteLink] self
+      def initialize(name, dataverse, hostname,
+                     username: nil,
+                     password: nil,
+                     encryption: EncryptionSettings.new)
+        @name = name
+        @dataverse = dataverse
+        @hostname = hostname
+        @username = username
+        @password = password
+        @encryption = encryption
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_backend
+        {
+          type: :couchbase,
+          link_name: @name,
+          dataverse: @dataverse,
+          hostname: @hostname,
+          username: @username,
+          password: @password,
+          encryption_level: @encryption.level,
+          certificate: @encryption.certificate,
+          client_certificate: @encryption.client_certificate,
+          client_key: @encryption.client_key,
+        }
+      end
+    end
+
+    class AzureBlobExternalAnalyticsLink
+      attr_accessor :name # @return [String]
+      attr_accessor :dataverse # @return [String]
+      attr_accessor :connection_string # @return [String, nil]
+      attr_accessor :account_name # @return [String, nil]
+      attr_accessor :account_key # @return [String, nil]
+      attr_accessor :shared_access_signature # @return [String, nil]
+      attr_accessor :blob_endpoint # @return [String, nil]
+      attr_accessor :endpoint_suffix # @return [String, nil]
+
+      # @param [String] name the name of this link
+      # @param [String] dataverse the dataverse this link belongs to
+      # @param [String, nil] connection_string the connection string can be used as an authentication method,
+      #  +connection_string+ contains other authentication methods embedded inside the string. Only a single
+      #  authentication method can be used. (e.g. "AccountName=myAccountName;AccountKey=myAccountKey").
+      # @param [String, nil] account_name Azure blob storage account name
+      # @param [String, nil] account_key Azure blob storage account key
+      # @param [String, nil] shared_access_signature token that can be used for authentication
+      # @param [String, nil] blob_endpoint Azure blob storage endpoint
+      # @param [String, nil] endpoint_suffix Azure blob endpoint suffix
+      #
+      # @yieldparam [AzureBlobExternalAnalyticsLink] self
+      def initialize(name, dataverse,
+                     connection_string: nil,
+                     account_name: nil,
+                     account_key: nil,
+                     shared_access_signature: nil,
+                     blob_endpoint: nil,
+                     endpoint_suffix: nil)
+        @name = name
+        @dataverse = dataverse
+        @connection_string = connection_string
+        @account_name = account_name
+        @account_key = account_key
+        @shared_access_signature = shared_access_signature
+        @blob_endpoint = blob_endpoint
+        @endpoint_suffix = endpoint_suffix
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_backend
+        {
+          type: :azureblob,
+          link_name: @name,
+          dataverse: @dataverse,
+          connection_string: @connection_string,
+          account_name: @account_name,
+          account_key: @account_key,
+          shared_access_signature: @shared_access_signature,
+          blob_endpoint: @blob_endpoint,
+          endpoint_suffix: @endpoint_suffix,
+        }
+      end
+    end
+
+    class S3ExternalAnalyticsLink
+      attr_accessor :name # @return [String]
+      attr_accessor :dataverse # @return [String]
+      attr_accessor :access_key_id # @return [String]
+      attr_accessor :secret_access_key # @return [String]
+      attr_accessor :session_token # @return [String, nil]
+      attr_accessor :region # @return [String]
+      attr_accessor :service_endpoint # @return [String, nil]
+
+      # @param [String] name the name of this link
+      # @param [String] dataverse the dataverse this link belongs to
+      # @param [String] access_key_id AWS S3 access key ID
+      # @param [String] secret_access_key AWS S3 secret key
+      # @param [String] region  AWS S3 region
+      # @param [String, nil] session_token AWS S3 token if temporary credentials are provided. Only available in 7.0+
+      # @param [String, nil] service_endpoint AWS S3 service endpoint
+      #
+      # @yieldparam [S3ExternalAnalyticsLink] self
+      def initialize(name, dataverse, access_key_id, secret_access_key, region,
+                     session_token: nil,
+                     service_endpoint: nil)
+        @name = name
+        @dataverse = dataverse
+        @access_key_id = access_key_id
+        @secret_access_key = secret_access_key
+        @session_token = session_token
+        @region = region
+        @service_endpoint = service_endpoint
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_backend
+        {
+          type: :s3,
+          link_name: @name,
+          dataverse: @dataverse,
+          access_key_id: @access_key_id,
+          secret_access_key: @secret_access_key,
+          session_token: @session_token,
+          region: @region,
+          service_endpoint: @service_endpoint,
+        }
+      end
+    end
   end
 end