class VericredClient::DentalPlanBenefits

Attributes

bridges[RW]

Bridges benefit string

crowns[RW]

Crowns benefit string

denture_relines_rebases[RW]

Denture Relines/Rebases benefit string

denture_repair_and_adjustments[RW]

Denture Repair and Adjustments benefit string

dentures[RW]

Dentures benefit string

emergency_treatment[RW]

Emergency Treatment benefit string

endodontics[RW]

Endodontics benefit string

family_annual_max[RW]

Family Annual Max benefit string

family_deductible[RW]

Family Deductible benefit string

fluoride_treatment[RW]

Fluoride Treatment benefit string

implants[RW]

Implants benefit string

individual_annual_max[RW]

Individual Annual Max benefit string

individual_deductible[RW]

Individual Deductible benefit string

inlays[RW]

Inlays benefit string

onlays[RW]

Onlays benefit string

oral_exam[RW]

Oral Exam benefit string

oral_surgery[RW]

Oral Surgery benefit string

orthodontics_adult[RW]

Orthodontics - Adult benefit string

orthodontics_child[RW]

Orthodontics - Child benefit string

periodontal_maintenance[RW]

Periodontal Maintenance benefit string

periodontics[RW]

Periodontics benefit string

prophylaxis_cleaning[RW]

Prophylaxis Cleaning benefit string

radiograph_bitewings[RW]

Radiograph - Bitewings benefit string

radiograph_other[RW]

Radiograph - Other benefit string

restoration_fillings[RW]

Restoration - Fillings benefit string

sealant[RW]

Sealant benefit string

simple_extraction[RW]

Simple Extraction benefit string

space_maintainers[RW]

Space Maintainers benefit string

Public Class Methods

attribute_map() click to toggle source

Attribute mapping from ruby-style variable name to JSON key.

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1103
def self.attribute_map
  {
    :'bridges' => :'bridges',
    :'crowns' => :'crowns',
    :'denture_relines_rebases' => :'denture_relines_rebases',
    :'denture_repair_and_adjustments' => :'denture_repair_and_adjustments',
    :'dentures' => :'dentures',
    :'emergency_treatment' => :'emergency_treatment',
    :'endodontics' => :'endodontics',
    :'family_annual_max' => :'family_annual_max',
    :'family_deductible' => :'family_deductible',
    :'fluoride_treatment' => :'fluoride_treatment',
    :'implants' => :'implants',
    :'individual_annual_max' => :'individual_annual_max',
    :'individual_deductible' => :'individual_deductible',
    :'inlays' => :'inlays',
    :'onlays' => :'onlays',
    :'oral_exam' => :'oral_exam',
    :'oral_surgery' => :'oral_surgery',
    :'orthodontics_adult' => :'orthodontics_adult',
    :'orthodontics_child' => :'orthodontics_child',
    :'periodontal_maintenance' => :'periodontal_maintenance',
    :'periodontics' => :'periodontics',
    :'prophylaxis_cleaning' => :'prophylaxis_cleaning',
    :'radiograph_bitewings' => :'radiograph_bitewings',
    :'radiograph_other' => :'radiograph_other',
    :'restoration_fillings' => :'restoration_fillings',
    :'sealant' => :'sealant',
    :'simple_extraction' => :'simple_extraction',
    :'space_maintainers' => :'space_maintainers'
  }
end
new(attributes = {}) click to toggle source

