vellum_ai 0.3.15 → 0.14.75

data/lib/vellum_ai/types/document_index_read.rb

@@ -1,98 +1,107 @@
 # frozen_string_literal: true
-
 require "date"
 require_relative "entity_status"
-require_relative "environment_enum"
+require_relative "document_index_indexing_config"
+require "ostruct"
 require "json"
 
 module Vellum
   class DocumentIndexRead
-    attr_reader :id, :created, :label, :name, :status, :environment, :indexing_config, :additional_properties
+  # @return [String] 
+    attr_reader :id
+  # @return [DateTime] 
+    attr_reader :created
+  # @return [String] A human-readable label for the document index
+    attr_reader :label
+  # @return [String] A name that uniquely identifies this index within its workspace
+    attr_reader :name
+  # @return [Vellum::EntityStatus] The current status of the document index
+#  * `ACTIVE` - Active
+#  * `ARCHIVED` - Archived
+    attr_reader :status
+  # @return [Vellum::DocumentIndexIndexingConfig] 
+    attr_reader :indexing_config
+  # @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 created [DateTime]
+    # @param id [String] 
+    # @param created [DateTime] 
     # @param label [String] A human-readable label for the document index
     # @param name [String] A name that uniquely identifies this index within its workspace
-    # @param status [ENTITY_STATUS] The current status of the document index
-    #   - `ACTIVE` - Active
-    #   - `ARCHIVED` - Archived
-    # @param environment [ENVIRONMENT_ENUM] The environment this document index is used in
-    #   - `DEVELOPMENT` - Development
-    #   - `STAGING` - Staging
-    #   - `PRODUCTION` - Production
-    # @param indexing_config [Hash{String => String}] Configuration representing how documents should be indexed
+    # @param status [Vellum::EntityStatus] The current status of the document index
+#  * `ACTIVE` - Active
+#  * `ARCHIVED` - Archived
+    # @param indexing_config [Vellum::DocumentIndexIndexingConfig] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [DocumentIndexRead]
-    def initialize(id:, created:, label:, name:, indexing_config:, status: nil, environment: nil,
-                   additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::DocumentIndexRead]
+    def initialize(id:, created:, label:, name:, status: OMIT, indexing_config:, additional_properties: nil)
       @id = id
-      # @type [DateTime]
       @created = created
-      # @type [String] A human-readable label for the document index
       @label = label
-      # @type [String] A name that uniquely identifies this index within its workspace
       @name = name
-      # @type [ENTITY_STATUS] The current status of the document index
-      #   - `ACTIVE` - Active
-      #   - `ARCHIVED` - Archived
-      @status = status
-      # @type [ENVIRONMENT_ENUM] The environment this document index is used in
-      #   - `DEVELOPMENT` - Development
-      #   - `STAGING` - Staging
-      #   - `PRODUCTION` - Production
-      @environment = environment
-      # @type [Hash{String => String}] Configuration representing how documents should be indexed
+      @status = status if status != OMIT
       @indexing_config = indexing_config
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "id": id, "created": created, "label": label, "name": name, "status": status, "indexing_config": indexing_config }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of DocumentIndexRead
+# Deserialize a JSON object to an instance of DocumentIndexRead
     #
