vellum_ai 0.3.4

data/lib/vellum_ai/types/generate_result.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "generate_result_data"
+require_relative "generate_result_error"
+require "json"
+
+module Vellum
+  class GenerateResult
+    attr_reader :data, :error, :additional_properties
+
+    # @param data [GenerateResultData] An object containing the resulting generation. This key will be absent if the LLM provider experienced an error.
+    # @param error [GenerateResultError] An object containing details about the error that occurred. This key will be absent if the LLM provider did not experience an error.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [GenerateResult]
+    def initialize(data: nil, error: nil, additional_properties: nil)
+      # @type [GenerateResultData] An object containing the resulting generation. This key will be absent if the LLM provider experienced an error.
+      @data = data
+      # @type [GenerateResultError] An object containing details about the error that occurred. This key will be absent if the LLM provider did not experience an error.
+      @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 GenerateResult
+    #
+    # @param json_object [JSON]
+    # @return [GenerateResult]
+    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 = GenerateResultData.from_json(json_object: data)
+      end
+      if parsed_json["error"].nil?
+        error = nil
+      else
+        error = parsed_json["error"].to_json
+        error = GenerateResultError.from_json(json_object: error)
+      end
+      new(data: data, error: error, additional_properties: struct)
+    end
+
+    # Serialize an instance of GenerateResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "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.data.nil? || GenerateResultData.validate_raw(obj: obj.data)
+      obj.error.nil? || GenerateResultError.validate_raw(obj: obj.error)
+    end
+  end
+end

data/lib/vellum_ai/types/generate_result_data.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "enriched_normalized_completion"
+require "json"
+
+module Vellum
+  class GenerateResultData
+    attr_reader :completions, :additional_properties
+
+    # @param completions [Array<EnrichedNormalizedCompletion>] The generated completions. This will generally be a list of length one.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [GenerateResultData]
+    def initialize(completions:, additional_properties: nil)
+      # @type [Array<EnrichedNormalizedCompletion>] The generated completions. This will generally be a list of length one.
+      @completions = completions
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of GenerateResultData
+    #
+    # @param json_object [JSON]
+    # @return [GenerateResultData]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      completions = parsed_json["completions"].map do |v|
+        v = v.to_json
+        EnrichedNormalizedCompletion.from_json(json_object: v)
+      end
+      new(completions: completions, additional_properties: struct)
+    end
+
+    # Serialize an instance of GenerateResultData to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "completions": @completions }.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.completions.is_a?(Array) != false || raise("Passed value for field obj.completions is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/generate_result_error.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class GenerateResultError
+    attr_reader :message, :additional_properties
+
+    # @param message [String] The error message returned by the LLM provider.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [GenerateResultError]
+    def initialize(message:, additional_properties: nil)
+      # @type [String] The error message returned by the LLM provider.
+      @message = message
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of GenerateResultError
+    #
+    # @param json_object [JSON]
+    # @return [GenerateResultError]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      message = struct.message
+      new(message: message, additional_properties: struct)
+    end
+
+    # Serialize an instance of GenerateResultError to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "message": @message }.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.message.is_a?(String) != false || raise("Passed value for field obj.message is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/generate_stream_response.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "generate_stream_result"
+require "json"
+
+module Vellum
+  class GenerateStreamResponse
+    attr_reader :delta, :additional_properties
+
+    # @param delta [GenerateStreamResult]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [GenerateStreamResponse]
+    def initialize(delta:, additional_properties: nil)
+      # @type [GenerateStreamResult]
+      @delta = delta
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of GenerateStreamResponse
+    #
+    # @param json_object [JSON]
+    # @return [GenerateStreamResponse]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["delta"].nil?
+        delta = nil
+      else
+        delta = parsed_json["delta"].to_json
+        delta = GenerateStreamResult.from_json(json_object: delta)
+      end
+      new(delta: delta, additional_properties: struct)
+    end
+
+    # Serialize an instance of GenerateStreamResponse to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "delta": @delta }.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:)
+      GenerateStreamResult.validate_raw(obj: obj.delta)
+    end
+  end
+end

