class Lithic::Internal::Type::BaseModel

def ==(other) = other.is_a?(Class) && other <= Lithic::Internal::Type::BaseModel && other.fields == fields

def ==(other) = self.class == other.class && @data == other.to_h

def [](key)
  unless key.instance_of?(Symbol)
    raise ArgumentError.new("Expected symbol key for lookup, got #{key.inspect}")
  end
  @data[key]
end

def add_field(name_sym, required:, type_info:, spec:)
n, info =
 type_info
roc | Lithic::Internal::Type::Converter | Class
ithic::Internal::Type::Converter.type_info({**spec, union: type_info}), spec]
ash
ithic::Internal::Type::Converter.type_info(type_info), type_info]
 = "#{name_sym}="
me = info.fetch(:api_name, name_sym)
e = info[:nil?]
= required && !nilable ? info.fetch(:const, Lithic::Internal::OMIT) : Lithic::Internal::OMIT
sym, setter].each { undef_method(_1) } if known_fields.key?(name_sym)
fields[name_sym] =
de: @mode,
i_name: api_name,
quired: required,
lable: nilable,
nst: const,
pe_fn: type_fn
_method(setter) { @data.store(name_sym, _1) }
_method(name_sym) do
et = type_fn.call
e = @data.fetch(name_sym) { const == Lithic::Internal::OMIT ? nil : const }
e = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
nilable || !required) && value.nil?
l

thic::Internal::Type::Converter.coerce(
target,
value,
state: state
 StandardError
= self.class.name.split("::").last
bocop:disable Layout/LineLength
age = "Failed to parse #{cls}.#{__method__} from #{value.class} to #{target.inspect}. To get the unparsed API response, use #{cls}[:#{__method__}]."
bocop:enable Layout/LineLength
e Lithic::Errors::ConversionError.new(message)

def coerce(value, state:)
  exactness = state.fetch(:exactness)
  if value.is_a?(self.class)
    exactness[:yes] += 1
    return value
  end
  unless (val = Lithic::Internal::Util.coerce_hash(value)).is_a?(Hash)
    exactness[:no] += 1
    return value
  end
  exactness[:yes] += 1
  keys = val.keys.to_set
  instance = new
  data = instance.to_h
  # rubocop:disable Metrics/BlockLength
  fields.each do |name, field|
    mode, required, target = field.fetch_values(:mode, :required, :type)
    api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
    unless val.key?(api_name)
      if required && mode != :dump && const == Lithic::Internal::OMIT
        exactness[nilable ? :maybe : :no] += 1
      else
        exactness[:yes] += 1
      end
      next
    end
    item = val.fetch(api_name)
    keys.delete(api_name)
    converted =
      if item.nil? && (nilable || !required)
        exactness[nilable ? :yes : :maybe] += 1
        nil
      else
        coerced = Lithic::Internal::Type::Converter.coerce(target, item, state: state)
        case target
        in Lithic::Internal::Type::Converter | Symbol
          coerced
        else
          item
        end
      end
    data.store(name, converted)
  end
  # rubocop:enable Metrics/BlockLength
  keys.each { data.store(_1, val.fetch(_1)) }
  instance
end

def deconstruct_keys(keys)
  (keys || self.class.known_fields.keys)
    .filter_map do |k|
      unless self.class.known_fields.key?(k)
        next
      end
      [k, public_send(k)]
    end
    .to_h
end

def dump(value)
  unless (coerced = Lithic::Internal::Util.coerce_hash(value)).is_a?(Hash)
    return super
  end
  acc = {}
  coerced.each do |key, val|
    name = key.is_a?(String) ? key.to_sym : key
    case (field = known_fields[name])
    in nil
      acc.store(name, super(val))
    else
      mode, api_name, type_fn = field.fetch_values(:mode, :api_name, :type_fn)
      case mode
      in :coerce
        next
      else
        target = type_fn.call
        acc.store(api_name, Lithic::Internal::Type::Converter.dump(target, val))
      end
    end
  end
  known_fields.each_value do |field|
    mode, api_name, const = field.fetch_values(:mode, :api_name, :const)
    next if mode == :coerce || acc.key?(api_name) || const == Lithic::Internal::OMIT
    acc.store(api_name, const)
  end
  acc
end

def fields
  known_fields.transform_values do |field|
    {**field.except(:type_fn), type: field.fetch(:type_fn).call}
  end
end

def initialize(data = {})
  case Lithic::Internal::Util.coerce_hash(data)
  in Hash => coerced
    @data = coerced
  else
    raise ArgumentError.new("Expected a #{Hash} or #{Lithic::Internal::Type::BaseModel}, got #{data.inspect}")
  end
end

def inspect
  rows = self.class.known_fields.keys.map do
    "#{_1}=#{@data.key?(_1) ? public_send(_1) : ''}"
  rescue Lithic::ConversionError
    "#{_1}=#{@data.fetch(_1)}"
  end
  "#<#{self.class.name}:0x#{object_id.to_s(16)} #{rows.join(' ')}>"
end

def known_fields
  @known_fields ||= (self < Lithic::Internal::Type::BaseModel ? superclass.known_fields.dup : {})
end

def optional(name_sym, type_info, spec = {})
  add_field(name_sym, required: false, type_info: type_info, spec: spec)
end

def request_only(&blk)
= :dump
ll
= nil

def required(name_sym, type_info, spec = {})
  add_field(name_sym, required: true, type_info: type_info, spec: spec)
end

def response_only(&blk)
= :coerce
ll
= nil

def to_h = @data

def to_json(*a) = self.class.dump(self).to_json(*a)

def to_yaml(*a) = self.class.dump(self).to_yaml(*a)