vellum_ai 0.3.4

data/lib/vellum_ai/types/prompt_deployment_expand_meta_request_request.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class PromptDeploymentExpandMetaRequestRequest
+    attr_reader :model_name, :latency, :deployment_release_tag, :prompt_version_id, :finish_reason,
+                :additional_properties
+
+    # @param model_name [Boolean] If enabled, the response will include the model identifier representing the ML Model invoked by the Prompt Deployment.
+    # @param latency [Boolean] If enabled, the response will include the time in nanoseconds it took to execute the Prompt Deployment.
+    # @param deployment_release_tag [Boolean] If enabled, the response will include the release tag of the Prompt Deployment.
+    # @param prompt_version_id [Boolean] If enabled, the response will include the ID of the Prompt Version backing the deployment.
+    # @param finish_reason [Boolean] If enabled, the response will include the reason provided by the model for why the execution finished.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [PromptDeploymentExpandMetaRequestRequest]
+    def initialize(model_name: nil, latency: nil, deployment_release_tag: nil, prompt_version_id: nil,
+                   finish_reason: nil, additional_properties: nil)
+      # @type [Boolean] If enabled, the response will include the model identifier representing the ML Model invoked by the Prompt Deployment.
+      @model_name = model_name
+      # @type [Boolean] If enabled, the response will include the time in nanoseconds it took to execute the Prompt Deployment.
+      @latency = latency
+      # @type [Boolean] If enabled, the response will include the release tag of the Prompt Deployment.
+      @deployment_release_tag = deployment_release_tag
+      # @type [Boolean] If enabled, the response will include the ID of the Prompt Version backing the deployment.
+      @prompt_version_id = prompt_version_id
+      # @type [Boolean] If enabled, the response will include the reason provided by the model for why the execution finished.
+      @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 PromptDeploymentExpandMetaRequestRequest
+    #
+    # @param json_object [JSON]
+    # @return [PromptDeploymentExpandMetaRequestRequest]
+    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
+      finish_reason = struct.finish_reason
+      new(model_name: model_name, latency: latency, deployment_release_tag: deployment_release_tag,
+          prompt_version_id: prompt_version_id, finish_reason: finish_reason, additional_properties: struct)
+    end
+
+    # Serialize an instance of PromptDeploymentExpandMetaRequestRequest 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,
+        "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.model_name&.is_a?(Boolean) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
+      obj.latency&.is_a?(Boolean) != false || raise("Passed value for field obj.latency is not the expected type, validation failed.")
+      obj.deployment_release_tag&.is_a?(Boolean) != false || raise("Passed value for field obj.deployment_release_tag is not the expected type, validation failed.")
+      obj.prompt_version_id&.is_a?(Boolean) != false || raise("Passed value for field obj.prompt_version_id is not the expected type, validation failed.")
+      obj.finish_reason&.is_a?(Boolean) != false || raise("Passed value for field obj.finish_reason is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_deployment_input_request.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "string_input_request"
+require_relative "json_input_request"
+require_relative "chat_history_input_request"
+
+module Vellum
+  class PromptDeploymentInputRequest
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [PromptDeploymentInputRequest]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of PromptDeploymentInputRequest
+    #
+    # @param json_object [JSON]
+    # @return [PromptDeploymentInputRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 StringInputRequest.from_json(json_object: json_object)
+               when "JSON"
+                 JsonInputRequest.from_json(json_object: json_object)
+               when "CHAT_HISTORY"
+                 ChatHistoryInputRequest.from_json(json_object: json_object)
+               else
+                 StringInputRequest.from_json(json_object: json_object)
+               end
+      new(member: member, discriminant: struct.type)
+    end
+
+    # For Union Types, to_json functionality is delegated to the wrapped member.
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      case @discriminant
+      when "STRING"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "JSON"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "CHAT_HISTORY"
+        { **@member.to_json, type: @discriminant }.to_json
+      else
+        { "type": @discriminant, value: @member }.to_json
+      end
+      @member.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:)
+      case obj.type
+      when "STRING"
+        StringInputRequest.validate_raw(obj: obj)
+      when "JSON"
+        JsonInputRequest.validate_raw(obj: obj)
+      when "CHAT_HISTORY"
+        ChatHistoryInputRequest.validate_raw(obj: obj)
+      else
+        raise("Passed value matched no type within the union, validation failed.")
+      end
+    end
+
+    # For Union Types, is_a? functionality is delegated to the wrapped member.
+    #
+    # @param obj [Object]
+    # @return [Boolean]
+    def is_a?(obj)
+      @member.is_a?(obj)
+    end
+
+    # @param member [StringInputRequest]
+    # @return [PromptDeploymentInputRequest]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [JsonInputRequest]
+    # @return [PromptDeploymentInputRequest]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [ChatHistoryInputRequest]
+    # @return [PromptDeploymentInputRequest]
+    def self.chat_history(member:)
+      new(member: member, discriminant: "CHAT_HISTORY")
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_execution_meta.rb