Initializes the object @param [Hash] attributes Model attributes in the form of hash

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1172
def initialize(attributes = {})
  return unless attributes.is_a?(Hash)

  # convert string to symbol for hash key
  attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}

  if attributes.has_key?(:'bridges')
    self.bridges = attributes[:'bridges']
  end

  if attributes.has_key?(:'crowns')
    self.crowns = attributes[:'crowns']
  end

  if attributes.has_key?(:'denture_relines_rebases')
    self.denture_relines_rebases = attributes[:'denture_relines_rebases']
  end

  if attributes.has_key?(:'denture_repair_and_adjustments')
    self.denture_repair_and_adjustments = attributes[:'denture_repair_and_adjustments']
  end

  if attributes.has_key?(:'dentures')
    self.dentures = attributes[:'dentures']
  end

  if attributes.has_key?(:'emergency_treatment')
    self.emergency_treatment = attributes[:'emergency_treatment']
  end

  if attributes.has_key?(:'endodontics')
    self.endodontics = attributes[:'endodontics']
  end

  if attributes.has_key?(:'family_annual_max')
    self.family_annual_max = attributes[:'family_annual_max']
  end

  if attributes.has_key?(:'family_deductible')
    self.family_deductible = attributes[:'family_deductible']
  end

  if attributes.has_key?(:'fluoride_treatment')
    self.fluoride_treatment = attributes[:'fluoride_treatment']
  end

  if attributes.has_key?(:'implants')
    self.implants = attributes[:'implants']
  end

  if attributes.has_key?(:'individual_annual_max')
    self.individual_annual_max = attributes[:'individual_annual_max']
  end

  if attributes.has_key?(:'individual_deductible')
    self.individual_deductible = attributes[:'individual_deductible']
  end

  if attributes.has_key?(:'inlays')
    self.inlays = attributes[:'inlays']
  end

  if attributes.has_key?(:'onlays')
    self.onlays = attributes[:'onlays']
  end

  if attributes.has_key?(:'oral_exam')
    self.oral_exam = attributes[:'oral_exam']
  end

  if attributes.has_key?(:'oral_surgery')
    self.oral_surgery = attributes[:'oral_surgery']
  end

  if attributes.has_key?(:'orthodontics_adult')
    self.orthodontics_adult = attributes[:'orthodontics_adult']
  end

  if attributes.has_key?(:'orthodontics_child')
    self.orthodontics_child = attributes[:'orthodontics_child']
  end

  if attributes.has_key?(:'periodontal_maintenance')
    self.periodontal_maintenance = attributes[:'periodontal_maintenance']
  end

  if attributes.has_key?(:'periodontics')
    self.periodontics = attributes[:'periodontics']
  end

  if attributes.has_key?(:'prophylaxis_cleaning')
    self.prophylaxis_cleaning = attributes[:'prophylaxis_cleaning']
  end

  if attributes.has_key?(:'radiograph_bitewings')
    self.radiograph_bitewings = attributes[:'radiograph_bitewings']
  end

  if attributes.has_key?(:'radiograph_other')
    self.radiograph_other = attributes[:'radiograph_other']
  end

  if attributes.has_key?(:'restoration_fillings')
    self.restoration_fillings = attributes[:'restoration_fillings']
  end

  if attributes.has_key?(:'sealant')
    self.sealant = attributes[:'sealant']
  end

  if attributes.has_key?(:'simple_extraction')
    self.simple_extraction = attributes[:'simple_extraction']
  end

  if attributes.has_key?(:'space_maintainers')
    self.space_maintainers = attributes[:'space_maintainers']
  end

end
swagger_types() click to toggle source

Attribute type mapping.

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1137
def self.swagger_types
  {
    :'bridges' => :'String',
    :'crowns' => :'String',
    :'denture_relines_rebases' => :'String',
    :'denture_repair_and_adjustments' => :'String',
    :'dentures' => :'String',
    :'emergency_treatment' => :'String',
    :'endodontics' => :'String',
    :'family_annual_max' => :'String',
    :'family_deductible' => :'String',
    :'fluoride_treatment' => :'String',
    :'implants' => :'String',
    :'individual_annual_max' => :'String',
    :'individual_deductible' => :'String',
    :'inlays' => :'String',
    :'onlays' => :'String',
    :'oral_exam' => :'String',
    :'oral_surgery' => :'String',
    :'orthodontics_adult' => :'String',
    :'orthodontics_child' => :'String',
    :'periodontal_maintenance' => :'String',
    :'periodontics' => :'String',
    :'prophylaxis_cleaning' => :'String',
    :'radiograph_bitewings' => :'String',
    :'radiograph_other' => :'String',
    :'restoration_fillings' => :'String',
    :'sealant' => :'String',
    :'simple_extraction' => :'String',
    :'space_maintainers' => :'String'
  }
end

Public Instance Methods

==(o) click to toggle source

Checks equality by comparing each attribute. @param [Object] Object to be compared

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1307
def ==(o)
  return true if self.equal?(o)
  self.class == o.class &&
      bridges == o.bridges &&
      crowns == o.crowns &&
      denture_relines_rebases == o.denture_relines_rebases &&
      denture_repair_and_adjustments == o.denture_repair_and_adjustments &&
      dentures == o.dentures &&
      emergency_treatment == o.emergency_treatment &&
      endodontics == o.endodontics &&
      family_annual_max == o.family_annual_max &&
      family_deductible == o.family_deductible &&
      fluoride_treatment == o.fluoride_treatment &&
      implants == o.implants &&
      individual_annual_max == o.individual_annual_max &&
      individual_deductible == o.individual_deductible &&
      inlays == o.inlays &&
      onlays == o.onlays &&
      oral_exam == o.oral_exam &&
      oral_surgery == o.oral_surgery &&
      orthodontics_adult == o.orthodontics_adult &&
      orthodontics_child == o.orthodontics_child &&
      periodontal_maintenance == o.periodontal_maintenance &&
      periodontics == o.periodontics &&
      prophylaxis_cleaning == o.prophylaxis_cleaning &&
      radiograph_bitewings == o.radiograph_bitewings &&
      radiograph_other == o.radiograph_other &&
      restoration_fillings == o.restoration_fillings &&
      sealant == o.sealant &&
      simple_extraction == o.simple_extraction &&
      space_maintainers == o.space_maintainers
