vellum_ai 0.3.4

data/lib/vellum_ai/types/test_case_error_variable_value.rb

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

data/lib/vellum_ai/types/test_case_json_variable_value.rb

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

data/lib/vellum_ai/types/test_case_number_variable_value.rb

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

data/lib/vellum_ai/types/test_case_search_results_variable_value.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "search_result"
+require "json"
+
+module Vellum
+  class TestCaseSearchResultsVariableValue
+    attr_reader :variable_id, :value, :additional_properties
+
+    # @param variable_id [String]
+    # @param value [Array<SearchResult>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [TestCaseSearchResultsVariableValue]
+    def initialize(variable_id:, value: nil, additional_properties: nil)
+      # @type [String]
+      @variable_id = variable_id
+      # @type [Array<SearchResult>]
+      @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 TestCaseSearchResultsVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [TestCaseSearchResultsVariableValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      variable_id = struct.variable_id
+      value = parsed_json["value"].map do |v|
+        v = v.to_json
+        SearchResult.from_json(json_object: v)
+      end
+      new(variable_id: variable_id, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of TestCaseSearchResultsVariableValue to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "variable_id": @variable_id, "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.variable_id.is_a?(String) != false || raise("Passed value for field obj.variable_id 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/test_case_string_variable_value.rb

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

data/lib/vellum_ai/types/test_case_variable_value.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "test_case_string_variable_value"
+require_relative "test_case_number_variable_value"
+require_relative "test_case_json_variable_value"
+require_relative "test_case_chat_history_variable_value"
+require_relative "test_case_search_results_variable_value"
+require_relative "test_case_error_variable_value"
+
+module Vellum
+  class TestCaseVariableValue
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [TestCaseVariableValue]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of TestCaseVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [TestCaseVariableValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 TestCaseStringVariableValue.from_json(json_object: json_object)
+               when "NUMBER"
+                 TestCaseNumberVariableValue.from_json(json_object: json_object)
+               when "JSON"
+                 TestCaseJsonVariableValue.from_json(json_object: json_object)
+               when "CHAT_HISTORY"
+                 TestCaseChatHistoryVariableValue.from_json(json_object: json_object)
+               when "SEARCH_RESULTS"
+                 TestCaseSearchResultsVariableValue.from_json(json_object: json_object)
+               when "ERROR"
+                 TestCaseErrorVariableValue.from_json(json_object: json_object)
+               else
+                 TestCaseStringVariableValue.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
+      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"
+        TestCaseStringVariableValue.validate_raw(obj: obj)
+      when "NUMBER"
+        TestCaseNumberVariableValue.validate_raw(obj: obj)
+      when "JSON"
+        TestCaseJsonVariableValue.validate_raw(obj: obj)
+      when "CHAT_HISTORY"
+        TestCaseChatHistoryVariableValue.validate_raw(obj: obj)
+      when "SEARCH_RESULTS"
+        TestCaseSearchResultsVariableValue.validate_raw(obj: obj)
+      when "ERROR"
+        TestCaseErrorVariableValue.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 [TestCaseStringVariableValue]
+    # @return [TestCaseVariableValue]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [TestCaseNumberVariableValue]
+    # @return [TestCaseVariableValue]
+    def self.number(member:)
+      new(member: member, discriminant: "NUMBER")
+    end
+
+    # @param member [TestCaseJsonVariableValue]
+    # @return [TestCaseVariableValue]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [TestCaseChatHistoryVariableValue]
+    # @return [TestCaseVariableValue]
+    def self.chat_history(member:)
+      new(member: member, discriminant: "CHAT_HISTORY")
+    end
+
+    # @param member [TestCaseSearchResultsVariableValue]
+    # @return [TestCaseVariableValue]
+    def self.search_results(member:)
+      new(member: member, discriminant: "SEARCH_RESULTS")
+    end
+
+    # @param member [TestCaseErrorVariableValue]
+    # @return [TestCaseVariableValue]
+    def self.error(member:)
+      new(member: member, discriminant: "ERROR")
+    end
+  end
+end

data/lib/vellum_ai/types/test_suite_test_case.rb

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

data/lib/vellum_ai/types/upload_document_error_response.rb

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

data/lib/vellum_ai/types/upload_document_response.rb

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

data/lib/vellum_ai/types/vellum_error.rb

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

data/lib/vellum_ai/types/vellum_error_code_enum.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [VELLUM_ERROR_CODE_ENUM]
+  VELLUM_ERROR_CODE_ENUM = {
+    invalid_request: "INVALID_REQUEST",
+    provider_error: "PROVIDER_ERROR",
+    internal_server_error: "INTERNAL_SERVER_ERROR"
+  }.freeze
+end

data/lib/vellum_ai/types/vellum_error_request.rb

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