class ActionController::Parameters

def self.hook_into_yaml_loading # :nodoc:
  # Wire up YAML format compatibility with Rails 4.2 and Psych 2.0.8 and 2.0.9+.
  # Makes the YAML parser call `init_with` when it encounters the keys below
  # instead of trying its own parsing routines.
  YAML.load_tags["!ruby/hash-with-ivars:ActionController::Parameters"] = name
  YAML.load_tags["!ruby/hash:ActionController::Parameters"] = name
end

def ==(other)
  if other.respond_to?(:permitted?)
    permitted? == other.permitted? && parameters == other.parameters
  else
    @parameters == other
  end
end

def []: ((Symbol | String) key) -> String?

def [](key)
  convert_hashes_to_parameters(key, @parameters[key])
end

def []=: (String key, String value) -> String

def []=(key, value)
  @parameters[key] = value
end

def array_of_permitted_scalars?(value)
  if value.is_a?(Array) && value.all? { |element| permitted_scalar?(element) }
    yield value
  end
end

def compact
  new_instance_with_inherited_permitted_status(@parameters.compact)
end

def compact!
  self if @parameters.compact!
end

def compact_blank
  reject { |_k, v| v.blank? }
end

def compact_blank!
  reject! { |_k, v| v.blank? }
end

type ActionController__Parameters_convert_hashes_to_parameters_value = String | Array[String] | nil | Hash
type ActionController__Parameters_convert_hashes_to_parameters_value = String |  | nil | gem_name | String | gem_version | String | receiver | String | method_name | String | application_name | String | location | String | type_fusion_version | String | parameters | Array | String | String | String | Array | String | String | String | return_value | String

def convert_hashes_to_parameters: ((String | Symbol) key, ActionController__Parameters_convert_hashes_to_parameters_value value) -> (String | nil | ActionController::Parameters)

def convert_hashes_to_parameters(key, value)
  converted = convert_value_to_parameters(value)
  @parameters[key] = converted unless converted.equal?(value)
  converted
end

def convert_parameters_to_hashes: (String value, Symbol using) -> String

def convert_parameters_to_hashes(value, using)
  case value
  when Array
    value.map { |v| convert_parameters_to_hashes(v, using) }
  when Hash
    value.transform_values do |v|
      convert_parameters_to_hashes(v, using)
    end.with_indifferent_access
  when Parameters
    value.send(using)
  else
    value
  end
end

def convert_value_to_parameters: (String? value) -> String?

def convert_value_to_parameters(value)
  case value
  when Array
    return value if converted_arrays.member?(value)
    converted = value.map { |_| convert_value_to_parameters(_) }
    converted_arrays << converted.dup
    converted
  when Hash
    self.class.new(value, @logging_context)
  else
    value
  end
end

def converted_arrays
  @converted_arrays ||= Set.new
end

def deep_dup
  self.class.new(@parameters.deep_dup, @logging_context).tap do |duplicate|
    duplicate.permitted = @permitted
  end
end

def deep_transform_keys(&block)
  new_instance_with_inherited_permitted_status(
    @parameters.deep_transform_keys(&block)
  )
end

def deep_transform_keys!(&block)
  @parameters.deep_transform_keys!(&block)
  self
end

def delete(key, &block)
  convert_value_to_parameters(@parameters.delete(key, &block))
end

def dig(*keys)
  convert_hashes_to_parameters(keys.first, @parameters[keys.first])
  @parameters.dig(*keys)
end

def each_element(object, filter, &block)
  case object
  when Array
    object.grep(Parameters).filter_map(&block)
  when Parameters
    if object.nested_attributes? && !specify_numeric_keys?(filter)
      object.each_nested_attribute(&block)
    else
      yield object
    end
  end
end

def each_nested_attribute
  hash = self.class.new
  self.each { |k, v| hash[k] = yield v if Parameters.nested_attribute?(k, v) }
  hash
end

def each_pair(&block)
  return to_enum(__callee__) unless block_given?
  @parameters.each_pair do |key, value|
    yield [key, convert_hashes_to_parameters(key, value)]
  end
  self
end

def each_value(&block)
  return to_enum(:each_value) unless block_given?
  @parameters.each_pair do |key, value|
    yield convert_hashes_to_parameters(key, value)
  end
  self
end