data/lib/vellum_ai/types/generate_stream_result.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "generate_stream_result_data"
+require_relative "generate_result_error"
+require "json"
+
+module Vellum
+  class GenerateStreamResult
+    attr_reader :request_index, :data, :error, :additional_properties
+
+    # @param request_index [Integer]
+    # @param data [GenerateStreamResultData]
+    # @param error [GenerateResultError]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [GenerateStreamResult]
+    def initialize(request_index:, data: nil, error: nil, additional_properties: nil)
+      # @type [Integer]
+      @request_index = request_index
+      # @type [GenerateStreamResultData]
+      @data = data
+      # @type [GenerateResultError]
+      @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 GenerateStreamResult
+    #
+    # @param json_object [JSON]
+    # @return [GenerateStreamResult]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      request_index = struct.request_index
+      if parsed_json["data"].nil?
+        data = nil
+      else
+        data = parsed_json["data"].to_json
+        data = GenerateStreamResultData.from_json(json_object: data)
+      end
+      if parsed_json["error"].nil?
+        error = nil
+      else
+        error = parsed_json["error"].to_json
+        error = GenerateResultError.from_json(json_object: error)
+      end
+      new(request_index: request_index, data: data, error: error, additional_properties: struct)
+    end
+
+    # Serialize an instance of GenerateStreamResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "request_index": @request_index, "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.request_index.is_a?(Integer) != false || raise("Passed value for field obj.request_index is not the expected type, validation failed.")
+      obj.data.nil? || GenerateStreamResultData.validate_raw(obj: obj.data)
+      obj.error.nil? || GenerateResultError.validate_raw(obj: obj.error)
+    end
+  end
+end

data/lib/vellum_ai/types/generate_stream_result_data.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "enriched_normalized_completion"
+require "json"
+
+module Vellum
+  class GenerateStreamResultData
+    attr_reader :completion_index, :completion, :additional_properties
+
+    # @param completion_index [Integer]
+    # @param completion [EnrichedNormalizedCompletion]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [GenerateStreamResultData]
+    def initialize(completion_index:, completion:, additional_properties: nil)
+      # @type [Integer]
+      @completion_index = completion_index
+      # @type [EnrichedNormalizedCompletion]
+      @completion = completion
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of GenerateStreamResultData
+    #
+    # @param json_object [JSON]
+    # @return [GenerateStreamResultData]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      completion_index = struct.completion_index
+      if parsed_json["completion"].nil?
+        completion = nil
+      else
+        completion = parsed_json["completion"].to_json
+        completion = EnrichedNormalizedCompletion.from_json(json_object: completion)
+      end
+      new(completion_index: completion_index, completion: completion, additional_properties: struct)
+    end
+
+    # Serialize an instance of GenerateStreamResultData to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "completion_index": @completion_index, "completion": @completion }.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.completion_index.is_a?(Integer) != false || raise("Passed value for field obj.completion_index is not the expected type, validation failed.")
+      EnrichedNormalizedCompletion.validate_raw(obj: obj.completion)
+    end
+  end
+end

data/lib/vellum_ai/types/image_chat_message_content.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "vellum_image"
+require "json"
+
+module Vellum
+  # An image value that is used in a chat message.
+  class ImageChatMessageContent
+    attr_reader :value, :additional_properties
+
+    # @param value [VellumImage]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ImageChatMessageContent]
+    def initialize(value:, additional_properties: nil)
+      # @type [VellumImage]
+      @value = value
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ImageChatMessageContent
+    #
+    # @param json_object [JSON]
+    # @return [ImageChatMessageContent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = VellumImage.from_json(json_object: value)
+      end
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ImageChatMessageContent to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "value": @value }.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:)
+      VellumImage.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/image_chat_message_content_request.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "vellum_image_request"
+require "json"
+
+module Vellum
+  # An image value that is used in a chat message.
+  class ImageChatMessageContentRequest
+    attr_reader :value, :additional_properties
+
+    # @param value [VellumImageRequest]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ImageChatMessageContentRequest]
+    def initialize(value:, additional_properties: nil)
+      # @type [VellumImageRequest]
+      @value = value
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ImageChatMessageContentRequest
+    #
+    # @param json_object [JSON]
+    # @return [ImageChatMessageContentRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = VellumImageRequest.from_json(json_object: value)
+      end
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ImageChatMessageContentRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "value": @value }.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:)
+      VellumImageRequest.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/image_enum.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vellum
+  IMAGE_ENUM = String
+end

data/lib/vellum_ai/types/indexing_state_enum.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [INDEXING_STATE_ENUM]
+  INDEXING_STATE_ENUM = {
+    awaiting_processing: "AWAITING_PROCESSING",
+    queued: "QUEUED",
+    indexing: "INDEXING",
+    indexed: "INDEXED",
+    failed: "FAILED"
+  }.freeze
+end

data/lib/vellum_ai/types/initiated_enum.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vellum
+  INITIATED_ENUM = String
+end

