module T::Configuration

def self.call_validation_error_handler(signature, opts={})
  if @call_validation_error_handler
    @call_validation_error_handler.call(signature, opts)
  else
    call_validation_error_handler_default(signature, opts)
  end
  nil
end

def self.call_validation_error_handler=(value)
  validate_lambda_given!(value)
  @call_validation_error_handler = value
end

def self.call_validation_error_handler_default(signature, opts)
(opts[:pretty_message])

def self.can_enable_vm_prop_serde?
  T::Props::Private::DeserializerGenerator.respond_to?(:generate2)
end

def self.class_owner_finder
  @class_owner_finder
end

def self.class_owner_finder=(handler)
  @class_owner_finder = handler
end

def self.default_checked_level=(default_checked_level)
  T::Private::RuntimeLevels.default_checked_level = default_checked_level
end

def self.disable_legacy_t_enum_migration_mode
  @legacy_t_enum_migration_mode = false
end

def self.disable_vm_prop_serde
  @use_vm_prop_serde = false
end

def self.enable_checking_for_sigs_marked_checked_tests
  T::Private::RuntimeLevels.enable_checking_in_tests
end

def self.enable_final_checks_on_hooks
  T::Private::Methods.set_final_checks_on_hooks(true)
end

def self.enable_legacy_t_enum_migration_mode
  @legacy_t_enum_migration_mode = true
end

def self.enable_vm_prop_serde
  if !can_enable_vm_prop_serde?
    hard_assert_handler('Ruby VM is not setup to use VM-defined prop serde')
  end
  @use_vm_prop_serde = true
end

def self.exclude_value_in_type_errors
  @include_value_in_type_errors = false
end

def self.hard_assert_handler(str, extra={})
  if @hard_assert_handler
    @hard_assert_handler.call(str, extra)
  else
    hard_assert_handler_default(str, extra)
  end
end

def self.hard_assert_handler=(value)
  validate_lambda_given!(value)
  @hard_assert_handler = value
end

def self.hard_assert_handler_default(str, _)

def self.include_value_in_type_errors
  @include_value_in_type_errors = true
end

def self.include_value_in_type_errors?
  @include_value_in_type_errors
end

def self.inline_type_error_handler(error, opts={})
  if @inline_type_error_handler
    # Backwards compatibility before `inline_type_error_handler` took a second arg
    if @inline_type_error_handler.arity == 1
      @inline_type_error_handler.call(error)
    else
      @inline_type_error_handler.call(error, opts)
    end
  else
    inline_type_error_handler_default(error, opts)
  end
  nil
end

def self.inline_type_error_handler=(value)
  validate_lambda_given!(value)
  @inline_type_error_handler = value
end

def self.inline_type_error_handler_default(error, opts)

def self.legacy_t_enum_migration_mode?
  @legacy_t_enum_migration_mode || false
end

def self.log_info_handler(str, extra)
  if @log_info_handler
    @log_info_handler.call(str, extra)
  else
    log_info_handler_default(str, extra)
  end
end

def self.log_info_handler=(value)
  validate_lambda_given!(value)
  @log_info_handler = value
end

def self.log_info_handler_default(str, extra)
: #{extra}"

def self.module_name_mangler
  @module_name_mangler || @default_module_name_mangler
end

def self.module_name_mangler=(handler)
  @module_name_mangler = handler
end

def self.normalize_sensitivity_and_pii_handler
  @sensitivity_and_pii_handler
end

def self.normalize_sensitivity_and_pii_handler=(handler)
  @sensitivity_and_pii_handler = handler
end

def self.prop_freeze_handler
  @prop_freeze_handler
end

def self.prop_freeze_handler=(handler)
  @prop_freeze_handler = handler
end

def self.redaction_handler
  @redaction_handler
end

def self.redaction_handler=(handler)
  @redaction_handler = handler
end

def self.reset_final_checks_on_hooks
  T::Private::Methods.set_final_checks_on_hooks(false)
end

def self.scalar_types
  @scalar_types || @default_scalar_types
end

def self.scalar_types=(values)
  if values.nil?
    @scalar_types = values
  else
    bad_values = values.reject {|v| v.class == String}
    unless bad_values.empty?
      raise ArgumentError.new("Provided values must all be class name strings.")
    end
    @scalar_types = Set.new(values).freeze
  end
end

def self.sealed_violation_whitelist
  @sealed_violation_whitelist
end

def self.sealed_violation_whitelist=(sealed_violation_whitelist)
  if !@sealed_violation_whitelist.nil?
    raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
  end
  case sealed_violation_whitelist
  when Array
    sealed_violation_whitelist.each do |x|
      case x
      when Regexp then nil
      else raise TypeError.new("sealed_violation_whitelist accepts an Array of Regexp")
      end
    end
  else
    raise TypeError.new("sealed_violation_whitelist= accepts an Array of Regexp")
  end
  @sealed_violation_whitelist = sealed_violation_whitelist
end

def self.sig_builder_error_handler(error, location)
  if @sig_builder_error_handler
    @sig_builder_error_handler.call(error, location)
  else
    sig_builder_error_handler_default(error, location)
  end
  nil
end

def self.sig_builder_error_handler=(value)
  validate_lambda_given!(value)
  @sig_builder_error_handler = value
end

def self.sig_builder_error_handler_default(error, location)
.new("#{location.path}:#{location.lineno}: Error interpreting `sig`:\n  #{error.message}\n\n")

def self.sig_validation_error_handler(error, opts={})
  if @sig_validation_error_handler
    @sig_validation_error_handler.call(error, opts)
  else
    sig_validation_error_handler_default(error, opts)
  end
  nil
end

def self.sig_validation_error_handler=(value)
  validate_lambda_given!(value)
  @sig_validation_error_handler = value
end

def self.sig_validation_error_handler_default(error, opts)

def self.soft_assert_handler(str, extra)
  if @soft_assert_handler
    @soft_assert_handler.call(str, extra)
  else
    soft_assert_handler_default(str, extra)
  end
end

def self.soft_assert_handler=(value)
  validate_lambda_given!(value)
  @soft_assert_handler = value
end

def self.soft_assert_handler_default(str, extra)
: #{extra}"

def self.use_vm_prop_serde?
  @use_vm_prop_serde || false
end

def self.validate_lambda_given!(value)
value.respond_to?(:call)
or.new("Provided value must respond to :call")

def self.without_ruby_warnings
  if $VERBOSE
    begin
      original_verbose = $VERBOSE
      $VERBOSE = false
      yield
    ensure
      $VERBOSE = original_verbose
    end
  else
    yield
  end
end