vellum_ai 0.3.4

data/lib/vellum_ai/types/rejected_prompt_execution_meta.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "finish_reason_enum"
+require "json"
+
+module Vellum
+  # The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
+  class RejectedPromptExecutionMeta
+    attr_reader :latency, :finish_reason, :additional_properties
+
+    # @param latency [Integer]
+    # @param finish_reason [FINISH_REASON_ENUM]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [RejectedPromptExecutionMeta]
+    def initialize(latency: nil, finish_reason: nil, additional_properties: nil)
+      # @type [Integer]
+      @latency = latency
+      # @type [FINISH_REASON_ENUM]
+      @finish_reason = finish_reason
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of RejectedPromptExecutionMeta
+    #
+    # @param json_object [JSON]
+    # @return [RejectedPromptExecutionMeta]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      latency = struct.latency
+      finish_reason = FINISH_REASON_ENUM.key(parsed_json["finish_reason"]) || parsed_json["finish_reason"]
+      new(latency: latency, finish_reason: finish_reason, additional_properties: struct)
+    end
+
+    # Serialize an instance of RejectedPromptExecutionMeta to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "latency": @latency, "finish_reason": FINISH_REASON_ENUM[@finish_reason] || @finish_reason }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.latency&.is_a?(Integer) != false || raise("Passed value for field obj.latency is not the expected type, validation failed.")
+      obj.finish_reason&.is_a?(FINISH_REASON_ENUM) != false || raise("Passed value for field obj.finish_reason is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/rejected_workflow_node_result_event.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "workflow_node_result_data"
+require_relative "workflow_event_error"
+require "json"
+
+module Vellum
+  # An event that indicates that the node has rejected its execution.
+  class RejectedWorkflowNodeResultEvent
+    attr_reader :id, :node_id, :node_result_id, :ts, :data, :error, :additional_properties
+
+    # @param id [String]
+    # @param node_id [String]
+    # @param node_result_id [String]
+    # @param ts [DateTime]
+    # @param data [WorkflowNodeResultData]
+    # @param error [WorkflowEventError]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [RejectedWorkflowNodeResultEvent]
+    def initialize(id:, node_id:, node_result_id:, error:, ts: nil, data: nil, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String]
+      @node_id = node_id
+      # @type [String]
+      @node_result_id = node_result_id
+      # @type [DateTime]
+      @ts = ts
+      # @type [WorkflowNodeResultData]
+      @data = data
+      # @type [WorkflowEventError]
+      @error = error
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of RejectedWorkflowNodeResultEvent
+    #
+    # @param json_object [JSON]
+    # @return [RejectedWorkflowNodeResultEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      node_id = struct.node_id
+      node_result_id = struct.node_result_id
+      ts = DateTime.parse(parsed_json["ts"])
+      if parsed_json["data"].nil?
+        data = nil
+      else
+        data = parsed_json["data"].to_json
+        data = WorkflowNodeResultData.from_json(json_object: data)
+      end
+      if parsed_json["error"].nil?
+        error = nil
+      else
+        error = parsed_json["error"].to_json
+        error = WorkflowEventError.from_json(json_object: error)
+      end
+      new(id: id, node_id: node_id, node_result_id: node_result_id, ts: ts, data: data, error: error,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of RejectedWorkflowNodeResultEvent to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "id": @id,
+        "node_id": @node_id,
+        "node_result_id": @node_result_id,
+        "ts": @ts,
+        "data": @data,
+        "error": @error
+      }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.node_id.is_a?(String) != false || raise("Passed value for field obj.node_id is not the expected type, validation failed.")
+      obj.node_result_id.is_a?(String) != false || raise("Passed value for field obj.node_result_id is not the expected type, validation failed.")
+      obj.ts&.is_a?(DateTime) != false || raise("Passed value for field obj.ts is not the expected type, validation failed.")
+      obj.data.nil? || WorkflowNodeResultData.validate_raw(obj: obj.data)
+      WorkflowEventError.validate_raw(obj: obj.error)
+    end
+  end
+end

data/lib/vellum_ai/types/sandbox_scenario.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "scenario_input"
+require "json"
+
+module Vellum
+  class SandboxScenario
+    attr_reader :label, :inputs, :id, :additional_properties
+
+    # @param label [String]
+    # @param inputs [Array<ScenarioInput>] The inputs for the scenario
+    # @param id [String] The id of the scenario
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SandboxScenario]
+    def initialize(inputs:, id:, label: nil, additional_properties: nil)
+      # @type [String]
+      @label = label
+      # @type [Array<ScenarioInput>] The inputs for the scenario
+      @inputs = inputs
+      # @type [String] The id of the scenario
+      @id = id
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SandboxScenario
+    #
+    # @param json_object [JSON]
+    # @return [SandboxScenario]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      label = struct.label
+      inputs = parsed_json["inputs"].map do |v|
+        v = v.to_json
+        ScenarioInput.from_json(json_object: v)
+      end
+      id = struct.id
+      new(label: label, inputs: inputs, id: id, additional_properties: struct)
+    end
+
+    # Serialize an instance of SandboxScenario to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "label": @label, "inputs": @inputs, "id": @id }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.label&.is_a?(String) != false || raise("Passed value for field obj.label is not the expected type, validation failed.")
+      obj.inputs.is_a?(Array) != false || raise("Passed value for field obj.inputs is not the expected type, validation failed.")
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/scenario_input.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "scenario_input_type_enum"
+require_relative "chat_message"
+require "json"
+
+module Vellum
+  class ScenarioInput
+    attr_reader :key, :type, :value, :chat_history, :additional_properties
+
+    # @param key [String]
+    # @param type [SCENARIO_INPUT_TYPE_ENUM]
+    # @param value [String]
+    # @param chat_history [Array<ChatMessage>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ScenarioInput]
+    def initialize(key:, type: nil, value: nil, chat_history: nil, additional_properties: nil)
+      # @type [String]
+      @key = key
+      # @type [SCENARIO_INPUT_TYPE_ENUM]
+      @type = type
+      # @type [String]
+      @value = value
+      # @type [Array<ChatMessage>]
+      @chat_history = chat_history
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ScenarioInput
+    #
+    # @param json_object [JSON]
+    # @return [ScenarioInput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      key = struct.key
+      type = SCENARIO_INPUT_TYPE_ENUM.key(parsed_json["type"]) || parsed_json["type"]
+      value = struct.value
+      chat_history = parsed_json["chat_history"].map do |v|
+        v = v.to_json
+        ChatMessage.from_json(json_object: v)
+      end
+      new(key: key, type: type, value: value, chat_history: chat_history, additional_properties: struct)
+    end
+
+    # Serialize an instance of ScenarioInput to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "key": @key,
+        "type": SCENARIO_INPUT_TYPE_ENUM[@type] || @type,
+        "value": @value,
+        "chat_history": @chat_history
+      }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.key.is_a?(String) != false || raise("Passed value for field obj.key is not the expected type, validation failed.")
+      obj.type&.is_a?(SCENARIO_INPUT_TYPE_ENUM) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value&.is_a?(String) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+      obj.chat_history&.is_a?(Array) != false || raise("Passed value for field obj.chat_history is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/scenario_input_request.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "scenario_input_type_enum"
+require_relative "chat_message_request"
+require "json"
+
+module Vellum
+  class ScenarioInputRequest
+    attr_reader :key, :type, :value, :chat_history, :additional_properties
+
+    # @param key [String]
+    # @param type [SCENARIO_INPUT_TYPE_ENUM]
+    # @param value [String]
+    # @param chat_history [Array<ChatMessageRequest>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ScenarioInputRequest]
+    def initialize(key:, type: nil, value: nil, chat_history: nil, additional_properties: nil)
+      # @type [String]
+      @key = key
+      # @type [SCENARIO_INPUT_TYPE_ENUM]
+      @type = type
+      # @type [String]
+      @value = value
+      # @type [Array<ChatMessageRequest>]
+      @chat_history = chat_history
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ScenarioInputRequest
+    #
+    # @param json_object [JSON]
+    # @return [ScenarioInputRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      key = struct.key
+      type = SCENARIO_INPUT_TYPE_ENUM.key(parsed_json["type"]) || parsed_json["type"]
+      value = struct.value
+      chat_history = parsed_json["chat_history"].map do |v|
+        v = v.to_json
+        ChatMessageRequest.from_json(json_object: v)
+      end
+      new(key: key, type: type, value: value, chat_history: chat_history, additional_properties: struct)
+    end
+
+    # Serialize an instance of ScenarioInputRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "key": @key,
+        "type": SCENARIO_INPUT_TYPE_ENUM[@type] || @type,
+        "value": @value,
+        "chat_history": @chat_history
+      }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.key.is_a?(String) != false || raise("Passed value for field obj.key is not the expected type, validation failed.")
+      obj.type&.is_a?(SCENARIO_INPUT_TYPE_ENUM) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value&.is_a?(String) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+      obj.chat_history&.is_a?(Array) != false || raise("Passed value for field obj.chat_history is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/scenario_input_type_enum.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [SCENARIO_INPUT_TYPE_ENUM]
+  SCENARIO_INPUT_TYPE_ENUM = { text: "TEXT", chat_history: "CHAT_HISTORY" }.freeze
+end

data/lib/vellum_ai/types/search_error_response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class SearchErrorResponse
+    attr_reader :detail, :additional_properties
+
+    # @param detail [String] Details about why the request failed.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SearchErrorResponse]
+    def initialize(detail:, additional_properties: nil)
+      # @type [String] Details about why the request failed.
+      @detail = detail
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SearchErrorResponse
+    #
+    # @param json_object [JSON]
+    # @return [SearchErrorResponse]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      detail = struct.detail
+      new(detail: detail, additional_properties: struct)
+    end
+
+    # Serialize an instance of SearchErrorResponse to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "detail": @detail }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.detail.is_a?(String) != false || raise("Passed value for field obj.detail is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/search_filters_request.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "metadata_filter_config_request"
+require "json"
+
+module Vellum
+  class SearchFiltersRequest
+    attr_reader :external_ids, :metadata, :additional_properties
+
+    # @param external_ids [Array<String>] The document external IDs to filter by
+    # @param metadata [MetadataFilterConfigRequest] The metadata filters to apply to the search
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SearchFiltersRequest]
+    def initialize(external_ids: nil, metadata: nil, additional_properties: nil)
+      # @type [Array<String>] The document external IDs to filter by
+      @external_ids = external_ids
+      # @type [MetadataFilterConfigRequest] The metadata filters to apply to the search
+      @metadata = metadata
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SearchFiltersRequest
+    #
+    # @param json_object [JSON]
+    # @return [SearchFiltersRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      external_ids = struct.external_ids
+      if parsed_json["metadata"].nil?
+        metadata = nil
+      else
+        metadata = parsed_json["metadata"].to_json
+        metadata = MetadataFilterConfigRequest.from_json(json_object: metadata)
+      end
+      new(external_ids: external_ids, metadata: metadata, additional_properties: struct)
+    end
+
+    # Serialize an instance of SearchFiltersRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "external_ids": @external_ids, "metadata": @metadata }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.external_ids&.is_a?(Array) != false || raise("Passed value for field obj.external_ids is not the expected type, validation failed.")
+      obj.metadata.nil? || MetadataFilterConfigRequest.validate_raw(obj: obj.metadata)
+    end
+  end
+end