data/lib/vellum_ai/types/initiated_execute_prompt_event.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "initiated_prompt_execution_meta"
+require "json"
+
+module Vellum
+  # The initial data returned indicating that the response from the model has returned and begun streaming.
+  class InitiatedExecutePromptEvent
+    attr_reader :meta, :execution_id, :additional_properties
+
+    # @param meta [InitiatedPromptExecutionMeta]
+    # @param execution_id [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [InitiatedExecutePromptEvent]
+    def initialize(execution_id:, meta: nil, additional_properties: nil)
+      # @type [InitiatedPromptExecutionMeta]
+      @meta = meta
+      # @type [String]
+      @execution_id = execution_id
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of InitiatedExecutePromptEvent
+    #
+    # @param json_object [JSON]
+    # @return [InitiatedExecutePromptEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["meta"].nil?
+        meta = nil
+      else
+        meta = parsed_json["meta"].to_json
+        meta = InitiatedPromptExecutionMeta.from_json(json_object: meta)
+      end
+      execution_id = struct.execution_id
+      new(meta: meta, execution_id: execution_id, additional_properties: struct)
+    end
+
+    # Serialize an instance of InitiatedExecutePromptEvent to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "meta": @meta, "execution_id": @execution_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.meta.nil? || InitiatedPromptExecutionMeta.validate_raw(obj: obj.meta)
+      obj.execution_id.is_a?(String) != false || raise("Passed value for field obj.execution_id is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/initiated_prompt_execution_meta.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  # The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
+  class InitiatedPromptExecutionMeta
+    attr_reader :model_name, :latency, :deployment_release_tag, :prompt_version_id, :additional_properties
+
+    # @param model_name [String]
+    # @param latency [Integer]
+    # @param deployment_release_tag [String]
+    # @param prompt_version_id [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [InitiatedPromptExecutionMeta]
+    def initialize(model_name: nil, latency: nil, deployment_release_tag: nil, prompt_version_id: nil,
+                   additional_properties: nil)
+      # @type [String]
+      @model_name = model_name
+      # @type [Integer]
+      @latency = latency
+      # @type [String]
+      @deployment_release_tag = deployment_release_tag
+      # @type [String]
+      @prompt_version_id = prompt_version_id
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of InitiatedPromptExecutionMeta
+    #
+    # @param json_object [JSON]
+    # @return [InitiatedPromptExecutionMeta]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      model_name = struct.model_name
+      latency = struct.latency
+      deployment_release_tag = struct.deployment_release_tag
+      prompt_version_id = struct.prompt_version_id
+      new(model_name: model_name, latency: latency, deployment_release_tag: deployment_release_tag,
+          prompt_version_id: prompt_version_id, additional_properties: struct)
+    end
+
+    # Serialize an instance of InitiatedPromptExecutionMeta to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "model_name": @model_name,
+        "latency": @latency,
+        "deployment_release_tag": @deployment_release_tag,
+        "prompt_version_id": @prompt_version_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.model_name&.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
+      obj.latency&.is_a?(Integer) != false || raise("Passed value for field obj.latency is not the expected type, validation failed.")
+      obj.deployment_release_tag&.is_a?(String) != false || raise("Passed value for field obj.deployment_release_tag is not the expected type, validation failed.")
+      obj.prompt_version_id&.is_a?(String) != false || raise("Passed value for field obj.prompt_version_id is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/initiated_workflow_node_result_event.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "workflow_node_result_data"
+require_relative "node_input_variable_compiled_value"
+require "json"
+
+module Vellum
+  # An event that indicates that the node has initiated its execution.
+  class InitiatedWorkflowNodeResultEvent
+    attr_reader :id, :node_id, :node_result_id, :ts, :data, :input_values, :additional_properties
+
+    # @param id [String]
+    # @param node_id [String]
+    # @param node_result_id [String]
+    # @param ts [DateTime]
+    # @param data [WorkflowNodeResultData]
+    # @param input_values [Array<NodeInputVariableCompiledValue>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [InitiatedWorkflowNodeResultEvent]
+    def initialize(id:, node_id:, node_result_id:, ts: nil, data: nil, input_values: 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 [Array<NodeInputVariableCompiledValue>]
+      @input_values = input_values
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of InitiatedWorkflowNodeResultEvent
+    #
+    # @param json_object [JSON]
+    # @return [InitiatedWorkflowNodeResultEvent]
+    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
+      input_values = parsed_json["input_values"].map do |v|
+        v = v.to_json
+        NodeInputVariableCompiledValue.from_json(json_object: v)
+      end
+      new(id: id, node_id: node_id, node_result_id: node_result_id, ts: ts, data: data, input_values: input_values,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of InitiatedWorkflowNodeResultEvent 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,
+        "input_values": @input_values
+      }.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)
+      obj.input_values&.is_a?(Array) != false || raise("Passed value for field obj.input_values is not the expected type, validation failed.")
+    end
+  end
+end