vellum_ai 0.3.4

data/lib/vellum_ai/types/workflow_node_result_data.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "prompt_node_result"
+require_relative "search_node_result"
+require_relative "templating_node_result"
+require_relative "code_execution_node_result"
+require_relative "conditional_node_result"
+require_relative "api_node_result"
+require_relative "terminal_node_result"
+
+module Vellum
+  class WorkflowNodeResultData
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [WorkflowNodeResultData]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of WorkflowNodeResultData
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowNodeResultData]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "PROMPT"
+                 PromptNodeResult.from_json(json_object: json_object)
+               when "SEARCH"
+                 SearchNodeResult.from_json(json_object: json_object)
+               when "TEMPLATING"
+                 TemplatingNodeResult.from_json(json_object: json_object)
+               when "CODE_EXECUTION"
+                 CodeExecutionNodeResult.from_json(json_object: json_object)
+               when "CONDITIONAL"
+                 ConditionalNodeResult.from_json(json_object: json_object)
+               when "API"
+                 ApiNodeResult.from_json(json_object: json_object)
+               when "TERMINAL"
+                 TerminalNodeResult.from_json(json_object: json_object)
+               else
+                 PromptNodeResult.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 "PROMPT"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "SEARCH"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "TEMPLATING"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "CODE_EXECUTION"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "CONDITIONAL"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "API"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "TERMINAL"
+        { **@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 "PROMPT"
+        PromptNodeResult.validate_raw(obj: obj)
+      when "SEARCH"
+        SearchNodeResult.validate_raw(obj: obj)
+      when "TEMPLATING"
+        TemplatingNodeResult.validate_raw(obj: obj)
+      when "CODE_EXECUTION"
+        CodeExecutionNodeResult.validate_raw(obj: obj)
+      when "CONDITIONAL"
+        ConditionalNodeResult.validate_raw(obj: obj)
+      when "API"
+        ApiNodeResult.validate_raw(obj: obj)
+      when "TERMINAL"
+        TerminalNodeResult.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 [PromptNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.prompt(member:)
+      new(member: member, discriminant: "PROMPT")
+    end
+
+    # @param member [SearchNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.search(member:)
+      new(member: member, discriminant: "SEARCH")
+    end
+
+    # @param member [TemplatingNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.templating(member:)
+      new(member: member, discriminant: "TEMPLATING")
+    end
+
+    # @param member [CodeExecutionNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.code_execution(member:)
+      new(member: member, discriminant: "CODE_EXECUTION")
+    end
+
+    # @param member [ConditionalNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.conditional(member:)
+      new(member: member, discriminant: "CONDITIONAL")
+    end
+
+    # @param member [ApiNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.api(member:)
+      new(member: member, discriminant: "API")
+    end
+
+    # @param member [TerminalNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.terminal(member:)
+      new(member: member, discriminant: "TERMINAL")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_node_result_event.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "initiated_workflow_node_result_event"
+require_relative "streaming_workflow_node_result_event"
+require_relative "fulfilled_workflow_node_result_event"
+require_relative "rejected_workflow_node_result_event"
+
+module Vellum
+  class WorkflowNodeResultEvent
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [WorkflowNodeResultEvent]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of WorkflowNodeResultEvent
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowNodeResultEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.state
+               when "INITIATED"
+                 InitiatedWorkflowNodeResultEvent.from_json(json_object: json_object)
+               when "STREAMING"
+                 StreamingWorkflowNodeResultEvent.from_json(json_object: json_object)
+               when "FULFILLED"
+                 FulfilledWorkflowNodeResultEvent.from_json(json_object: json_object)
+               when "REJECTED"
+                 RejectedWorkflowNodeResultEvent.from_json(json_object: json_object)
+               else
+                 InitiatedWorkflowNodeResultEvent.from_json(json_object: json_object)
+               end
+      new(member: member, discriminant: struct.state)
+    end
+
+    # For Union Types, to_json functionality is delegated to the wrapped member.
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      case @discriminant
+      when "INITIATED"
+        { **@member.to_json, state: @discriminant }.to_json
+      when "STREAMING"
+        { **@member.to_json, state: @discriminant }.to_json
+      when "FULFILLED"
+        { **@member.to_json, state: @discriminant }.to_json
+      when "REJECTED"
+        { **@member.to_json, state: @discriminant }.to_json
+      else
+        { "state": @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.state
+      when "INITIATED"
+        InitiatedWorkflowNodeResultEvent.validate_raw(obj: obj)
+      when "STREAMING"
+        StreamingWorkflowNodeResultEvent.validate_raw(obj: obj)
+      when "FULFILLED"
+        FulfilledWorkflowNodeResultEvent.validate_raw(obj: obj)
+      when "REJECTED"
+        RejectedWorkflowNodeResultEvent.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 [InitiatedWorkflowNodeResultEvent]
+    # @return [WorkflowNodeResultEvent]
+    def self.initiated(member:)
+      new(member: member, discriminant: "INITIATED")
+    end
+
+    # @param member [StreamingWorkflowNodeResultEvent]
+    # @return [WorkflowNodeResultEvent]
+    def self.streaming(member:)
+      new(member: member, discriminant: "STREAMING")
+    end
+
+    # @param member [FulfilledWorkflowNodeResultEvent]
+    # @return [WorkflowNodeResultEvent]
+    def self.fulfilled(member:)
+      new(member: member, discriminant: "FULFILLED")
+    end
+
+    # @param member [RejectedWorkflowNodeResultEvent]
+    # @return [WorkflowNodeResultEvent]
+    def self.rejected(member:)
+      new(member: member, discriminant: "REJECTED")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_node_result_event_state.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [WORKFLOW_NODE_RESULT_EVENT_STATE]
+  WORKFLOW_NODE_RESULT_EVENT_STATE = {
+    initiated: "INITIATED",
+    streaming: "STREAMING",
+    fulfilled: "FULFILLED",
+    rejected: "REJECTED"
+  }.freeze
+end

data/lib/vellum_ai/types/workflow_output.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "workflow_output_string"
+require_relative "workflow_output_number"
+require_relative "workflow_output_json"
+require_relative "workflow_output_chat_history"
+require_relative "workflow_output_search_results"
+require_relative "workflow_output_error"
+require_relative "workflow_output_function_call"
+require_relative "workflow_output_image"
+
+module Vellum
+  class WorkflowOutput
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [WorkflowOutput]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of WorkflowOutput
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowOutput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 WorkflowOutputString.from_json(json_object: json_object)
+               when "NUMBER"
+                 WorkflowOutputNumber.from_json(json_object: json_object)
+               when "JSON"
+                 WorkflowOutputJson.from_json(json_object: json_object)
+               when "CHAT_HISTORY"
+                 WorkflowOutputChatHistory.from_json(json_object: json_object)
+               when "SEARCH_RESULTS"
+                 WorkflowOutputSearchResults.from_json(json_object: json_object)
+               when "ERROR"
+                 WorkflowOutputError.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 WorkflowOutputFunctionCall.from_json(json_object: json_object)
+               when "IMAGE"
+                 WorkflowOutputImage.from_json(json_object: json_object)
+               else
+                 WorkflowOutputString.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 "NUMBER"
+        { **@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
+      when "SEARCH_RESULTS"
+        { **@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
+      when "IMAGE"
+        { **@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"
+        WorkflowOutputString.validate_raw(obj: obj)
+      when "NUMBER"
+        WorkflowOutputNumber.validate_raw(obj: obj)
+      when "JSON"
+        WorkflowOutputJson.validate_raw(obj: obj)
+      when "CHAT_HISTORY"
+        WorkflowOutputChatHistory.validate_raw(obj: obj)
+      when "SEARCH_RESULTS"
+        WorkflowOutputSearchResults.validate_raw(obj: obj)
+      when "ERROR"
+        WorkflowOutputError.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        WorkflowOutputFunctionCall.validate_raw(obj: obj)
+      when "IMAGE"
+        WorkflowOutputImage.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 [WorkflowOutputString]
+    # @return [WorkflowOutput]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [WorkflowOutputNumber]
+    # @return [WorkflowOutput]
+    def self.number(member:)
+      new(member: member, discriminant: "NUMBER")
+    end
+
+    # @param member [WorkflowOutputJson]
+    # @return [WorkflowOutput]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [WorkflowOutputChatHistory]
+    # @return [WorkflowOutput]
+    def self.chat_history(member:)
+      new(member: member, discriminant: "CHAT_HISTORY")
+    end
+
+    # @param member [WorkflowOutputSearchResults]
+    # @return [WorkflowOutput]
+    def self.search_results(member:)
+      new(member: member, discriminant: "SEARCH_RESULTS")
+    end
+
+    # @param member [WorkflowOutputError]
+    # @return [WorkflowOutput]
+    def self.error(member:)
+      new(member: member, discriminant: "ERROR")
+    end
+
+    # @param member [WorkflowOutputFunctionCall]
+    # @return [WorkflowOutput]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
+
+    # @param member [WorkflowOutputImage]
+    # @return [WorkflowOutput]
+    def self.image(member:)
+      new(member: member, discriminant: "IMAGE")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_output_chat_history.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "chat_message"
+require "json"
+
+module Vellum
+  # A chat history output from a Workflow execution.
+  class WorkflowOutputChatHistory
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String]
+    # @param name [String] The output's name, as defined in the workflow
+    # @param value [Array<ChatMessage>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [WorkflowOutputChatHistory]
+    def initialize(id:, name:, value:, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The output's name, as defined in the workflow
+      @name = name
+      # @type [Array<ChatMessage>]
+      @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 WorkflowOutputChatHistory
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowOutputChatHistory]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      value = parsed_json["value"].map do |v|
+        v = v.to_json
+        ChatMessage.from_json(json_object: v)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of WorkflowOutputChatHistory to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "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:)
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.value.is_a?(Array) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_output_error.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "vellum_error"
+require "json"
+
+module Vellum
+  # An error output from a Workflow execution.
+  class WorkflowOutputError
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String]
+    # @param name [String] The output's name, as defined in the workflow
+    # @param value [VellumError]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [WorkflowOutputError]
+    def initialize(id:, name:, value:, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The output's name, as defined in the workflow
+      @name = name
+      # @type [VellumError]
+      @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 WorkflowOutputError
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowOutputError]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = VellumError.from_json(json_object: value)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of WorkflowOutputError to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "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:)
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      VellumError.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_output_function_call.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "function_call"
+require "json"
+
+module Vellum
+  # A function call output from a Workflow execution.
+  class WorkflowOutputFunctionCall
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String]
+    # @param name [String] The output's name, as defined in the workflow
+    # @param value [FunctionCall]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [WorkflowOutputFunctionCall]
+    def initialize(id:, name:, value:, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The output's name, as defined in the workflow
+      @name = name
+      # @type [FunctionCall]
+      @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 WorkflowOutputFunctionCall
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowOutputFunctionCall]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = FunctionCall.from_json(json_object: value)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of WorkflowOutputFunctionCall to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "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:)
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      FunctionCall.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_output_image.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "vellum_image"
+require "json"
+
+module Vellum
+  # An image output from a Workflow execution.
+  class WorkflowOutputImage
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String]
+    # @param name [String] The output's name, as defined in the workflow
+    # @param value [VellumImage]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [WorkflowOutputImage]
+    def initialize(id:, name:, value:, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The output's name, as defined in the workflow
+      @name = name
+      # @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 WorkflowOutputImage
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowOutputImage]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = VellumImage.from_json(json_object: value)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of WorkflowOutputImage to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "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:)
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      VellumImage.validate_raw(obj: obj.value)
+    end
+  end
+end