couchbase 3.7.0 → 3.8.0

data/lib/couchbase/management/search_index_manager.rb

@@ -15,92 +15,374 @@
 #  limitations under the License.
 
 require "couchbase/errors"
+require "couchbase/options"
 
 module Couchbase
   module Management
+    module Options
+      module Search
+        # Options for {SearchIndexManager#get_index}
+        class GetIndex < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#get_index}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetIndex] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#get_all_indexes}
+        class GetAllIndexes < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#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 [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,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#upsert_index}
+        class UpsertIndex < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#upsert_index}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [UpsertIndex] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#drop_index}
+        class DropIndex < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#drop_index}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropIndex] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#get_indexed_documents_count}
+        class GetIndexedDocumentsCount < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#get_indexed_documents_count}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetIndexedDocumentsCount] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#get_index_stats}
+        class GetIndexStats < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#get_index_stats}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetIndexStats] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#pause_ingest}
+        class PauseIngest < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#pause_ingest}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [PauseIngest] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#resume_ingest}
+        class ResumeIngest < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#resume_ingest}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [ResumeIngest] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#allow_querying}
+        class AllowQuerying < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#allow_querying}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [AllowQuerying] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#disallow_querying}
+        class DisallowQuerying < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#disallow_querying}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DisallowQuerying] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#freeze_plan}
+        class FreezePlan < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#freeze_plan}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [FreezePlan] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#unfreeze_plan}
+        class UnfreezePlan < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#unfreeze_plan}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [UnfreezePlan] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+
+        # Options for {SearchIndexManager#analyze_document}
+        class AnalyzeDocument < ::Couchbase::Options::Base
+          # Creates an instance of options for {SearchIndexManager#analyze_document}
+          #
+          # @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 [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [AnalyzeDocument] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+
+          # @api private
+          DEFAULT = new.freeze
+        end
+      end
+    end
+
     class SearchIndexManager
       alias inspect to_s
 
       # @param [Couchbase::Backend] backend
-      def initialize(backend)
+      # @param [Couchbase::Observability::Wrapper] observability wrapper
+      #
+      # @api private
+      def initialize(backend, observability)
         @backend = backend
+        @observability = observability
       end
 
       # Fetches an index from the server if it exists
       #
       # @param [String] index_name name of the index
-      # @param [GetIndexOptions] options
+      # @param [Options::Search::GetIndex] options
       #
       # @return [SearchIndex]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def get_index(index_name, options = GetIndexOptions.new)