-    # @param json_object [JSON]
-    # @return [DocumentIndexRead]
+    # @param json_object [String] 
+    # @return [Vellum::DocumentIndexRead]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      id = struct.id
-      created = DateTime.parse(parsed_json["created"])
-      label = struct.label
-      name = struct.name
-      status = ENTITY_STATUS.key(parsed_json["status"]) || parsed_json["status"]
-      environment = ENVIRONMENT_ENUM.key(parsed_json["environment"]) || parsed_json["environment"]
-      indexing_config = struct.indexing_config
-      new(id: id, created: created, label: label, name: name, status: status, environment: environment,
-          indexing_config: indexing_config, additional_properties: struct)
+      id = parsed_json["id"]
+      created = unless parsed_json["created"].nil?
+  DateTime.parse(parsed_json["created"])
+else
+  nil
+end
+      label = parsed_json["label"]
+      name = parsed_json["name"]
+      status = parsed_json["status"]
+      unless parsed_json["indexing_config"].nil?
+        indexing_config = parsed_json["indexing_config"].to_json
+        indexing_config = Vellum::DocumentIndexIndexingConfig.from_json(json_object: indexing_config)
+      else
+        indexing_config = nil
+      end
+      new(
+        id: id,
+        created: created,
+        label: label,
+        name: name,
+        status: status,
+        indexing_config: indexing_config,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of DocumentIndexRead to a JSON object
+# Serialize an instance of DocumentIndexRead to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      {
-        "id": @id,
-        "created": @created,
-        "label": @label,
-        "name": @name,
-        "status": ENTITY_STATUS[@status] || @status,
-        "environment": ENVIRONMENT_ENUM[@environment] || @environment,
-        "indexing_config": @indexing_config
-      }.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.created.is_a?(DateTime) != false || raise("Passed value for field obj.created 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.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
-      obj.status&.is_a?(ENTITY_STATUS) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
-      obj.environment&.is_a?(ENVIRONMENT_ENUM) != false || raise("Passed value for field obj.environment is not the expected type, validation failed.")
-      obj.indexing_config.is_a?(Hash) != false || raise("Passed value for field obj.indexing_config is not the expected type, validation failed.")
+      obj.status&.is_a?(Vellum::EntityStatus) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+      Vellum::DocumentIndexIndexingConfig.validate_raw(obj: obj.indexing_config)
     end
   end
-end
+end

data/lib/vellum_ai/types/document_processing_state.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Vellum
+# * `QUEUED` - Queued
+#  * `PROCESSING` - Processing
+#  * `PROCESSED` - Processed
+#  * `FAILED` - Failed
+#  * `UNKNOWN` - Unknown
+  class DocumentProcessingState
+
+    QUEUED = "QUEUED"
+    PROCESSING = "PROCESSING"
+    PROCESSED = "PROCESSED"
+    FAILED = "FAILED"
+    UNKNOWN = "UNKNOWN"
+
+  end
+end

data/lib/vellum_ai/types/document_prompt_block.rb

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

data/lib/vellum_ai/types/document_read.rb

@@ -1,121 +1,129 @@
 # frozen_string_literal: true
-
 require "date"
-require_relative "processing_state_enum"
+require_relative "document_processing_state"
 require_relative "document_status"
 require_relative "document_document_to_document_index"
+require "ostruct"
 require "json"
 
 module Vellum
   class DocumentRead
-    attr_reader :id, :external_id, :last_uploaded_at, :label, :processing_state, :status, :original_file_url,
-                :processed_file_url, :document_to_document_indexes, :metadata, :additional_properties
+  # @return [String] 
+    attr_reader :id
+  # @return [String] The unique id of this document as it exists in the user's system.
+    attr_reader :external_id
+  # @return [DateTime] 
+    attr_reader :last_uploaded_at
+  # @return [String] A human-readable label for the document. Defaults to the originally uploaded
+#  file's file name.
+    attr_reader :label
+  # @return [Vellum::DocumentProcessingState] 
+    attr_reader :processing_state
+  # @return [Vellum::DOCUMENT_STATUS] The current status of the document
+#  * `ACTIVE` - Active
+    attr_reader :status
+  # @return [String] 
+    attr_reader :original_file_url
+  # @return [Array<Vellum::DocumentDocumentToDocumentIndex>] 
+    attr_reader :document_to_document_indexes
+  # @return [Hash{String => Object}] A previously supplied JSON object containing metadata that can be filtered on
+#  when searching.
+    attr_reader :metadata
+  # @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 id [String] 
     # @param external_id [String] The unique id of this document as it exists in the user's system.
-    # @param last_uploaded_at [DateTime]
-    # @param label [String] A human-readable label for the document. Defaults to the originally uploaded file's file name.
-    # @param processing_state [PROCESSING_STATE_ENUM] The current processing state of the document
-    #   - `QUEUED` - Queued
-    #   - `PROCESSING` - Processing
-    #   - `PROCESSED` - Processed
-    #   - `FAILED` - Failed
-    # @param status [DOCUMENT_STATUS] The current status of the document
-    #   - `ACTIVE` - Active
-    # @param original_file_url [String]
-    # @param processed_file_url [String]
-    # @param document_to_document_indexes [Array<DocumentDocumentToDocumentIndex>]
-    # @param metadata [Hash{String => String}] A previously supplied JSON object containing metadata that can be filtered on when searching.
+    # @param last_uploaded_at [DateTime] 
+    # @param label [String] A human-readable label for the document. Defaults to the originally uploaded
+#  file's file name.
+    # @param processing_state [Vellum::DocumentProcessingState] 
+    # @param status [Vellum::DOCUMENT_STATUS] The current status of the document
+#  * `ACTIVE` - Active
+    # @param original_file_url [String] 
+    # @param document_to_document_indexes [Array<Vellum::DocumentDocumentToDocumentIndex>] 
+    # @param metadata [Hash{String => Object}] A previously supplied JSON object containing metadata that can be filtered on
+#  when searching.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [DocumentRead]
-    def initialize(id:, last_uploaded_at:, label:, document_to_document_indexes:, external_id: nil, processing_state: nil, status: nil,
-                   original_file_url: nil, processed_file_url: nil, metadata: nil, additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::DocumentRead]
+    def initialize(id:, external_id: OMIT, last_uploaded_at:, label:, processing_state:, status: OMIT, original_file_url: OMIT, document_to_document_indexes:, metadata: OMIT, additional_properties: nil)
       @id = id
-      # @type [String] The unique id of this document as it exists in the user's system.
-      @external_id = external_id
-      # @type [DateTime]
+      @external_id = external_id if external_id != OMIT
       @last_uploaded_at = last_uploaded_at
-      # @type [String] A human-readable label for the document. Defaults to the originally uploaded file's file name.
       @label = label
-      # @type [PROCESSING_STATE_ENUM] The current processing state of the document
-      #   - `QUEUED` - Queued
-      #   - `PROCESSING` - Processing
-      #   - `PROCESSED` - Processed
-      #   - `FAILED` - Failed
       @processing_state = processing_state
-      # @type [DOCUMENT_STATUS] The current status of the document
-      #   - `ACTIVE` - Active
-      @status = status
-      # @type [String]
-      @original_file_url = original_file_url
-      # @type [String]
-      @processed_file_url = processed_file_url
-      # @type [Array<DocumentDocumentToDocumentIndex>]
+      @status = status if status != OMIT
+      @original_file_url = original_file_url if original_file_url != OMIT
       @document_to_document_indexes = document_to_document_indexes
-      # @type [Hash{String => String}] A previously supplied JSON object containing metadata that can be filtered on when searching.
-      @metadata = metadata
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @metadata = metadata if metadata != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "id": id, "external_id": external_id, "last_uploaded_at": last_uploaded_at, "label": label, "processing_state": processing_state, "status": status, "original_file_url": original_file_url, "document_to_document_indexes": document_to_document_indexes, "metadata": metadata }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of DocumentRead
+# Deserialize a JSON object to an instance of DocumentRead
     #