end
_deserialize(type, value) click to toggle source

Deserializes the data based on type @param string type Data type @param string value Value to be deserialized @return [Object] Deserialized data

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1376
def _deserialize(type, value)
  case type.to_sym
  when :DateTime
    DateTime.parse(value)
  when :Date
    Date.parse(value)
  when :String
    value.to_s
  when :Integer
    value.to_i
  when :Float
    value.to_f
  when :BOOLEAN
    if value.to_s =~ /\A(true|t|yes|y|1)\z/i
      true
    else
      false
    end
  when :Object
    # generic object (usually a Hash), return directly
    value
  when /\AArray<(?<inner_type>.+)>\z/
    inner_type = Regexp.last_match[:inner_type]
    value.map { |v| _deserialize(inner_type, v) }
  when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
    k_type = Regexp.last_match[:k_type]
    v_type = Regexp.last_match[:v_type]
    {}.tap do |hash|
      value.each do |k, v|
        hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
      end
    end
  else # model
    temp_model = VericredClient.const_get(type).new
    temp_model.build_from_hash(value)
  end
end
_to_hash(value) click to toggle source

Outputs non-array value in the form of hash For object, use to_hash. Otherwise, just return the value @param [Object] value Any valid value @return [Hash] Returns the value in the form of hash

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1442
def _to_hash(value)
  if value.is_a?(Array)
    value.compact.map{ |v| _to_hash(v) }
  elsif value.is_a?(Hash)
    {}.tap do |hash|
      value.each { |k, v| hash[k] = _to_hash(v) }
    end
  elsif value.respond_to? :to_hash
    value.to_hash
  else
    value
  end
end
build_from_hash(attributes) click to toggle source

Builds the object from hash @param [Hash] attributes Model attributes in the form of hash @return [Object] Returns the model itself

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1355
def build_from_hash(attributes)
  return nil unless attributes.is_a?(Hash)
  self.class.swagger_types.each_pair do |key, type|
    if type =~ /\AArray<(.*)>/i
      # check to ensure the input is an array given that the the attribute
      # is documented as an array but the input is not
      if attributes[self.class.attribute_map[key]].is_a?(Array)
        self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
      end
    elsif !attributes[self.class.attribute_map[key]].nil?
      self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
    end # or else data not found in attributes(hash), not an issue as the data can be optional
  end

  self
end
eql?(o) click to toggle source

@see the `==` method @param [Object] Object to be compared

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1342
def eql?(o)
  self == o
end
hash() click to toggle source

Calculates hash code according to all attributes. @return [Fixnum] Hash code

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1348
def hash
  [bridges, crowns, denture_relines_rebases, denture_repair_and_adjustments, dentures, emergency_treatment, endodontics, family_annual_max, family_deductible, fluoride_treatment, implants, individual_annual_max, individual_deductible, inlays, onlays, oral_exam, oral_surgery, orthodontics_adult, orthodontics_child, periodontal_maintenance, periodontics, prophylaxis_cleaning, radiograph_bitewings, radiograph_other, restoration_fillings, sealant, simple_extraction, space_maintainers].hash
end
list_invalid_properties() click to toggle source

Show invalid properties with the reasons. Usually used together with valid? @return Array for valid properies with the reasons

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1294
def list_invalid_properties
  invalid_properties = Array.new
  return invalid_properties
end
to_body() click to toggle source

to_body is an alias to to_hash (backward compatibility) @return [Hash] Returns the object in the form of hash

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1422
def to_body
  to_hash
end
to_hash() click to toggle source

Returns the object in the form of hash @return [Hash] Returns the object in the form of hash

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1428
def to_hash
  hash = {}
  self.class.attribute_map.each_pair do |attr, param|
    value = self.send(attr)
    next if value.nil?
    hash[param] = _to_hash(value)
  end
  hash
end
to_s() click to toggle source

Returns the string representation of the object @return [String] String presentation of the object

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1416
def to_s
  to_hash.to_s
end
valid?() click to toggle source

Check to see if the all the properties in the model are valid @return true if the model is valid

# File lib/vericred_client/models/dental_plan_benefits.rb, line 1301
def valid?
  return true
end