vellum_ai 0.3.14 → 0.14.74

data/lib/vellum_ai/types/initiated_prompt_execution_meta.rb

@@ -1,62 +1,73 @@
 # frozen_string_literal: true
-
+require "ostruct"
 require "json"
 
 module Vellum
-  # The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
+# 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
+  # @return [String] 
+    attr_reader :model_name
+  # @return [Integer] 
+    attr_reader :latency
+  # @return [String] 
+    attr_reader :deployment_release_tag
+  # @return [String] 
+    attr_reader :prompt_version_id
+  # @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 model_name [String]
-    # @param latency [Integer]
-    # @param deployment_release_tag [String]
-    # @param prompt_version_id [String]
+    # @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
+    # @return [Vellum::InitiatedPromptExecutionMeta]
+    def initialize(model_name: OMIT, latency: OMIT, deployment_release_tag: OMIT, prompt_version_id: OMIT, additional_properties: nil)
+      @model_name = model_name if model_name != OMIT
+      @latency = latency if latency != OMIT
+      @deployment_release_tag = deployment_release_tag if deployment_release_tag != OMIT
+      @prompt_version_id = prompt_version_id if prompt_version_id != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "model_name": model_name, "latency": latency, "deployment_release_tag": deployment_release_tag, "prompt_version_id": prompt_version_id }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of InitiatedPromptExecutionMeta
+# Deserialize a JSON object to an instance of InitiatedPromptExecutionMeta
     #