@@ -0,0 +1,76 @@
+# 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 PromptExecutionMeta
+    attr_reader :model_name, :latency, :deployment_release_tag, :prompt_version_id, :finish_reason,
+                :additional_properties
+
+    # @param model_name [String]
+    # @param latency [Integer]
+    # @param deployment_release_tag [String]
+    # @param prompt_version_id [String]
+    # @param finish_reason [FINISH_REASON_ENUM]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [PromptExecutionMeta]
+    def initialize(model_name: nil, latency: nil, deployment_release_tag: nil, prompt_version_id: nil,
+                   finish_reason: 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 [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 PromptExecutionMeta
+    #
+    # @param json_object [JSON]
+    # @return [PromptExecutionMeta]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = 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
+      finish_reason = FINISH_REASON_ENUM.key(parsed_json["finish_reason"]) || parsed_json["finish_reason"]
+      new(model_name: model_name, latency: latency, deployment_release_tag: deployment_release_tag,
+          prompt_version_id: prompt_version_id, finish_reason: finish_reason, additional_properties: struct)
+    end
+
+    # Serialize an instance of PromptExecutionMeta 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,
+        "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.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.")
+      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/prompt_node_result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "prompt_node_result_data"
+require "json"
+
+module Vellum
+  # A Node Result Event emitted from a Prompt Node.
+  class PromptNodeResult
+    attr_reader :data, :additional_properties
+
+    # @param data [PromptNodeResultData]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [PromptNodeResult]
+    def initialize(data:, additional_properties: nil)
+      # @type [PromptNodeResultData]
+      @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 PromptNodeResult
+    #
+    # @param json_object [JSON]
+    # @return [PromptNodeResult]
+    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 = PromptNodeResultData.from_json(json_object: data)
+      end
+      new(data: data, additional_properties: struct)
+    end
+
+    # Serialize an instance of PromptNodeResult 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:)
+      PromptNodeResultData.validate_raw(obj: obj.data)
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_node_result_data.rb

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

data/lib/vellum_ai/types/prompt_output.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "string_variable_value"
+require_relative "json_variable_value"
+require_relative "error_variable_value"
+require_relative "function_call_variable_value"
+
+module Vellum
+  class PromptOutput
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [PromptOutput]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of PromptOutput
+    #
+    # @param json_object [JSON]
+    # @return [PromptOutput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 StringVariableValue.from_json(json_object: json_object)
+               when "JSON"
+                 JsonVariableValue.from_json(json_object: json_object)
+               when "ERROR"
+                 ErrorVariableValue.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 FunctionCallVariableValue.from_json(json_object: json_object)
+               else
+                 StringVariableValue.from_json(json_object: json_object)
+               end
+      new(member: member, discriminant: struct.type)
+    end
+
+    # For Union Types, to_json functionality is delegated to the wrapped member.
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      case @discriminant
+      when "STRING"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "JSON"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "ERROR"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "FUNCTION_CALL"
+        { **@member.to_json, type: @discriminant }.to_json
+      else
+        { "type": @discriminant, value: @member }.to_json
+      end
+      @member.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:)
+      case obj.type
+      when "STRING"
+        StringVariableValue.validate_raw(obj: obj)
+      when "JSON"
+        JsonVariableValue.validate_raw(obj: obj)
+      when "ERROR"
+        ErrorVariableValue.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        FunctionCallVariableValue.validate_raw(obj: obj)
+      else
+        raise("Passed value matched no type within the union, validation failed.")
+      end
+    end
+
+    # For Union Types, is_a? functionality is delegated to the wrapped member.
+    #
+    # @param obj [Object]
+    # @return [Boolean]
+    def is_a?(obj)
+      @member.is_a?(obj)
+    end
+
+    # @param member [StringVariableValue]
+    # @return [PromptOutput]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [JsonVariableValue]
+    # @return [PromptOutput]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [ErrorVariableValue]
+    # @return [PromptOutput]
+    def self.error(member:)
+      new(member: member, discriminant: "ERROR")
+    end
+
+    # @param member [FunctionCallVariableValue]
+    # @return [PromptOutput]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_template_block.rb

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

data/lib/vellum_ai/types/prompt_template_block_data.rb

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

data/lib/vellum_ai/types/prompt_template_block_data_request.rb

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