class Honeybadger::Util::Sanitizer

type Honeybadger__Util__Sanitizer_sanitize_data = Hash | Float | String | nil | true
type Honeybadger__Util__Sanitizer_sanitize_return_value = String | nil | true | Float

def sanitize: (Honeybadger__Util__Sanitizer_sanitize_data data, ?Integer depth, ?Set? stack, ?(Array[Symbol] | Array[]) parents) -> Honeybadger__Util__Sanitizer_sanitize_return_value

def sanitize(data, depth = 0, stack = nil, parents = [])
  return BASIC_OBJECT if basic_object?(data)
  if recursive?(data)
    return RECURSION if stack && stack.include?(data.object_id)
    stack = stack ? stack.dup : Set.new
    stack << data.object_id
  end
  case data
  when Hash
    return DEPTH if depth >= max_depth
    hash = data.to_hash
    new_hash = {}
    hash.each_pair do |key, value|
      parents.push(key) if deep_regexps
      key = key.kind_of?(Symbol) ? key : sanitize(key, depth+1, stack, parents)
      if filter_key?(key, parents)
        new_hash[key] = FILTERED
      else
        value = sanitize(value, depth+1, stack, parents)
        if blocks.any? && !recursive?(value)
          key = key.dup if can_dup?(key)
          value = value.dup if can_dup?(value)
          blocks.each { |b| b.call(key, value) }
        end
        new_hash[key] = value
      end
      parents.pop if deep_regexps
    end
    new_hash
  when Array, Set
    return DEPTH if depth >= max_depth
    data.to_a.map do |value|
      sanitize(value, depth+1, stack, parents)
    end
  when Numeric, TrueClass, FalseClass, NilClass
    data
  when String
    sanitize_string(data)
  when -> (d) { d.respond_to?(:to_honeybadger) }
    return DEPTH if depth >= max_depth
    begin
      data = data.to_honeybadger
    rescue
      return RAISED
    end
    sanitize(data, depth+1, stack, parents)
  else # all other objects
    klass = data.class
    begin
      data = String(data)
    rescue
      return RAISED
    end
    return "#<#{klass.name}>" if inspected?(data)
    sanitize_string(data)
  end
end