-    # @param json_object [JSON]
-    # @return [InitiatedPromptExecutionMeta]
+    # @param json_object [String] 
+    # @return [Vellum::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)
+      parsed_json = JSON.parse(json_object)
+      model_name = parsed_json["model_name"]
+      latency = parsed_json["latency"]
+      deployment_release_tag = parsed_json["deployment_release_tag"]
+      prompt_version_id = parsed_json["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
+# 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
+    # @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.model_name&.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
@@ -65,4 +76,4 @@ module Vellum
       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
+end

data/lib/vellum_ai/types/initiated_workflow_node_result_event.rb

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

data/lib/vellum_ai/types/instructor_vectorizer_config.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# Configuration for using an Instructor vectorizer.
+  class InstructorVectorizerConfig
+  # @return [String] 
+    attr_reader :instruction_domain
+  # @return [String] 
+    attr_reader :instruction_query_text_type
+  # @return [String] 
+    attr_reader :instruction_document_text_type
+  # @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 instruction_domain [String] 
+    # @param instruction_query_text_type [String] 
+    # @param instruction_document_text_type [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::InstructorVectorizerConfig]
+    def initialize(instruction_domain:, instruction_query_text_type:, instruction_document_text_type:, additional_properties: nil)
+      @instruction_domain = instruction_domain
+      @instruction_query_text_type = instruction_query_text_type
+      @instruction_document_text_type = instruction_document_text_type
+      @additional_properties = additional_properties
+      @_field_set = { "instruction_domain": instruction_domain, "instruction_query_text_type": instruction_query_text_type, "instruction_document_text_type": instruction_document_text_type }
+    end
+# Deserialize a JSON object to an instance of InstructorVectorizerConfig
+    #
+    # @param json_object [String] 
+    # @return [Vellum::InstructorVectorizerConfig]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      instruction_domain = parsed_json["instruction_domain"]
+      instruction_query_text_type = parsed_json["instruction_query_text_type"]
+      instruction_document_text_type = parsed_json["instruction_document_text_type"]
+      new(
+        instruction_domain: instruction_domain,
+        instruction_query_text_type: instruction_query_text_type,
+        instruction_document_text_type: instruction_document_text_type,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of InstructorVectorizerConfig 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.instruction_domain.is_a?(String) != false || raise("Passed value for field obj.instruction_domain is not the expected type, validation failed.")
+      obj.instruction_query_text_type.is_a?(String) != false || raise("Passed value for field obj.instruction_query_text_type is not the expected type, validation failed.")
+      obj.instruction_document_text_type.is_a?(String) != false || raise("Passed value for field obj.instruction_document_text_type is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/instructor_vectorizer_config_request.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# Configuration for using an Instructor vectorizer.
+  class InstructorVectorizerConfigRequest
+  # @return [String] 
+    attr_reader :instruction_domain
+  # @return [String] 
+    attr_reader :instruction_query_text_type
+  # @return [String] 
+    attr_reader :instruction_document_text_type
+  # @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 instruction_domain [String] 
+    # @param instruction_query_text_type [String] 
+    # @param instruction_document_text_type [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::InstructorVectorizerConfigRequest]
+    def initialize(instruction_domain:, instruction_query_text_type:, instruction_document_text_type:, additional_properties: nil)
+      @instruction_domain = instruction_domain
+      @instruction_query_text_type = instruction_query_text_type
+      @instruction_document_text_type = instruction_document_text_type
+      @additional_properties = additional_properties
+      @_field_set = { "instruction_domain": instruction_domain, "instruction_query_text_type": instruction_query_text_type, "instruction_document_text_type": instruction_document_text_type }
+    end
+# Deserialize a JSON object to an instance of InstructorVectorizerConfigRequest
+    #
+    # @param json_object [String] 
+    # @return [Vellum::InstructorVectorizerConfigRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      instruction_domain = parsed_json["instruction_domain"]
+      instruction_query_text_type = parsed_json["instruction_query_text_type"]
+      instruction_document_text_type = parsed_json["instruction_document_text_type"]
+      new(
+        instruction_domain: instruction_domain,
+        instruction_query_text_type: instruction_query_text_type,
+        instruction_document_text_type: instruction_document_text_type,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of InstructorVectorizerConfigRequest 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.instruction_domain.is_a?(String) != false || raise("Passed value for field obj.instruction_domain is not the expected type, validation failed.")
+      obj.instruction_query_text_type.is_a?(String) != false || raise("Passed value for field obj.instruction_query_text_type is not the expected type, validation failed.")
+      obj.instruction_document_text_type.is_a?(String) != false || raise("Passed value for field obj.instruction_document_text_type is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/invoked_port.rb

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

data/lib/vellum_ai/types/iteration_state_enum.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Vellum
+# * `INITIATED` - INITIATED
+#  * `FULFILLED` - FULFILLED
+#  * `REJECTED` - REJECTED
+  class IterationStateEnum
+
+    INITIATED = "INITIATED"
+    FULFILLED = "FULFILLED"
+    REJECTED = "REJECTED"
+
+  end
+end

data/lib/vellum_ai/types/jinja_prompt_block.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require_relative "prompt_block_state"
+require_relative "ephemeral_prompt_cache_config"
+require "ostruct"
+require "json"
+
+module Vellum
+# A block of Jinja template code that is used to generate a prompt
+  class JinjaPromptBlock
+  # @return [String] 
+    attr_reader :block_type
+  # @return [Vellum::PromptBlockState] 
+    attr_reader :state
+  # @return [Vellum::EphemeralPromptCacheConfig] 
+    attr_reader :cache_config
+  # @return [String] 
+    attr_reader :template
+  # @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 block_type [String] 
+    # @param state [Vellum::PromptBlockState] 
+    # @param cache_config [Vellum::EphemeralPromptCacheConfig] 
+    # @param template [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::JinjaPromptBlock]
+    def initialize(block_type:, state: OMIT, cache_config: OMIT, template:, additional_properties: nil)
+      @block_type = block_type
+      @state = state if state != OMIT
+      @cache_config = cache_config if cache_config != OMIT
+      @template = template
+      @additional_properties = additional_properties
+      @_field_set = { "block_type": block_type, "state": state, "cache_config": cache_config, "template": template }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of JinjaPromptBlock
+    #
+    # @param json_object [String] 
+    # @return [Vellum::JinjaPromptBlock]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      block_type = parsed_json["block_type"]
+      state = parsed_json["state"]
+      unless parsed_json["cache_config"].nil?
+        cache_config = parsed_json["cache_config"].to_json
+        cache_config = Vellum::EphemeralPromptCacheConfig.from_json(json_object: cache_config)
+      else
+        cache_config = nil
+      end
+      template = parsed_json["template"]
+      new(
+        block_type: block_type,
+        state: state,
+        cache_config: cache_config,
+        template: template,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of JinjaPromptBlock 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.block_type.is_a?(String) != false || raise("Passed value for field obj.block_type is not the expected type, validation failed.")
+      obj.state&.is_a?(Vellum::PromptBlockState) != false || raise("Passed value for field obj.state is not the expected type, validation failed.")
+      obj.cache_config.nil? || Vellum::EphemeralPromptCacheConfig.validate_raw(obj: obj.cache_config)
+      obj.template.is_a?(String) != false || raise("Passed value for field obj.template is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/json_input.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# A user input representing a JSON object
+  class JsonInput
+  # @return [String] The variable's name
+    attr_reader :name
+  # @return [String] 
+    attr_reader :type
+  # @return [Object] 
+    attr_reader :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 name [String] The variable's name
+    # @param type [String] 
+    # @param value [Object] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::JsonInput]
+    def initialize(name:, type:, value:, additional_properties: nil)
+      @name = name
+      @type = type
+      @value = value
+      @additional_properties = additional_properties
+      @_field_set = { "name": name, "type": type, "value": value }
+    end
+# Deserialize a JSON object to an instance of JsonInput
+    #
+    # @param json_object [String] 
+    # @return [Vellum::JsonInput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      name = parsed_json["name"]
+      type = parsed_json["type"]
+      value = parsed_json["value"]
+      new(
+        name: name,
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of JsonInput 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.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value.is_a?(Object) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end