-        res = @backend.search_index_get(nil, nil, index_name, options.timeout)
-        self.class.extract_search_index(res)
+      def get_index(index_name, options = Options::Search::GetIndex::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_INDEX, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_get(nil, nil, index_name, options.timeout, obs_handler)
+          self.class.extract_search_index(res)
+        end
       end
 
       # Fetches all indexes from the server
       #
-      # @param [GetAllIndexesOptions] options
+      # @param [Options::Search::GetAllIndexes] options
       #
       # @return [Array<SearchIndex>]
-      def get_all_indexes(options = GetAllIndexesOptions.new)
-        res = @backend.search_index_get_all(nil, nil, options.timeout)
-        res[:indexes].map { |idx| self.class.extract_search_index(idx) }
+      def get_all_indexes(options = Options::Search::GetAllIndexes::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_ALL_INDEXES, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_get_all(nil, nil, options.timeout, obs_handler)
+          res[:indexes].map { |idx| self.class.extract_search_index(idx) }
+        end
       end
 
       # Creates or updates the index
       #
       # @param [SearchIndex] index_definition the index definition
-      # @param [UpsertIndexOptions] options
+      # @param [Options::Search::UpsertIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError] if name, type or source_type is empty
-      def upsert_index(index_definition, options = UpsertIndexOptions.new)
-        @backend.search_index_upsert(
-          nil,
-          nil,
-          {
-            name: index_definition.name,
-            type: index_definition.type,
-            uuid: index_definition.uuid,
-            params: (JSON.generate(index_definition.params) if index_definition.params),
-            source_name: index_definition.source_name,
-            source_type: index_definition.source_type,
-            source_uuid: index_definition.source_uuid,
-            source_params: (JSON.generate(index_definition.source_params) if index_definition.source_params),
-            plan_params: (JSON.generate(index_definition.plan_params) if index_definition.plan_params),
-          }, options.timeout
-        )
+      def upsert_index(index_definition, options = Options::Search::UpsertIndex::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_UPSERT_INDEX, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_upsert(
+            nil,
+            nil,
+            {
+              name: index_definition.name,
+              type: index_definition.type,
+              uuid: index_definition.uuid,
+              params: (JSON.generate(index_definition.params) if index_definition.params),
+              source_name: index_definition.source_name,
+              source_type: index_definition.source_type,
+              source_uuid: index_definition.source_uuid,
+              source_params: (JSON.generate(index_definition.source_params) if index_definition.source_params),
+              plan_params: (JSON.generate(index_definition.plan_params) if index_definition.plan_params),
+            },
+            options.timeout,
+            obs_handler,
+          )
+        end
       end
 
       # Drops the index
       #
       # @param [String] index_name name of the index
-      # @param [DropIndexOptions] options
+      # @param [Options::Search::DropIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def drop_index(index_name, options = DropIndexOptions.new)
-        @backend.search_index_drop(nil, nil, index_name, options.timeout)
+      def drop_index(index_name, options = Options::Search::DropIndex::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_DROP_INDEX, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_drop(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Retrieves the number of documents that have been indexed for an index
       #
       # @param [String] index_name name of the index
-      # @param [GetIndexedDocumentsCountOptions] options
+      # @param [Options::Search::GetIndexedDocumentsCount] options
       #
       # @return [Integer]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def get_indexed_documents_count(index_name, options = GetIndexedDocumentsCountOptions.new)
-        res = @backend.search_index_get_documents_count(nil, nil, index_name, options.timeout)
-        res[:count]
+      def get_indexed_documents_count(index_name, options = Options::Search::GetIndexedDocumentsCount::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_INDEXED_DOCUMENTS_COUNT, options.parent_span, self,
+                                        :search) do |obs_handler|
+          res = @backend.search_index_get_documents_count(nil, nil, index_name, options.timeout, obs_handler)
+          res[:count]
+        end
       end
 
       # Retrieves metrics, timings and counters for a given index
@@ -108,15 +390,17 @@ module Couchbase
       # @!macro uncommitted
       #
       # @param [String] index_name name of the index
-      # @param [GetIndexStatsOptions] options
+      # @param [Options::Search::GetIndexStats] options
       #
       # @return [Integer]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def get_index_stats(index_name, options = GetIndexStatsOptions.new)
-        res = @backend.search_index_get_stats(index_name, options.timeout)
-        JSON.parse(res)
+      def get_index_stats(index_name, options = Options::Search::GetIndexStats::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_INDEX_STATS, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_get_stats(index_name, options.timeout, obs_handler)
+          JSON.parse(res)
+        end
       end
 
       # Retrieves statistics on search service. Information is provided on documents, partition indexes, mutations,
@@ -124,237 +408,176 @@ module Couchbase
       #
       # @!macro uncommitted
       #
-      # @param [GetIndexStatsOptions] options
+      # @param [Options::Search::GetIndexStats] options
       #
       # @return [Integer]
       #
       # @raise [ArgumentError]
-      def get_stats(options = GetIndexStatsOptions.new)
-        res = @backend.search_get_stats(options.timeout)
-        JSON.parse(res)
+      def get_stats(options = Options::Search::GetIndexStats::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_STATS, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_get_stats(options.timeout, obs_handler)
+          JSON.parse(res)
+        end
       end
 
       # Pauses updates and maintenance for the index
       #
       # @param [String] index_name name of the index
-      # @param [PauseIngestOptions] options
+      # @param [Options::Search::PauseIngest] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def pause_ingest(index_name, options = PauseIngestOptions.new)
-        @backend.search_index_pause_ingest(nil, nil, index_name, options.timeout)
+      def pause_ingest(index_name, options = Options::Search::PauseIngest::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_PAUSE_INGEST, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_pause_ingest(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Resumes updates and maintenance for an index
       #
       # @param [String] index_name name of the index
-      # @param [ResumeIngestOptions] options
+      # @param [Options::Search::ResumeIngest] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def resume_ingest(index_name, options = ResumeIngestOptions.new)
-        @backend.search_index_resume_ingest(nil, nil, index_name, options.timeout)
+      def resume_ingest(index_name, options = Options::Search::ResumeIngest::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_RESUME_INGEST, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_resume_ingest(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Allows querying against the index
       #
       # @param [String] index_name name of the index
-      # @param [AllowQueryingOptions] options
+      # @param [Options::Search::AllowQuerying] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def allow_querying(index_name, options = AllowQueryingOptions.new)
-        @backend.search_index_allow_querying(nil, nil, index_name, options.timeout)
+      def allow_querying(index_name, options = Options::Search::AllowQuerying::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_ALLOW_QUERYING, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_allow_querying(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Disallows querying against the index
       #
       # @param [String] index_name name of the index
-      # @param [DisallowQueryingOptions] options
+      # @param [Options::Search::DisallowQuerying] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def disallow_querying(index_name, options = DisallowQueryingOptions.new)
-        @backend.search_index_disallow_querying(nil, nil, index_name, options.timeout)
+      def disallow_querying(index_name, options = Options::Search::DisallowQuerying::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_DISALLOW_QUERYING, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_disallow_querying(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Freeze the assignment of index partitions to nodes
       #
       # @param [String] index_name name of the index
-      # @param [FreezePlanOptions] options
+      # @param [Options::Search::FreezePlan] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def freeze_plan(index_name, options = FreezePlanOptions.new)
-        @backend.search_index_freeze_plan(nil, nil, index_name, options.timeout)
+      def freeze_plan(index_name, options = Options::Search::FreezePlan::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_FREEZE_PLAN, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_freeze_plan(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Unfreeze the assignment of index partitions to nodes
       #
       # @param [String] index_name name of the index
-      # @param [UnfreezePlanOptions] options
+      # @param [Options::Search::UnfreezePlan] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def unfreeze_plan(index_name, options = UnfreezePlanOptions.new)
-        @backend.search_index_unfreeze_plan(nil, nil, index_name, options.timeout)
+      def unfreeze_plan(index_name, options = Options::Search::UnfreezePlan::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_UNFREEZE_PLAN, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_unfreeze_plan(nil, nil, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Allows to see how a document is analyzed against a specific index
       #
       # @param [String] index_name name of the index
       # @param [Hash] document the document to be analyzed
+      # @param [Options::Search::AnalyzeDocument] options
       #
       # @return [Array<Hash>]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def analyze_document(index_name, document, options = AnalyzeDocumentOptions.new)
-        res = @backend.search_index_analyze_document(nil, nil, index_name, JSON.generate(document), options.timeout)
-        JSON.parse(res[:analysis])
-      end
-
-      class GetIndexOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetIndexOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class GetAllIndexesOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetAllIndexesOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class UpsertIndexOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [UpsertIndexOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class DropIndexOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropIndexOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class GetIndexedDocumentsCountOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetIndexedDocumentCountOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class GetIndexStatsOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetStatsOptions] self
-        def initialize
-          yield self if block_given?
+      def analyze_document(index_name, document, options = Options::Search::AnalyzeDocument::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_ANALYZE_DOCUMENT, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_analyze_document(nil, nil, index_name, JSON.generate(document), options.timeout, obs_handler)
+          JSON.parse(res[:analysis])
         end
       end
 
-      class PauseIngestOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [PauseIngestOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::GetIndex} instead
+      GetIndexOptions = Options::Search::GetIndex
 
-      class ResumeIngestOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # @deprecated use {Options::Search::GetAllIndexes} instead
+      GetAllIndexesOptions = Options::Search::GetAllIndexes
 
-        # @yieldparam [ResumeIngestOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::UpsertIndex} instead
+      UpsertIndexOptions = Options::Search::UpsertIndex
 
-      class AllowQueryingOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # @deprecated use {Options::Search::DropIndex} instead
+      DropIndexOptions = Options::Search::DropIndex
 
-        # @yieldparam [AllowQueryingOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::GetIndexedDocumentsCount} instead
+      GetIndexedDocumentsCountOptions = Options::Search::GetIndexedDocumentsCount
 
-      class DisallowQueryingOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # @deprecated use {Options::Search::GetIndexStats} instead
+      GetIndexStatsOptions = Options::Search::GetIndexStats
 
-        # @yieldparam [DisallowQueryingOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::PauseIngest} instead
+      PauseIngestOptions = Options::Search::PauseIngest
 
-      class FreezePlanOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # @deprecated use {Options::Search::ResumeIngest} instead
+      ResumeIngestOptions = Options::Search::ResumeIngest
 
-        # @yieldparam [FreezePlanOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::AllowQuerying} instead
+      AllowQueryingOptions = Options::Search::AllowQuerying
 
-      class UnfreezePlanOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # @deprecated use {Options::Search::DisallowQuerying} instead
+      DisallowQueryingOptions = Options::Search::DisallowQuerying
 
-        # @yieldparam [UnfreezePlanOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::FreezePlan} instead
+      FreezePlanOptions = Options::Search::FreezePlan
 
-      class AnalyzeDocumentOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # @deprecated use {Options::Search::UnfreezePlan} instead
+      UnfreezePlanOptions = Options::Search::UnfreezePlan
 
-        # @yieldparam [AnalyzeDocumentOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # @deprecated use {Options::Search::AnalyzeDocument} instead
+      AnalyzeDocumentOptions = Options::Search::AnalyzeDocument
 
       # @api private
       def self.extract_search_index(resp)