vellum_ai 0.3.15 → 0.14.74

data/lib/vellum_ai/types/workflow_error.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "json"
+require_relative "workflow_event_error"
+require_relative "workflow_initialization_error"
+
+module Vellum
+  class WorkflowError
+
+
+# Deserialize a JSON object to an instance of WorkflowError
+    #
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowError]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      begin
+        Vellum::WorkflowEventError.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::WorkflowEventError.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::WorkflowInitializationError.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::WorkflowInitializationError.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+ return struct
+    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:)
+      begin
+        return Vellum::WorkflowEventError.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::WorkflowInitializationError.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      raise("Passed value matched no type within the union, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_event_error.rb

@@ -1,51 +1,62 @@
 # frozen_string_literal: true
-
 require_relative "workflow_execution_event_error_code"
+require "ostruct"
 require "json"
 
 module Vellum
   class WorkflowEventError
-    attr_reader :message, :code, :additional_properties
+  # @return [String] 
+    attr_reader :message
+  # @return [Vellum::WorkflowExecutionEventErrorCode] 
+    attr_reader :code
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param message [String]
-    # @param code [WORKFLOW_EXECUTION_EVENT_ERROR_CODE]
+    # @param message [String] 
+    # @param code [Vellum::WorkflowExecutionEventErrorCode] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [WorkflowEventError]
+    # @return [Vellum::WorkflowEventError]
     def initialize(message:, code:, additional_properties: nil)
-      # @type [String]
       @message = message
-      # @type [WORKFLOW_EXECUTION_EVENT_ERROR_CODE]
       @code = code
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "message": message, "code": code }
     end
-
-    # Deserialize a JSON object to an instance of WorkflowEventError
+# Deserialize a JSON object to an instance of WorkflowEventError
     #
