vellum_ai 0.3.4

data/lib/vellum_ai/types/json_enum.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vellum
+  JSON_ENUM = String
+end

data/lib/vellum_ai/types/json_input_request.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  # A user input representing a JSON object
+  class JsonInputRequest
+    attr_reader :name, :value, :additional_properties
+
+    # @param name [String] The variable's name, as defined in the deployment.
+    # @param value [Hash{String => String}]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [JsonInputRequest]
+    def initialize(name:, value:, additional_properties: nil)
+      # @type [String] The variable's name, as defined in the deployment.
+      @name = name
+      # @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 JsonInputRequest
+    #
+    # @param json_object [JSON]
+    # @return [JsonInputRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      name = struct.name
+      value = struct.value
+      new(name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of JsonInputRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "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.name.is_a?(String) != false || raise("Passed value for field obj.name 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/json_variable_value.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class JsonVariableValue
+    attr_reader :value, :additional_properties
+
+    # @param value [Hash{String => String}]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [JsonVariableValue]
+    def initialize(value: nil, additional_properties: nil)
+      # @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 JsonVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [JsonVariableValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      value = struct.value
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of JsonVariableValue to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "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.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/logical_operator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [LOGICAL_OPERATOR]
+  LOGICAL_OPERATOR = {
+    equals: "=",
+    does_not_equal: "!=",
+    less_than: "<",
+    greater_than: ">",
+    less_than_or_equal_to: "<=",
+    greater_than_or_equal_to: ">=",
+    contains: "contains",
+    begins_with: "beginsWith",
+    ends_with: "endsWith",
+    does_not_contain: "doesNotContain",
+    does_not_begin_with: "doesNotBeginWith",
+    does_not_end_with: "doesNotEndWith",
+    null: "null",
+    not_null: "notNull",
+    in_: "in",
+    not_in: "notIn",
+    between: "between",
+    not_between: "notBetween"
+  }.freeze
+end

data/lib/vellum_ai/types/logprobs_enum.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [LOGPROBS_ENUM]
+  LOGPROBS_ENUM = { all: "ALL", none: "NONE" }.freeze
+end

data/lib/vellum_ai/types/metadata_filter_config_request.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "metadata_filter_rule_combinator"
+require_relative "metadata_filter_rule_request"
+require_relative "logical_operator"
+require "json"
+
+module Vellum
+  class MetadataFilterConfigRequest
+    attr_reader :combinator, :negated, :rules, :field, :operator, :value, :additional_properties
+
+    # @param combinator [METADATA_FILTER_RULE_COMBINATOR]
+    # @param negated [Boolean]
+    # @param rules [Array<MetadataFilterRuleRequest>]
+    # @param field [String]
+    # @param operator [LOGICAL_OPERATOR]
+    # @param value [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [MetadataFilterConfigRequest]
+    def initialize(combinator: nil, negated: nil, rules: nil, field: nil, operator: nil, value: nil,
+                   additional_properties: nil)
+      # @type [METADATA_FILTER_RULE_COMBINATOR]
+      @combinator = combinator
+      # @type [Boolean]
+      @negated = negated
+      # @type [Array<MetadataFilterRuleRequest>]
+      @rules = rules
+      # @type [String]
+      @field = field
+      # @type [LOGICAL_OPERATOR]
+      @operator = operator
+      # @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 MetadataFilterConfigRequest
+    #
+    # @param json_object [JSON]
+    # @return [MetadataFilterConfigRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      combinator = METADATA_FILTER_RULE_COMBINATOR.key(parsed_json["combinator"]) || parsed_json["combinator"]
+      negated = struct.negated
+      rules = parsed_json["rules"].map do |v|
+        v = v.to_json
+        MetadataFilterRuleRequest.from_json(json_object: v)
+      end
+      field = struct.field
+      operator = LOGICAL_OPERATOR.key(parsed_json["operator"]) || parsed_json["operator"]
+      value = struct.value
+      new(combinator: combinator, negated: negated, rules: rules, field: field, operator: operator, value: value,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of MetadataFilterConfigRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "combinator": METADATA_FILTER_RULE_COMBINATOR[@combinator] || @combinator,
+        "negated": @negated,
+        "rules": @rules,
+        "field": @field,
+        "operator": LOGICAL_OPERATOR[@operator] || @operator,
+        "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.combinator&.is_a?(METADATA_FILTER_RULE_COMBINATOR) != false || raise("Passed value for field obj.combinator is not the expected type, validation failed.")
+      obj.negated&.is_a?(Boolean) != false || raise("Passed value for field obj.negated is not the expected type, validation failed.")
+      obj.rules&.is_a?(Array) != false || raise("Passed value for field obj.rules is not the expected type, validation failed.")
+      obj.field&.is_a?(String) != false || raise("Passed value for field obj.field is not the expected type, validation failed.")
+      obj.operator&.is_a?(LOGICAL_OPERATOR) != false || raise("Passed value for field obj.operator 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/metadata_filter_rule_combinator.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [METADATA_FILTER_RULE_COMBINATOR]
+  METADATA_FILTER_RULE_COMBINATOR = { and_: "and", or_: "or" }.freeze
+end

data/lib/vellum_ai/types/metadata_filter_rule_request.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "metadata_filter_rule_combinator"
+require_relative "logical_operator"
+require "json"
+
+module Vellum
+  class MetadataFilterRuleRequest
+    attr_reader :combinator, :negated, :rules, :field, :operator, :value, :additional_properties
+
+    # @param combinator [METADATA_FILTER_RULE_COMBINATOR]
+    # @param negated [Boolean]
+    # @param rules [Array<MetadataFilterRuleRequest>]
+    # @param field [String]
+    # @param operator [LOGICAL_OPERATOR]
+    # @param value [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [MetadataFilterRuleRequest]
+    def initialize(combinator: nil, negated: nil, rules: nil, field: nil, operator: nil, value: nil,
+                   additional_properties: nil)
+      # @type [METADATA_FILTER_RULE_COMBINATOR]
+      @combinator = combinator
+      # @type [Boolean]
+      @negated = negated
+      # @type [Array<MetadataFilterRuleRequest>]
+      @rules = rules
+      # @type [String]
+      @field = field
+      # @type [LOGICAL_OPERATOR]
+      @operator = operator
+      # @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 MetadataFilterRuleRequest
+    #
+    # @param json_object [JSON]
+    # @return [MetadataFilterRuleRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      combinator = METADATA_FILTER_RULE_COMBINATOR.key(parsed_json["combinator"]) || parsed_json["combinator"]
+      negated = struct.negated
+      rules = parsed_json["rules"].map do |v|
+        v = v.to_json
+        MetadataFilterRuleRequest.from_json(json_object: v)
+      end
+      field = struct.field
+      operator = LOGICAL_OPERATOR.key(parsed_json["operator"]) || parsed_json["operator"]
+      value = struct.value
+      new(combinator: combinator, negated: negated, rules: rules, field: field, operator: operator, value: value,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of MetadataFilterRuleRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "combinator": METADATA_FILTER_RULE_COMBINATOR[@combinator] || @combinator,
+        "negated": @negated,
+        "rules": @rules,
+        "field": @field,
+        "operator": LOGICAL_OPERATOR[@operator] || @operator,
+        "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.combinator&.is_a?(METADATA_FILTER_RULE_COMBINATOR) != false || raise("Passed value for field obj.combinator is not the expected type, validation failed.")
+      obj.negated&.is_a?(Boolean) != false || raise("Passed value for field obj.negated is not the expected type, validation failed.")
+      obj.rules&.is_a?(Array) != false || raise("Passed value for field obj.rules is not the expected type, validation failed.")
+      obj.field&.is_a?(String) != false || raise("Passed value for field obj.field is not the expected type, validation failed.")
+      obj.operator&.is_a?(LOGICAL_OPERATOR) != false || raise("Passed value for field obj.operator 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/model_version_build_config.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "model_version_sandbox_snapshot"
+require "json"
+
+module Vellum
+  class ModelVersionBuildConfig
+    attr_reader :base_model, :sandbox_snapshot, :prompt_version_id, :additional_properties
+
+    # @param base_model [String] The name of the base model used to create this model version, as identified by the LLM provider.
+    # @param sandbox_snapshot [ModelVersionSandboxSnapshot] Information about the sandbox snapshot that was used to create this model version, if applicable.
+    # @param prompt_version_id [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ModelVersionBuildConfig]
+    def initialize(base_model:, sandbox_snapshot: nil, prompt_version_id: nil, additional_properties: nil)
+      # @type [String] The name of the base model used to create this model version, as identified by the LLM provider.
+      @base_model = base_model
+      # @type [ModelVersionSandboxSnapshot] Information about the sandbox snapshot that was used to create this model version, if applicable.
+      @sandbox_snapshot = sandbox_snapshot
+      # @type [String]
+      @prompt_version_id = prompt_version_id
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ModelVersionBuildConfig
+    #
+    # @param json_object [JSON]
+    # @return [ModelVersionBuildConfig]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      base_model = struct.base_model
+      if parsed_json["sandbox_snapshot"].nil?
+        sandbox_snapshot = nil
+      else
+        sandbox_snapshot = parsed_json["sandbox_snapshot"].to_json
+        sandbox_snapshot = ModelVersionSandboxSnapshot.from_json(json_object: sandbox_snapshot)
+      end
+      prompt_version_id = struct.prompt_version_id
+      new(base_model: base_model, sandbox_snapshot: sandbox_snapshot, prompt_version_id: prompt_version_id,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of ModelVersionBuildConfig to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "base_model": @base_model,
+        "sandbox_snapshot": @sandbox_snapshot,
+        "prompt_version_id": @prompt_version_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.base_model.is_a?(String) != false || raise("Passed value for field obj.base_model is not the expected type, validation failed.")
+      obj.sandbox_snapshot.nil? || ModelVersionSandboxSnapshot.validate_raw(obj: obj.sandbox_snapshot)
+      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

data/lib/vellum_ai/types/model_version_exec_config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "model_version_exec_config_parameters"
+require_relative "vellum_variable"
+require_relative "prompt_template_block_data"
+require "json"
+
+module Vellum
+  class ModelVersionExecConfig
+    attr_reader :parameters, :input_variables, :prompt_template, :prompt_block_data, :prompt_syntax_version,
+                :additional_properties
+
+    # @param parameters [ModelVersionExecConfigParameters] The generation parameters that are passed to the LLM provider at runtime.
+    # @param input_variables [Array<VellumVariable>] Input variables specified in the prompt template.
+    # @param prompt_template [String] The template used to generate prompts for this model version.
+    # @param prompt_block_data [PromptTemplateBlockData]
+    # @param prompt_syntax_version [Integer]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ModelVersionExecConfig]
+    def initialize(parameters:, input_variables:, prompt_template: nil, prompt_block_data: nil,
+                   prompt_syntax_version: nil, additional_properties: nil)
+      # @type [ModelVersionExecConfigParameters] The generation parameters that are passed to the LLM provider at runtime.
+      @parameters = parameters
+      # @type [Array<VellumVariable>] Input variables specified in the prompt template.
+      @input_variables = input_variables
+      # @type [String] The template used to generate prompts for this model version.
+      @prompt_template = prompt_template
+      # @type [PromptTemplateBlockData]
+      @prompt_block_data = prompt_block_data
+      # @type [Integer]
+      @prompt_syntax_version = prompt_syntax_version
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ModelVersionExecConfig
+    #
+    # @param json_object [JSON]
+    # @return [ModelVersionExecConfig]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["parameters"].nil?
+        parameters = nil
+      else
+        parameters = parsed_json["parameters"].to_json
+        parameters = ModelVersionExecConfigParameters.from_json(json_object: parameters)
+      end
+      input_variables = parsed_json["input_variables"].map do |v|
+        v = v.to_json
+        VellumVariable.from_json(json_object: v)
+      end
+      prompt_template = struct.prompt_template
+      if parsed_json["prompt_block_data"].nil?
+        prompt_block_data = nil
+      else
+        prompt_block_data = parsed_json["prompt_block_data"].to_json
+        prompt_block_data = PromptTemplateBlockData.from_json(json_object: prompt_block_data)
+      end
+      prompt_syntax_version = struct.prompt_syntax_version
+      new(parameters: parameters, input_variables: input_variables, prompt_template: prompt_template,
+          prompt_block_data: prompt_block_data, prompt_syntax_version: prompt_syntax_version, additional_properties: struct)
+    end
+
+    # Serialize an instance of ModelVersionExecConfig to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "parameters": @parameters,
+        "input_variables": @input_variables,
+        "prompt_template": @prompt_template,
+        "prompt_block_data": @prompt_block_data,
+        "prompt_syntax_version": @prompt_syntax_version
+      }.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:)
+      ModelVersionExecConfigParameters.validate_raw(obj: obj.parameters)
+      obj.input_variables.is_a?(Array) != false || raise("Passed value for field obj.input_variables is not the expected type, validation failed.")
+      obj.prompt_template&.is_a?(String) != false || raise("Passed value for field obj.prompt_template is not the expected type, validation failed.")
+      obj.prompt_block_data.nil? || PromptTemplateBlockData.validate_raw(obj: obj.prompt_block_data)
+      obj.prompt_syntax_version&.is_a?(Integer) != false || raise("Passed value for field obj.prompt_syntax_version is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/model_version_exec_config_parameters.rb

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