def encode_with(coder) # :nodoc:
  coder.map = { "parameters" => @parameters, "permitted" => @permitted }
end

def eql?(other)
  self.class == other.class &&
    permitted? == other.permitted? &&
    parameters.eql?(other.parameters)
end

def except(*keys)
  new_instance_with_inherited_permitted_status(@parameters.except(*keys))
end

def extract!(*keys)
  new_instance_with_inherited_permitted_status(@parameters.extract!(*keys))
end

def fetch(key, *args)
  convert_value_to_parameters(
    @parameters.fetch(key) {
      if block_given?
        yield
      else
        args.fetch(0) { raise ActionController::ParameterMissing.new(key, @parameters.keys) }
      end
    }
  )
end

def hash
  [self.class, @parameters, @permitted].hash
end

def hash_filter(params, filter)
  filter = filter.with_indifferent_access
  # Slicing filters out non-declared keys.
  slice(*filter.keys).each do |key, value|
    next unless value
    next unless has_key? key
    if filter[key] == EMPTY_ARRAY
      # Declaration { comment_ids: [] }.
      array_of_permitted_scalars?(self[key]) do |val|
        params[key] = val
      end
    elsif filter[key] == EMPTY_HASH
      # Declaration { preferences: {} }.
      if value.is_a?(Parameters)
        params[key] = permit_any_in_parameters(value)
      end
    elsif non_scalar?(value)
      # Declaration { user: :name } or { user: [:name, :age, { address: ... }] }.
      params[key] = each_element(value, filter[key]) do |element|
        element.permit(*Array.wrap(filter[key]))
      end
    end
  end
end

def init_with(coder) # :nodoc:
  case coder.tag
  when "!ruby/hash:ActionController::Parameters"
    # YAML 2.0.8's format where hash instance variables weren't stored.
    @parameters = coder.map.with_indifferent_access
    @permitted  = false
  when "!ruby/hash-with-ivars:ActionController::Parameters"
    # YAML 2.0.9's Hash subclass format where keys and values
    # were stored under an elements hash and `permitted` within an ivars hash.
    @parameters = coder.map["elements"].with_indifferent_access
    @permitted  = coder.map["ivars"][:@permitted]
  when "!ruby/object:ActionController::Parameters"
    # YAML's Object format. Only needed because of the format
    # backwards compatibility above, otherwise equivalent to YAML's initialization.
    @parameters, @permitted = coder.map["parameters"], coder.map["permitted"]
  end
end

def initialize: (? parameters, ? logging_context) -> void

def initialize(parameters = {}, logging_context = {})
  @parameters = parameters.with_indifferent_access
  @logging_context = logging_context
  @permitted = self.class.permit_all_parameters
end

def initialize_copy(source)
  super
  @parameters = @parameters.dup
end

def inspect
  "#<#{self.class} #{@parameters} permitted: #{@permitted}>"
end

def merge(other_hash)
  new_instance_with_inherited_permitted_status(
    @parameters.merge(other_hash.to_h)
  )
end

def merge!(other_hash)
  @parameters.merge!(other_hash.to_h)
  self
end

def nested_attribute?(key, value) # :nodoc:
  /\A-?\d+\z/.match?(key) && (value.is_a?(Hash) || value.is_a?(Parameters))
end

def nested_attributes?
  @parameters.any? { |k, v| Parameters.nested_attribute?(k, v) }
end

def new_instance_with_inherited_permitted_status: ( hash) -> ActionController::Parameters

def new_instance_with_inherited_permitted_status(hash)
  self.class.new(hash, @logging_context).tap do |new_instance|
    new_instance.permitted = @permitted
  end
end

def non_scalar?(value)
  value.is_a?(Array) || value.is_a?(Parameters)
end

def permit(*filters)
  params = self.class.new
  filters.flatten.each do |filter|
    case filter
    when Symbol, String
      permitted_scalar_filter(params, filter)
    when Hash
      hash_filter(params, filter)
    end
  end
  unpermitted_parameters!(params) if self.class.action_on_unpermitted_parameters
  params.permit!
end

def permit!
  each_pair do |key, value|
    Array.wrap(value).flatten.each do |v|
      v.permit! if v.respond_to? :permit!
    end
  end
  @permitted = true
  self
end