-    # @param json_object [JSON]
-    # @return [DocumentRead]
+    # @param json_object [String] 
+    # @return [Vellum::DocumentRead]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      id = struct.id
-      external_id = struct.external_id
-      last_uploaded_at = DateTime.parse(parsed_json["last_uploaded_at"])
-      label = struct.label
-      processing_state = PROCESSING_STATE_ENUM.key(parsed_json["processing_state"]) || parsed_json["processing_state"]
-      status = struct.status
-      original_file_url = struct.original_file_url
-      processed_file_url = struct.processed_file_url
-      document_to_document_indexes = parsed_json["document_to_document_indexes"].map do |v|
-        v = v.to_json
-        DocumentDocumentToDocumentIndex.from_json(json_object: v)
-      end
-      metadata = struct.metadata
-      new(id: id, external_id: external_id, last_uploaded_at: last_uploaded_at, label: label,
-          processing_state: processing_state, status: status, original_file_url: original_file_url, processed_file_url: processed_file_url, document_to_document_indexes: document_to_document_indexes, metadata: metadata, additional_properties: struct)
+      id = parsed_json["id"]
+      external_id = parsed_json["external_id"]
+      last_uploaded_at = unless parsed_json["last_uploaded_at"].nil?
+  DateTime.parse(parsed_json["last_uploaded_at"])
+else
+  nil
+end
+      label = parsed_json["label"]
+      processing_state = parsed_json["processing_state"]
+      status = parsed_json["status"]
+      original_file_url = parsed_json["original_file_url"]
+      document_to_document_indexes = parsed_json["document_to_document_indexes"]&.map do | item |
+  item = item.to_json
+  Vellum::DocumentDocumentToDocumentIndex.from_json(json_object: item)
+end
+      metadata = parsed_json["metadata"]
+      new(
+        id: id,
+        external_id: external_id,
+        last_uploaded_at: last_uploaded_at,
+        label: label,
+        processing_state: processing_state,
+        status: status,
+        original_file_url: original_file_url,
+        document_to_document_indexes: document_to_document_indexes,
+        metadata: metadata,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of DocumentRead to a JSON object
+# Serialize an instance of DocumentRead to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      {
-        "id": @id,
-        "external_id": @external_id,
-        "last_uploaded_at": @last_uploaded_at,
-        "label": @label,
-        "processing_state": PROCESSING_STATE_ENUM[@processing_state] || @processing_state,
-        "status": @status,
-        "original_file_url": @original_file_url,
-        "processed_file_url": @processed_file_url,
-        "document_to_document_indexes": @document_to_document_indexes,
-        "metadata": @metadata
-      }.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.external_id&.is_a?(String) != false || raise("Passed value for field obj.external_id is not the expected type, validation failed.")
       obj.last_uploaded_at.is_a?(DateTime) != false || raise("Passed value for field obj.last_uploaded_at 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.processing_state&.is_a?(PROCESSING_STATE_ENUM) != false || raise("Passed value for field obj.processing_state is not the expected type, validation failed.")
+      obj.processing_state.is_a?(Vellum::DocumentProcessingState) != false || raise("Passed value for field obj.processing_state is not the expected type, validation failed.")
       obj.status&.is_a?(String) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
       obj.original_file_url&.is_a?(String) != false || raise("Passed value for field obj.original_file_url is not the expected type, validation failed.")
-      obj.processed_file_url&.is_a?(String) != false || raise("Passed value for field obj.processed_file_url is not the expected type, validation failed.")
       obj.document_to_document_indexes.is_a?(Array) != false || raise("Passed value for field obj.document_to_document_indexes is not the expected type, validation failed.")
       obj.metadata&.is_a?(Hash) != false || raise("Passed value for field obj.metadata is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/document_status.rb

@@ -2,4 +2,4 @@
 
 module Vellum
   DOCUMENT_STATUS = String
-end
+end

data/lib/vellum_ai/types/document_vellum_value.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require_relative "vellum_document"
+require "ostruct"
+require "json"
+
+module Vellum
+# A base Vellum primitive value representing a document.
+  class DocumentVellumValue
+  # @return [String] 
+    attr_reader :type
+  # @return [Vellum::VellumDocument] 
+    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 type [String] 
+    # @param value [Vellum::VellumDocument] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::DocumentVellumValue]
+    def initialize(type:, value: OMIT, additional_properties: nil)
+      @type = type
+      @value = value if value != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "type": type, "value": value }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of DocumentVellumValue
+    #
+    # @param json_object [String] 
+    # @return [Vellum::DocumentVellumValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      type = parsed_json["type"]
+      unless parsed_json["value"].nil?
+        value = parsed_json["value"].to_json
+        value = Vellum::VellumDocument.from_json(json_object: value)
+      else
+        value = nil
+      end
+      new(
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of DocumentVellumValue 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.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value.nil? || Vellum::VellumDocument.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/document_vellum_value_request.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require_relative "vellum_document_request"
+require "ostruct"
+require "json"
+
+module Vellum
+# A base Vellum primitive value representing a document.
+  class DocumentVellumValueRequest
+  # @return [String] 
+    attr_reader :type
+  # @return [Vellum::VellumDocumentRequest] 
+    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 type [String] 
+    # @param value [Vellum::VellumDocumentRequest] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::DocumentVellumValueRequest]
+    def initialize(type:, value: OMIT, additional_properties: nil)
+      @type = type
+      @value = value if value != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "type": type, "value": value }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of DocumentVellumValueRequest
+    #
+    # @param json_object [String] 
+    # @return [Vellum::DocumentVellumValueRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      type = parsed_json["type"]
+      unless parsed_json["value"].nil?
+        value = parsed_json["value"].to_json
+        value = Vellum::VellumDocumentRequest.from_json(json_object: value)
+      else
+        value = nil
+      end
+      new(
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of DocumentVellumValueRequest 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.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value.nil? || Vellum::VellumDocumentRequest.validate_raw(obj: obj.value)
+    end
+  end
+end