class String

def acts_like_string?
  true
end

def as_json: (?(nil |  | prefixes | String | template | String | layout | Proc) options) -> String

def as_json(options = nil) # :nodoc:
  self
end

def at(position)
  self[position]
end

def blank?: () -> bool

def blank?
  # The regexp that matches blank strings is expensive. For the case of empty
  # strings we can speed up this method (~3.5x) with an empty? call. The
  # penalty for the rest of strings is marginal.
  empty? ||
    begin
      BLANK_RE.match?(self)
    rescue Encoding::CompatibilityError
      ENCODED_BLANKS[self.encoding].match?(self)
    end
end

def camelize: (?Symbol first_letter) -> String

def camelize(first_letter = :upper)
  case first_letter
  when :upper
    ActiveSupport::Inflector.camelize(self, true)
  when :lower
    ActiveSupport::Inflector.camelize(self, false)
  else
    raise ArgumentError, "Invalid option, use either :upper or :lower."
  end
end

def classify
  ActiveSupport::Inflector.classify(self)
end

def constantize: () -> (Class | Module)

def constantize
  ActiveSupport::Inflector.constantize(self)
end

def dasherize: () -> String

def dasherize
  ActiveSupport::Inflector.dasherize(self)
end

def deconstantize
  ActiveSupport::Inflector.deconstantize(self)
end

def demodulize: () -> String

def demodulize
  ActiveSupport::Inflector.demodulize(self)
end

def exclude?(string)
  !include?(string)
end

def first: (?Integer limit) -> String

def first(limit = 1)
  self[0, limit] || raise(ArgumentError, "negative limit")
end

def foreign_key(separate_class_name_and_id_with_underscore = true)
  ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

def from: (Integer position) -> String

def from(position)
  self[position, length]
end

def html_safe: () -> ActiveSupport::SafeBuffer

def html_safe
  ActiveSupport::SafeBuffer.new(self)
end

def humanize: (capitalize: true, keep_id_suffix: false) -> String

def humanize(capitalize: true, keep_id_suffix: false)
  ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
end

def in_time_zone(zone = ::Time.zone)
  if zone
    ::Time.find_zone!(zone).parse(self)
  else
    to_time
  end
end

def indent(amount, indent_string = nil, indent_empty_lines = false)
  dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }
end

def indent!(amount, indent_string = nil, indent_empty_lines = false)
  indent_string = indent_string || self[/^[ \t]/] || " "
  re = indent_empty_lines ? /^/ : /^(?!$)/
  gsub!(re, indent_string * amount)
end

def inquiry
  ActiveSupport::StringInquirer.new(self)
end

def is_utf8?
  case encoding
  when Encoding::UTF_8, Encoding::US_ASCII
    valid_encoding?
  when Encoding::ASCII_8BIT
    dup.force_encoding(Encoding::UTF_8).valid_encoding?
  else
    false
  end
end

def last: (?Integer limit) -> String

def last(limit = 1)
  self[[length - limit, 0].max, limit] || raise(ArgumentError, "negative limit")
end

def mb_chars
  ActiveSupport::Multibyte.proxy_class.new(self)
end

def parameterize: (separator: String, preserve_case: false, locale: nil) -> String

def parameterize(separator: "-", preserve_case: false, locale: nil)
  ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
end

def pluralize: (?(Symbol | nil | Integer) count, ?Symbol locale) -> String

def pluralize(count = nil, locale = :en)
  locale = count if count.is_a?(Symbol)
  if count == 1
    dup
  else
    ActiveSupport::Inflector.pluralize(self, locale)
  end
end

def remove(*patterns)
  dup.remove!(*patterns)
end

def remove!(*patterns)
  patterns.each do |pattern|
    gsub! pattern, ""
  end
  self
end

def safe_constantize
  ActiveSupport::Inflector.safe_constantize(self)
end

def singularize: (?Symbol locale) -> String

def singularize(locale = :en)
  ActiveSupport::Inflector.singularize(self, locale)
end

def squish
  dup.squish!
end

def squish!
  gsub!(/[[:space:]]+/, " ")
  strip!
  self
end

def strip_heredoc
  gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
    stripped.freeze if frozen?
  end
end

def tableize
  ActiveSupport::Inflector.tableize(self)
end

def titleize(keep_id_suffix: false)
  ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
end

def to(position)
  position += size if position < 0
  self[0, position + 1] || +""
end

def to_date
  ::Date.parse(self, false) unless blank?
end

def to_datetime
  ::DateTime.parse(self, false) unless blank?
end

def to_time(form = :local)
  parts = Date._parse(self, false)
  used_keys = %i(year mon mday hour min sec sec_fraction offset)
  return if (parts.keys & used_keys).empty?
  now = Time.now
  time = Time.new(
    parts.fetch(:year, now.year),
    parts.fetch(:mon, now.month),
    parts.fetch(:mday, now.day),
    parts.fetch(:hour, 0),
    parts.fetch(:min, 0),
    parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
    parts.fetch(:offset, form == :utc ? 0 : nil)
  )
  form == :utc ? time.utc : time.to_time
end

def truncate: (Integer truncate_at, ?( | length | Integer | separator | String | omission | String | escape | TrueClass) options) -> String

def truncate(truncate_at, options = {})
  return dup unless length > truncate_at
  omission = options[:omission] || "..."
  length_with_room_for_omission = truncate_at - omission.length
  stop = \
    if options[:separator]
      rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
    else
      length_with_room_for_omission
    end
  +"#{self[0, stop]}#{omission}"
end

def truncate_bytes(truncate_at, omission: "…")
  omission ||= ""
  case
  when bytesize <= truncate_at
    dup
  when omission.bytesize > truncate_at
    raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
  when omission.bytesize == truncate_at
    omission.dup
  else
    self.class.new.tap do |cut|
      cut_at = truncate_at - omission.bytesize
      each_grapheme_cluster do |grapheme|
        if cut.bytesize + grapheme.bytesize <= cut_at
          cut << grapheme
        else
          break
        end
      end
      cut << omission
    end
  end
end

def truncate_words(words_count, options = {})
  sep = options[:separator] || /\s+/
  sep = Regexp.escape(sep.to_s) unless Regexp === sep
  if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
    $1 + (options[:omission] || "...")
  else
    dup
  end
end

def underscore: () -> String

def underscore
  ActiveSupport::Inflector.underscore(self)
end

def upcase_first
  ActiveSupport::Inflector.upcase_first(self)
end