def permit_any_in_array(array)
  [].tap do |sanitized|
    array.each do |element|
      case element
      when ->(e) { permitted_scalar?(e) }
        sanitized << element
      when Parameters
        sanitized << permit_any_in_parameters(element)
      else
        # Filter this one out.
      end
    end
  end
end

def permit_any_in_parameters(params)
  self.class.new.tap do |sanitized|
    params.each do |key, value|
      case value
      when ->(v) { permitted_scalar?(v) }
        sanitized[key] = value
      when Array
        sanitized[key] = permit_any_in_array(value)
      when Parameters
        sanitized[key] = permit_any_in_parameters(value)
      else
        # Filter this one out.
      end
    end
  end
end

def permitted?
  @permitted
end

def permitted_scalar?: (String value) -> true

def permitted_scalar?(value)
  PERMITTED_SCALAR_TYPES.any? { |type| value.is_a?(type) }
end

def permitted_scalar_filter: (ActionController::Parameters params, String permitted_key) -> untyped

def permitted_scalar_filter(params, permitted_key)
  permitted_key = permitted_key.to_s
  if has_key?(permitted_key) && permitted_scalar?(self[permitted_key])
    params[permitted_key] = self[permitted_key]
  end
  each_key do |key|
    next unless key =~ /\(\d+[if]?\)\z/
    next unless $~.pre_match == permitted_key
    params[key] = self[key] if permitted_scalar?(self[key])
  end
end

def reject(&block)
  new_instance_with_inherited_permitted_status(@parameters.reject(&block))
end

def reject!(&block)
  @parameters.reject!(&block)
  self
end

def require(key)
  return key.map { |k| require(k) } if key.is_a?(Array)
  value = self[key]
  if value.present? || value == false
    value
  else
    raise ParameterMissing.new(key, @parameters.keys)
  end
end

def reverse_merge(other_hash)
  new_instance_with_inherited_permitted_status(
    other_hash.to_h.merge(@parameters)
  )
end

def reverse_merge!(other_hash)
  @parameters.merge!(other_hash.to_h) { |key, left, right| left }
  self
end

def select(&block)
  new_instance_with_inherited_permitted_status(@parameters.select(&block))
end

def select!(&block)
  @parameters.select!(&block)
  self
end

def slice: (* keys) -> ActionController::Parameters

def slice(*keys)
  new_instance_with_inherited_permitted_status(@parameters.slice(*keys))
end

def slice!(*keys)
  @parameters.slice!(*keys)
  self
end

def specify_numeric_keys?(filter)
  if filter.respond_to?(:keys)
    filter.keys.any? { |key| /\A-?\d+\z/.match?(key) }
  end
end

def stringify_keys # :nodoc:
  dup
end

def to_h
  if permitted?
    convert_parameters_to_hashes(@parameters, :to_h)
  else
    raise UnfilteredParameters
  end
end

def to_hash
  to_h.to_hash
end

def to_query(*args)
  to_h.to_query(*args)
end

def to_unsafe_h
  convert_parameters_to_hashes(@parameters, :to_unsafe_h)
end

def transform_keys(&block)
  return to_enum(:transform_keys) unless block_given?
  new_instance_with_inherited_permitted_status(
    @parameters.transform_keys(&block)
  )
end

def transform_keys!(&block)
  return to_enum(:transform_keys!) unless block_given?
  @parameters.transform_keys!(&block)
  self
end

def transform_values
  return to_enum(:transform_values) unless block_given?
  new_instance_with_inherited_permitted_status(
    @parameters.transform_values { |v| yield convert_value_to_parameters(v) }
  )
end

def transform_values!
  return to_enum(:transform_values!) unless block_given?
  @parameters.transform_values! { |v| yield convert_value_to_parameters(v) }
  self
end

def unpermitted_keys(params)
  keys - params.keys - always_permitted_parameters
end

def unpermitted_parameters!: (ActionController::Parameters params) -> nil

def unpermitted_parameters!(params)
  unpermitted_keys = unpermitted_keys(params)
  if unpermitted_keys.any?
    case self.class.action_on_unpermitted_parameters
    when :log
      name = "unpermitted_parameters.action_controller"
      ActiveSupport::Notifications.instrument(name, keys: unpermitted_keys, context: @logging_context)
    when :raise
      raise ActionController::UnpermittedParameters.new(unpermitted_keys)
    end
  end
end

def values_at(*keys)
  convert_value_to_parameters(@parameters.values_at(*keys))
end