-    # @param json_object [JSON]
-    # @return [WorkflowEventError]
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowEventError]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      message = struct.message
-      code = WORKFLOW_EXECUTION_EVENT_ERROR_CODE.key(parsed_json["code"]) || parsed_json["code"]
-      new(message: message, code: code, additional_properties: struct)
+      message = parsed_json["message"]
+      code = parsed_json["code"]
+      new(
+        message: message,
+        code: code,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of WorkflowEventError to a JSON object
+# Serialize an instance of WorkflowEventError to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "message": @message, "code": WORKFLOW_EXECUTION_EVENT_ERROR_CODE[@code] || @code }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.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.
+# 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]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.message.is_a?(String) != false || raise("Passed value for field obj.message is not the expected type, validation failed.")
-      obj.code.is_a?(WORKFLOW_EXECUTION_EVENT_ERROR_CODE) != false || raise("Passed value for field obj.code is not the expected type, validation failed.")
+      obj.code.is_a?(Vellum::WorkflowExecutionEventErrorCode) != false || raise("Passed value for field obj.code is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/workflow_event_execution_read.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+require_relative "workflow_deployment_parent_context"
+require "date"
+require "date"
+require_relative "execution_vellum_value"
+require_relative "workflow_error"
+require_relative "workflow_execution_actual"
+require_relative "workflow_execution_view_online_eval_metric_result"
+require_relative "workflow_execution_usage_result"
+require_relative "vellum_span"
+require "ostruct"
+require "json"
+
+module Vellum
+  class WorkflowEventExecutionRead
+  # @return [String] 
+    attr_reader :span_id
+  # @return [Vellum::WorkflowDeploymentParentContext] 
+    attr_reader :parent_context
+  # @return [DateTime] 
+    attr_reader :start
+  # @return [DateTime] 
+    attr_reader :end_
+  # @return [Array<Vellum::ExecutionVellumValue>] 
+    attr_reader :inputs
+  # @return [Array<Vellum::ExecutionVellumValue>] 
+    attr_reader :outputs
+  # @return [Vellum::WorkflowError] 
+    attr_reader :error
+  # @return [Vellum::WorkflowExecutionActual] 
+    attr_reader :latest_actual
+  # @return [Array<Vellum::WorkflowExecutionViewOnlineEvalMetricResult>] 
+    attr_reader :metric_results
+  # @return [Array<Vellum::WorkflowExecutionUsageResult>] 
+    attr_reader :usage_results
+  # @return [Array<Vellum::VellumSpan>] 
+    attr_reader :spans
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
+
+    # @param span_id [String] 
+    # @param parent_context [Vellum::WorkflowDeploymentParentContext] 
+    # @param start [DateTime] 
+    # @param end_ [DateTime] 
+    # @param inputs [Array<Vellum::ExecutionVellumValue>] 
+    # @param outputs [Array<Vellum::ExecutionVellumValue>] 
+    # @param error [Vellum::WorkflowError] 
+    # @param latest_actual [Vellum::WorkflowExecutionActual] 
+    # @param metric_results [Array<Vellum::WorkflowExecutionViewOnlineEvalMetricResult>] 
+    # @param usage_results [Array<Vellum::WorkflowExecutionUsageResult>] 
+    # @param spans [Array<Vellum::VellumSpan>] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::WorkflowEventExecutionRead]
+    def initialize(span_id:, parent_context: OMIT, start:, end_: OMIT, inputs:, outputs:, error: OMIT, latest_actual: OMIT, metric_results:, usage_results: OMIT, spans:, additional_properties: nil)
+      @span_id = span_id
+      @parent_context = parent_context if parent_context != OMIT
+      @start = start
+      @end_ = end_ if end_ != OMIT
+      @inputs = inputs
+      @outputs = outputs
+      @error = error if error != OMIT
+      @latest_actual = latest_actual if latest_actual != OMIT
+      @metric_results = metric_results
+      @usage_results = usage_results if usage_results != OMIT
+      @spans = spans
+      @additional_properties = additional_properties
+      @_field_set = { "span_id": span_id, "parent_context": parent_context, "start": start, "end": end_, "inputs": inputs, "outputs": outputs, "error": error, "latest_actual": latest_actual, "metric_results": metric_results, "usage_results": usage_results, "spans": spans }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of WorkflowEventExecutionRead
+    #
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowEventExecutionRead]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      span_id = parsed_json["span_id"]
+      unless parsed_json["parent_context"].nil?
+        parent_context = parsed_json["parent_context"].to_json
+        parent_context = Vellum::WorkflowDeploymentParentContext.from_json(json_object: parent_context)
+      else
+        parent_context = nil
+      end
+      start = unless parsed_json["start"].nil?
+  DateTime.parse(parsed_json["start"])
+else
+  nil
+end
+      end_ = unless parsed_json["end"].nil?
+  DateTime.parse(parsed_json["end"])
+else
+  nil
+end
+      inputs = parsed_json["inputs"]&.map do | item |
+  item = item.to_json
+  Vellum::ExecutionVellumValue.from_json(json_object: item)
+end
+      outputs = parsed_json["outputs"]&.map do | item |
+  item = item.to_json
+  Vellum::ExecutionVellumValue.from_json(json_object: item)
+end
+      unless parsed_json["error"].nil?
+        error = parsed_json["error"].to_json
+        error = Vellum::WorkflowError.from_json(json_object: error)
+      else
+        error = nil
+      end
+      unless parsed_json["latest_actual"].nil?
+        latest_actual = parsed_json["latest_actual"].to_json
+        latest_actual = Vellum::WorkflowExecutionActual.from_json(json_object: latest_actual)
+      else
+        latest_actual = nil
+      end
+      metric_results = parsed_json["metric_results"]&.map do | item |
+  item = item.to_json
+  Vellum::WorkflowExecutionViewOnlineEvalMetricResult.from_json(json_object: item)
+end
+      usage_results = parsed_json["usage_results"]&.map do | item |
+  item = item.to_json
+  Vellum::WorkflowExecutionUsageResult.from_json(json_object: item)
+end
+      spans = parsed_json["spans"]&.map do | item |
+  item = item.to_json
+  Vellum::VellumSpan.from_json(json_object: item)
+end
+      new(
+        span_id: span_id,
+        parent_context: parent_context,
+        start: start,
+        end_: end_,
+        inputs: inputs,
+        outputs: outputs,
+        error: error,
+        latest_actual: latest_actual,
+        metric_results: metric_results,
+        usage_results: usage_results,
+        spans: spans,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of WorkflowEventExecutionRead to a JSON object
+    #
+    # @return [String]
+    def to_json
+      @_field_set&.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.span_id.is_a?(String) != false || raise("Passed value for field obj.span_id is not the expected type, validation failed.")
+      obj.parent_context.nil? || Vellum::WorkflowDeploymentParentContext.validate_raw(obj: obj.parent_context)
+      obj.start.is_a?(DateTime) != false || raise("Passed value for field obj.start is not the expected type, validation failed.")
+      obj.end_&.is_a?(DateTime) != false || raise("Passed value for field obj.end_ 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.outputs.is_a?(Array) != false || raise("Passed value for field obj.outputs is not the expected type, validation failed.")
+      obj.error.nil? || Vellum::WorkflowError.validate_raw(obj: obj.error)
+      obj.latest_actual.nil? || Vellum::WorkflowExecutionActual.validate_raw(obj: obj.latest_actual)
+      obj.metric_results.is_a?(Array) != false || raise("Passed value for field obj.metric_results is not the expected type, validation failed.")
+      obj.usage_results&.is_a?(Array) != false || raise("Passed value for field obj.usage_results is not the expected type, validation failed.")
+      obj.spans.is_a?(Array) != false || raise("Passed value for field obj.spans is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_execution_actual.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require_relative "execution_vellum_value"
+require "date"
+require "ostruct"
+require "json"
+
+module Vellum
+  class WorkflowExecutionActual
+  # @return [Vellum::ExecutionVellumValue] 
+    attr_reader :output
+  # @return [DateTime] 
+    attr_reader :timestamp
+  # @return [Float] 
+    attr_reader :quality
+  # @return [Hash{String => Object}] 
+    attr_reader :metadata
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
+
+    # @param output [Vellum::ExecutionVellumValue] 
+    # @param timestamp [DateTime] 
+    # @param quality [Float] 
+    # @param metadata [Hash{String => Object}] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::WorkflowExecutionActual]
+    def initialize(output:, timestamp:, quality:, metadata: OMIT, additional_properties: nil)
+      @output = output
+      @timestamp = timestamp
+      @quality = quality
+      @metadata = metadata if metadata != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "output": output, "timestamp": timestamp, "quality": quality, "metadata": metadata }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of WorkflowExecutionActual
+    #
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowExecutionActual]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      unless parsed_json["output"].nil?
+        output = parsed_json["output"].to_json
+        output = Vellum::ExecutionVellumValue.from_json(json_object: output)
+      else
+        output = nil
+      end
+      timestamp = unless parsed_json["timestamp"].nil?
+  DateTime.parse(parsed_json["timestamp"])
+else
+  nil
+end
+      quality = parsed_json["quality"]
+      metadata = parsed_json["metadata"]
+      new(
+        output: output,
+        timestamp: timestamp,
+        quality: quality,
+        metadata: metadata,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of WorkflowExecutionActual to a JSON object
+    #
+    # @return [String]
+    def to_json
+      @_field_set&.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:)
+      Vellum::ExecutionVellumValue.validate_raw(obj: obj.output)
+      obj.timestamp.is_a?(DateTime) != false || raise("Passed value for field obj.timestamp is not the expected type, validation failed.")
+      obj.quality.is_a?(Float) != false || raise("Passed value for field obj.quality is not the expected type, validation failed.")
+      obj.metadata&.is_a?(Hash) != false || raise("Passed value for field obj.metadata is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_execution_actual_chat_history_request.rb

@@ -1,77 +1,114 @@
 # frozen_string_literal: true
-
 require_relative "chat_message_request"
+require "ostruct"
 require "json"
 
 module Vellum
   class WorkflowExecutionActualChatHistoryRequest
-    attr_reader :output_id, :output_key, :quality, :timestamp, :desired_output_value, :additional_properties
+  # @return [String] The Vellum-generated ID of a workflow output. Must provide either this or
+#  output_key. output_key is typically preferred.
+    attr_reader :output_id
+  # @return [String] The user-defined name of a workflow output. Must provide either this or
+#  output_id. Should correspond to the `Name` specified in a Final Output Node.
+#  Generally preferred over output_id.
+    attr_reader :output_key
+  # @return [Float] Optionally provide a decimal number between 0.0 and 1.0 (inclusive) representing
+#  the quality of the output. 0 is the worst, 1 is the best.
+    attr_reader :quality
+  # @return [Hash{String => Object}] Optionally provide additional metadata about the feedback submission.
+    attr_reader :metadata
+  # @return [Float] Optionally provide the timestamp representing when this feedback was collected.
+#  Used for reporting purposes.
+    attr_reader :timestamp
+  # @return [String] 
+    attr_reader :output_type
+  # @return [Array<Vellum::ChatMessageRequest>] Optionally provide the value that the output ideally should have been.
+    attr_reader :desired_output_value
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param output_id [String] The Vellum-generated ID of a workflow output. Must provide either this or output_key. output_key is typically preferred.
-    # @param output_key [String] The user-defined name of a workflow output. Must provide either this or output_id. Should correspond to the `Name` specified in a Final Output Node. Generally preferred over output_id.
-    # @param quality [Float] Optionally provide a decimal number between 0.0 and 1.0 (inclusive) representing the quality of the output. 0 is the worst, 1 is the best.
-    # @param timestamp [Float] Optionally provide the timestamp representing when this feedback was collected. Used for reporting purposes.
-    # @param desired_output_value [Array<ChatMessageRequest>] Optionally provide the value that the output ideally should have been.
+    # @param output_id [String] The Vellum-generated ID of a workflow output. Must provide either this or
+#  output_key. output_key is typically preferred.
+    # @param output_key [String] The user-defined name of a workflow output. Must provide either this or
+#  output_id. Should correspond to the `Name` specified in a Final Output Node.
+#  Generally preferred over output_id.
+    # @param quality [Float] Optionally provide a decimal number between 0.0 and 1.0 (inclusive) representing
+#  the quality of the output. 0 is the worst, 1 is the best.
+    # @param metadata [Hash{String => Object}] Optionally provide additional metadata about the feedback submission.
+    # @param timestamp [Float] Optionally provide the timestamp representing when this feedback was collected.
+#  Used for reporting purposes.
+    # @param output_type [String] 
+    # @param desired_output_value [Array<Vellum::ChatMessageRequest>] Optionally provide the value that the output ideally should have been.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [WorkflowExecutionActualChatHistoryRequest]
-    def initialize(output_id: nil, output_key: nil, quality: nil, timestamp: nil, desired_output_value: nil,
-                   additional_properties: nil)
-      # @type [String] The Vellum-generated ID of a workflow output. Must provide either this or output_key. output_key is typically preferred.
-      @output_id = output_id
-      # @type [String] The user-defined name of a workflow output. Must provide either this or output_id. Should correspond to the `Name` specified in a Final Output Node. Generally preferred over output_id.
-      @output_key = output_key
-      # @type [Float] Optionally provide a decimal number between 0.0 and 1.0 (inclusive) representing the quality of the output. 0 is the worst, 1 is the best.
-      @quality = quality
-      # @type [Float] Optionally provide the timestamp representing when this feedback was collected. Used for reporting purposes.
-      @timestamp = timestamp
-      # @type [Array<ChatMessageRequest>] Optionally provide the value that the output ideally should have been.
-      @desired_output_value = desired_output_value
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::WorkflowExecutionActualChatHistoryRequest]
+    def initialize(output_id: OMIT, output_key: OMIT, quality: OMIT, metadata: OMIT, timestamp: OMIT, output_type:, desired_output_value: OMIT, additional_properties: nil)
+      @output_id = output_id if output_id != OMIT
+      @output_key = output_key if output_key != OMIT
+      @quality = quality if quality != OMIT
+      @metadata = metadata if metadata != OMIT
+      @timestamp = timestamp if timestamp != OMIT
+      @output_type = output_type
+      @desired_output_value = desired_output_value if desired_output_value != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "output_id": output_id, "output_key": output_key, "quality": quality, "metadata": metadata, "timestamp": timestamp, "output_type": output_type, "desired_output_value": desired_output_value }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of WorkflowExecutionActualChatHistoryRequest
+# Deserialize a JSON object to an instance of
+#  WorkflowExecutionActualChatHistoryRequest
     #
-    # @param json_object [JSON]
-    # @return [WorkflowExecutionActualChatHistoryRequest]
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowExecutionActualChatHistoryRequest]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      output_id = struct.output_id
-      output_key = struct.output_key
-      quality = struct.quality
-      timestamp = struct.timestamp
-      desired_output_value = parsed_json["desired_output_value"].map do |v|
-        v = v.to_json
-        ChatMessageRequest.from_json(json_object: v)
-      end
-      new(output_id: output_id, output_key: output_key, quality: quality, timestamp: timestamp,
-          desired_output_value: desired_output_value, additional_properties: struct)
+      output_id = parsed_json["output_id"]
+      output_key = parsed_json["output_key"]
+      quality = parsed_json["quality"]
+      metadata = parsed_json["metadata"]
+      timestamp = parsed_json["timestamp"]
+      output_type = parsed_json["output_type"]
+      desired_output_value = parsed_json["desired_output_value"]&.map do | item |
+  item = item.to_json
+  Vellum::ChatMessageRequest.from_json(json_object: item)
+end
+      new(
+        output_id: output_id,
+        output_key: output_key,
+        quality: quality,
+        metadata: metadata,
+        timestamp: timestamp,
+        output_type: output_type,
+        desired_output_value: desired_output_value,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of WorkflowExecutionActualChatHistoryRequest to a JSON object
+# Serialize an instance of WorkflowExecutionActualChatHistoryRequest to a JSON
+#  object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      {
-        "output_id": @output_id,
-        "output_key": @output_key,
-        "quality": @quality,
-        "timestamp": @timestamp,
-        "desired_output_value": @desired_output_value
-      }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.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.
+# 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]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.output_id&.is_a?(String) != false || raise("Passed value for field obj.output_id is not the expected type, validation failed.")
       obj.output_key&.is_a?(String) != false || raise("Passed value for field obj.output_key is not the expected type, validation failed.")
       obj.quality&.is_a?(Float) != false || raise("Passed value for field obj.quality is not the expected type, validation failed.")
+      obj.metadata&.is_a?(Hash) != false || raise("Passed value for field obj.metadata is not the expected type, validation failed.")
       obj.timestamp&.is_a?(Float) != false || raise("Passed value for field obj.timestamp is not the expected type, validation failed.")
+      obj.output_type.is_a?(String) != false || raise("Passed value for field obj.output_type is not the expected type, validation failed.")
       obj.desired_output_value&.is_a?(Array) != false || raise("Passed value for field obj.desired_output_value is not the expected type, validation failed.")
     end
   end
-end
+end