data/lib/vellum_ai/types/search_node_result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "search_node_result_data"
+require "json"
+
+module Vellum
+  # A Node Result Event emitted from a Search Node.
+  class SearchNodeResult
+    attr_reader :data, :additional_properties
+
+    # @param data [SearchNodeResultData]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SearchNodeResult]
+    def initialize(data:, additional_properties: nil)
+      # @type [SearchNodeResultData]
+      @data = data
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SearchNodeResult
+    #
+    # @param json_object [JSON]
+    # @return [SearchNodeResult]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["data"].nil?
+        data = nil
+      else
+        data = parsed_json["data"].to_json
+        data = SearchNodeResultData.from_json(json_object: data)
+      end
+      new(data: data, additional_properties: struct)
+    end
+
+    # Serialize an instance of SearchNodeResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "data": @data }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      SearchNodeResultData.validate_raw(obj: obj.data)
+    end
+  end
+end

data/lib/vellum_ai/types/search_node_result_data.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "search_result"
+require "json"
+
+module Vellum
+  class SearchNodeResultData
+    attr_reader :results_output_id, :results, :text_output_id, :text, :additional_properties
+
+    # @param results_output_id [String]
+    # @param results [Array<SearchResult>] The results of the search. Each result represents a chunk that matches the search query.
+    # @param text_output_id [String]
+    # @param text [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SearchNodeResultData]
+    def initialize(results_output_id:, results:, text_output_id:, text: nil, additional_properties: nil)
+      # @type [String]
+      @results_output_id = results_output_id
+      # @type [Array<SearchResult>] The results of the search. Each result represents a chunk that matches the search query.
+      @results = results
+      # @type [String]
+      @text_output_id = text_output_id
+      # @type [String]
+      @text = text
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SearchNodeResultData
+    #
+    # @param json_object [JSON]
+    # @return [SearchNodeResultData]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      results_output_id = struct.results_output_id
+      results = parsed_json["results"].map do |v|
+        v = v.to_json
+        SearchResult.from_json(json_object: v)
+      end
+      text_output_id = struct.text_output_id
+      text = struct.text
+      new(results_output_id: results_output_id, results: results, text_output_id: text_output_id, text: text,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of SearchNodeResultData to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "results_output_id": @results_output_id,
+        "results": @results,
+        "text_output_id": @text_output_id,
+        "text": @text
+      }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.results_output_id.is_a?(String) != false || raise("Passed value for field obj.results_output_id is not the expected type, validation failed.")
+      obj.results.is_a?(Array) != false || raise("Passed value for field obj.results is not the expected type, validation failed.")
+      obj.text_output_id.is_a?(String) != false || raise("Passed value for field obj.text_output_id is not the expected type, validation failed.")
+      obj.text&.is_a?(String) != false || raise("Passed value for field obj.text is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/search_request_options_request.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "search_weights_request"
+require_relative "search_result_merging_request"
+require_relative "search_filters_request"
+require "json"
+
+module Vellum
+  class SearchRequestOptionsRequest
+    attr_reader :limit, :weights, :result_merging, :filters, :additional_properties
+
+    # @param limit [Integer] The maximum number of results to return.
+    # @param weights [SearchWeightsRequest] The weights to use for the search. Must add up to 1.0.
+    # @param result_merging [SearchResultMergingRequest] The configuration for merging results.
+    # @param filters [SearchFiltersRequest] The filters to apply to the search.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SearchRequestOptionsRequest]
+    def initialize(limit: nil, weights: nil, result_merging: nil, filters: nil, additional_properties: nil)
+      # @type [Integer] The maximum number of results to return.
+      @limit = limit
+      # @type [SearchWeightsRequest] The weights to use for the search. Must add up to 1.0.
+      @weights = weights
+      # @type [SearchResultMergingRequest] The configuration for merging results.
+      @result_merging = result_merging
+      # @type [SearchFiltersRequest] The filters to apply to the search.
+      @filters = filters
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SearchRequestOptionsRequest
+    #
+    # @param json_object [JSON]
+    # @return [SearchRequestOptionsRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      limit = struct.limit
+      if parsed_json["weights"].nil?
+        weights = nil
+      else
+        weights = parsed_json["weights"].to_json
+        weights = SearchWeightsRequest.from_json(json_object: weights)
+      end
+      if parsed_json["result_merging"].nil?
+        result_merging = nil
+      else
+        result_merging = parsed_json["result_merging"].to_json
+        result_merging = SearchResultMergingRequest.from_json(json_object: result_merging)
+      end
+      if parsed_json["filters"].nil?
+        filters = nil
+      else
+        filters = parsed_json["filters"].to_json
+        filters = SearchFiltersRequest.from_json(json_object: filters)
+      end
+      new(limit: limit, weights: weights, result_merging: result_merging, filters: filters,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of SearchRequestOptionsRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "limit": @limit, "weights": @weights, "result_merging": @result_merging, "filters": @filters }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.limit&.is_a?(Integer) != false || raise("Passed value for field obj.limit is not the expected type, validation failed.")
+      obj.weights.nil? || SearchWeightsRequest.validate_raw(obj: obj.weights)
+      obj.result_merging.nil? || SearchResultMergingRequest.validate_raw(obj: obj.result_merging)
+      obj.filters.nil? || SearchFiltersRequest.validate_raw(obj: obj.filters)
+    end
+  end
+end