zonesync 0.12.0 → 0.13.0

data/lib/zonesync.rb

@@ -1,5 +1,4 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "zonesync/sync"
 require "zonesync/generate"
@@ -16,29 +15,21 @@ begin # optional active_support dependency
 rescue LoadError; end
 
 module Zonesync
-  extend T::Sig
-
-  sig { params(source: T.nilable(String), destination: T.nilable(String), dry_run: T::Boolean, force: T::Boolean).void }
-  def self.call source: "Zonefile", destination: "zonesync", dry_run: false, force: false
-    source = T.must(source)
-    destination = T.must(destination).to_sym
+  def self.call(source: "Zonefile", destination: "zonesync", dry_run: false, force: false)
     Sync.new(
       Provider.from({ provider: "Filesystem", path: source }),
-      Provider.from(credentials(destination)),
+      Provider.from(credentials(destination.to_sym)),
     ).call(dry_run: dry_run, force: force)
   end
 
-  sig { params(source: T.nilable(String), destination: T.nilable(String)).void }
-  def self.generate source: "zonesync", destination: "Zonefile"
-    source = T.must(source).to_sym
+  def self.generate(source: "zonesync", destination: "Zonefile")
     Generate.new(
-      Provider.from(credentials(source)),
-      Provider.from({ provider: "Filesystem", path: T.must(destination) }),
+      Provider.from(credentials(source.to_sym)),
+      Provider.from({ provider: "Filesystem", path: destination }),
     ).call
   end
 
-  sig { params(key: Symbol).returns(T::Hash[Symbol, String]) }
-  def self.credentials key
+  def self.credentials(key)
     ActiveSupport::EncryptedConfiguration.new(
       config_path: "config/credentials.yml.enc",
       key_path: "config/master.key",
@@ -47,4 +38,3 @@ module Zonesync
     ).config[key]
   end
 end
-

data/zonesync.gemspec

@@ -27,14 +27,10 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "diff-lcs", "~>1.4"
   spec.add_dependency "thor", "~>1.0"
   spec.add_dependency "treetop", "~>1.6"
-  spec.add_dependency "sorbet-runtime"
 
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "webmock"
-  spec.add_development_dependency "sorbet"
-  spec.add_development_dependency "tapioca"
 end

metadata

@@ -1,30 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: zonesync
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Micah Geisel
 - James Ottaway
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-19 00:00:00.000000000 Z
+date: 2025-12-22 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: diff-lcs
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -53,20 +39,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -109,34 +81,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: sorbet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: tapioca
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Sync your Zone file with your DNS host
 email:
 - micah@botandrose.com
@@ -157,6 +101,7 @@ files:
 - lib/zonesync.rb
 - lib/zonesync/cli.rb
 - lib/zonesync/cloudflare.rb
+- lib/zonesync/cloudflare/proxied_support.rb
 - lib/zonesync/diff.rb
 - lib/zonesync/errors.rb
 - lib/zonesync/generate.rb
@@ -175,59 +120,6 @@ files:
 - lib/zonesync/zonefile.rb
 - lib/zonesync/zonefile.treetop
 - log/.keep
-- sorbet/config
-- sorbet/rbi/annotations/.gitattributes
-- sorbet/rbi/annotations/activesupport.rbi
-- sorbet/rbi/annotations/minitest.rbi
-- sorbet/rbi/annotations/webmock.rbi
-- sorbet/rbi/gems/.gitattributes
-- sorbet/rbi/gems/activesupport@8.0.1.rbi
-- sorbet/rbi/gems/addressable@2.8.7.rbi
-- sorbet/rbi/gems/base64@0.2.0.rbi
-- sorbet/rbi/gems/benchmark@0.4.0.rbi
-- sorbet/rbi/gems/bigdecimal@3.1.9.rbi
-- sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
-- sorbet/rbi/gems/connection_pool@2.4.1.rbi
-- sorbet/rbi/gems/crack@1.0.0.rbi
-- sorbet/rbi/gems/date@3.4.1.rbi
-- sorbet/rbi/gems/diff-lcs@1.5.1.rbi
-- sorbet/rbi/gems/drb@2.2.1.rbi
-- sorbet/rbi/gems/erubi@1.13.1.rbi
-- sorbet/rbi/gems/hashdiff@1.1.2.rbi
-- sorbet/rbi/gems/i18n@1.14.6.rbi
-- sorbet/rbi/gems/io-console@0.8.0.rbi
-- sorbet/rbi/gems/logger@1.6.4.rbi
-- sorbet/rbi/gems/minitest@5.25.4.rbi
-- sorbet/rbi/gems/netrc@0.11.0.rbi
-- sorbet/rbi/gems/parallel@1.26.3.rbi
-- sorbet/rbi/gems/polyglot@0.3.5.rbi
-- sorbet/rbi/gems/prism@1.3.0.rbi
-- sorbet/rbi/gems/psych@5.2.2.rbi
-- sorbet/rbi/gems/public_suffix@6.0.1.rbi
-- sorbet/rbi/gems/rake@13.2.1.rbi
-- sorbet/rbi/gems/rbi@0.2.2.rbi
-- sorbet/rbi/gems/rdoc@6.10.0.rbi
-- sorbet/rbi/gems/reline@0.6.0.rbi
-- sorbet/rbi/gems/rexml@3.4.0.rbi
-- sorbet/rbi/gems/rspec-core@3.13.2.rbi
-- sorbet/rbi/gems/rspec-expectations@3.13.3.rbi
-- sorbet/rbi/gems/rspec-mocks@3.13.2.rbi
-- sorbet/rbi/gems/rspec-support@3.13.2.rbi
-- sorbet/rbi/gems/rspec@3.13.0.rbi
-- sorbet/rbi/gems/securerandom@0.4.1.rbi
-- sorbet/rbi/gems/spoom@1.5.0.rbi
-- sorbet/rbi/gems/stringio@3.1.2.rbi
-- sorbet/rbi/gems/tapioca@0.16.6.rbi
-- sorbet/rbi/gems/thor@1.3.2.rbi
-- sorbet/rbi/gems/treetop@1.6.12.rbi
-- sorbet/rbi/gems/tzinfo@2.0.6.rbi
-- sorbet/rbi/gems/uri@1.0.2.rbi
-- sorbet/rbi/gems/webmock@3.24.0.rbi
-- sorbet/rbi/gems/yard-sorbet@0.9.0.rbi
-- sorbet/rbi/gems/yard@0.9.37.rbi
-- sorbet/rbi/todo.rbi
-- sorbet/tapioca/config.yml
-- sorbet/tapioca/require.rb
 - zonesync.gemspec
 homepage: https://github.com/botandrose/zonesync
 licenses:
@@ -235,7 +127,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/botandrose/zonesync
   source_code_uri: https://github.com/botandrose/zonesync
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -251,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.11
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Sync your Zone file with your DNS host
 test_files: []

data/sorbet/config

@@ -1,4 +0,0 @@
---dir
-.
---ignore=tmp/
---ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -1 +0,0 @@
-**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/activesupport.rbi

@@ -1,457 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This file was pulled from a central RBI files repository.
-# Please run `bin/tapioca annotations` to update it.
-
-module ActiveSupport::Testing::Declarative
-  sig { params(name: String, block: T.proc.bind(T.untyped).void).void }
-  def test(name, &block); end
-end
-
-class ActiveSupport::EnvironmentInquirer
-  sig { returns(T::Boolean) }
-  def development?; end
-
-  sig { returns(T::Boolean) }
-  def production?; end
-
-  sig { returns(T::Boolean) }
-  def test?; end
-
-  # @method_missing: delegated to String through ActiveSupport::StringInquirer
-  sig { returns(T::Boolean) }
-  def staging?; end
-end
-
-module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
-  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.untyped).void)).void }
-  def setup(*args, &block); end
-
-  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.untyped).void)).void }
-  def teardown(*args, &block); end
-end
-
-class ActiveSupport::TestCase
-  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).void)).void }
-  def self.setup(*args, &block); end
-
-  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).void)).void }
-  def self.teardown(*args, &block); end
-
-  sig { params(name: String, block: T.proc.bind(T.attached_class).void).void }
-  def self.test(name, &block); end
-end
-
-class ActiveSupport::TimeWithZone
-  # @shim: Methods on ActiveSupport::TimeWithZone are delegated to `Time` using `method_missing
-  include ::DateAndTime::Zones
-
-  # @shim: Methods on ActiveSupport::TimeWithZone are delegated to `Time` using `method_missing
-  include ::DateAndTime::Calculations
-
-  sig { returns(FalseClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always true, `presence` always returns `self`
-  sig { returns(T.self_type) }
-  def presence; end
-
-  # @shim: since `blank?` is always false, `present?` always returns `true`
-  sig { returns(TrueClass) }
-  def present?; end
-end
-
-class Object
-  sig { returns(T::Boolean) }
-  def blank?; end
-
-  sig { returns(FalseClass) }
-  def html_safe?; end
-
-  sig { returns(T.nilable(T.self_type)) }
-  def presence; end
-
-  sig { params(another_object: T.untyped).returns(T.nilable(T.self_type)) }
-  def presence_in(another_object); end
-
-  sig { returns(T::Boolean) }
-  def present?; end
-end
-
-class Hash
-  sig { returns(T::Boolean) }
-  def blank?; end
-
-  sig { returns(T::Boolean) }
-  def present?; end
-
-  sig { returns(T::Boolean) }
-  def extractable_options?; end
-end
-
-class Array
-  sig { returns(T::Boolean) }
-  def blank?; end
-
-  sig { returns(T::Boolean) }
-  def present?; end
-
-  sig { params(position: Integer).returns(T.self_type) }
-  def from(position); end
-
-  sig { params(position: Integer).returns(T.self_type) }
-  def to(position); end
-
-  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
-  def including(*elements); end
-
-  sig { params(elements: T.untyped).returns(T.self_type) }
-  def excluding(*elements); end
-
-  sig { params(elements: T.untyped).returns(T.self_type) }
-  def without(*elements); end
-
-  sig { returns(T.nilable(Elem)) }
-  def second; end
-
-  sig { returns(T.nilable(Elem)) }
-  def third; end
-
-  sig { returns(T.nilable(Elem)) }
-  def fourth; end
-
-  sig { returns(T.nilable(Elem)) }
-  def fifth; end
-
-  sig { returns(T.nilable(Elem)) }
-  def forty_two; end
-
-  sig { returns(T.nilable(Elem)) }
-  def third_to_last; end
-
-  sig { returns(T.nilable(Elem)) }
-  def second_to_last; end
-
-  sig { params(options: T::Hash[T.untyped, T.untyped]).returns(String) }
-  def to_sentence(options = {}); end
-
-  sig { params(format: Symbol).returns(String) }
-  def to_fs(format = :default); end
-
-  sig { params(format: Symbol).returns(String) }
-  def to_formatted_s(format = :default); end
-
-  sig { returns(String) }
-  def to_xml; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def extract_options!; end
-
-  sig { type_parameters(:FillType).params(number: Integer, fill_with: T.type_parameter(:FillType), block: T.nilable(T.proc.params(group: T::Array[T.any(Elem, T.type_parameter(:FillType))]).void)).returns(T::Array[T::Array[T.any(Elem, T.type_parameter(:FillType))]]) }
-  def in_groups(number, fill_with = T.unsafe(nil), &block); end
-
-  sig { type_parameters(:FillType).params(number: Integer, fill_with: T.type_parameter(:FillType), block: T.nilable(T.proc.params(group: T::Array[T.any(Elem, T.type_parameter(:FillType))]).void)).returns(T::Array[T::Array[T.any(Elem, T.type_parameter(:FillType))]]) }
-  def in_groups_of(number, fill_with = T.unsafe(nil), &block); end
-
-  sig { params(value: T.untyped, block: T.nilable(T.proc.params(element: Elem).returns(T.untyped))).returns(T::Array[T::Array[Elem]]) }
-  def split(value = nil, &block); end
-
-  sig { params(block: T.nilable(T.proc.params(element: Elem).returns(T.untyped))).returns(T.any(T::Array[Elem], T::Enumerator[Elem])) }
-  def extract!(&block); end
-
-  sig { returns(ActiveSupport::ArrayInquirer) }
-  def inquiry; end
-
-  sig { params(object: T.untyped).returns(T::Array[T.untyped]) }
-  def self.wrap(object); end
-end
-
-class Date
-  sig { returns(FalseClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always true, `presence` always returns `self`
-  sig { returns(T.self_type) }
-  def presence; end
-
-  # @shim: since `blank?` is always false, `present?` always returns `true`
-  sig { returns(TrueClass) }
-  def present?; end
-end
-
-class DateTime
-  sig { returns(FalseClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always true, `presence` always returns `self`
-  sig { returns(T.self_type) }
-  def presence; end
-
-  # @shim: since `blank?` is always false, `present?` always returns `true`
-  sig { returns(TrueClass) }
-  def present?; end
-end
-
-class NilClass
-  sig { returns(TrueClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always false, `presence` always returns `nil`
-  sig { returns(NilClass) }
-  def presence; end
-
-  # @shim: since `blank?` is always true, `present?` always returns `false`
-  sig { returns(FalseClass) }
-  def present?; end
-end
-
-class FalseClass
-  sig { returns(TrueClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always false, `presence` always returns `nil`
-  sig { returns(NilClass) }
-  def presence; end
-
-  # @shim: since `blank?` is always true, `present?` always returns `false`
-  sig { returns(FalseClass) }
-  def present?; end
-end
-
-class TrueClass
-  sig { returns(FalseClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always true, `presence` always returns `self`
-  sig { returns(T.self_type) }
-  def presence; end
-
-  # @shim: since `blank?` is always false, `present?` always returns `true`
-  sig { returns(TrueClass) }
-  def present?; end
-end
-
-class Numeric
-  sig { returns(FalseClass) }
-  def blank?; end
-
-  sig { returns(TrueClass) }
-  def html_safe?; end
-
-  # @shim: since `present?` is always true, `presence` always returns `self`
-  sig { returns(T.self_type) }
-  def presence; end
-
-  # @shim: since `blank?` is always false, `present?` always returns `true`
-  sig { returns(TrueClass) }
-  def present?; end
-end
-
-class Time
-  sig { returns(FalseClass) }
-  def blank?; end
-
-  # @shim: since `present?` is always true, `presence` always returns `self`
-  sig { returns(T.self_type) }
-  def presence; end
-
-  # @shim: since `blank?` is always false, `present?` always returns `true`
-  sig { returns(TrueClass) }
-  def present?; end
-
-  sig { returns(ActiveSupport::TimeZone) }
-  def self.zone; end
-
-  sig { returns(T.any(ActiveSupport::TimeWithZone, ::Time)) }
-  def self.current; end
-end
-
-class Symbol
-  sig { returns(T::Boolean) }
-  def blank?; end
-
-  sig { returns(T::Boolean) }
-  def present?; end
-
-  # alias for `#start_with?`
-  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
-  def starts_with?(*string_or_regexp); end
-
-  # alias for `#end_with?`
-  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
-  def ends_with?(*string_or_regexp); end
-end
-
-class String
-  sig { returns(TrueClass) }
-  def acts_like_string?; end
-
-  # This is the subset of `#[]` sigs that have just 1 parameter.
-  # https://github.com/sorbet/sorbet/blob/40ad87b4dc7be23fa00c1369ac9f927053c68907/rbi/core/string.rbi#L270-L303
-  sig { params(position: Integer).returns(T.nilable(String)) }
-  sig { params(position: T.any(T::Range[Integer], Regexp)).returns(T.nilable(String)) }
-  sig { params(position: String).returns(T.nilable(String)) }
-  def at(position); end
-
-  sig { returns(String) }
-  def as_json; end
-
-  sig { returns(T::Boolean) }
-  def blank?; end
-
-  sig { params(first_letter: Symbol).returns(String) }
-  def camelcase(first_letter = :upper); end
-
-  sig { params(first_letter: Symbol).returns(String) }
-  def camelize(first_letter = :upper); end
-
-  sig { returns(String) }
-  def classify; end
-
-  sig { returns(T.untyped) }
-  def constantize; end
-
-  sig { returns(String) }
-  def dasherize; end
-
-  sig { returns(String) }
-  def deconstantize; end
-
-  sig { returns(String) }
-  def demodulize; end
-
-  # alias for `#end_with?`
-  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
-  def ends_with?(*string_or_regexp); end
-
-  sig { returns(String) }
-  def downcase_first; end
-
-  sig { params(string: String).returns(T::Boolean) }
-  def exclude?(string); end
-
-  sig { params(limit: Integer).returns(String) }
-  def first(limit = 1); end
-
-  sig { params(separate_class_name_and_id_with_underscore: T::Boolean).returns(String) }
-  def foreign_key(separate_class_name_and_id_with_underscore = true); end
-
-  sig { params(position: Integer).returns(String) }
-  def from(position); end
-
-  sig { returns(ActiveSupport::SafeBuffer) }
-  def html_safe; end
-
-  sig { params(capitalize: T::Boolean, keep_id_suffix: T::Boolean).returns(String) }
-  def humanize(capitalize: true, keep_id_suffix: false); end
-
-  sig { params(zone: T.nilable(T.any(ActiveSupport::TimeZone, String))).returns(T.any(ActiveSupport::TimeWithZone, Time)) }
-  def in_time_zone(zone = ::Time.zone); end
-
-  sig { params(amount: Integer, indent_string: T.nilable(String), indent_empty_lines: T::Boolean).returns(String) }
-  def indent(amount, indent_string = nil, indent_empty_lines = false); end
-
-  sig { params(amount: Integer, indent_string: T.nilable(String), indent_empty_lines: T::Boolean).returns(T.nilable(String)) }
-  def indent!(amount, indent_string = nil, indent_empty_lines = false); end
-
-  sig { returns(ActiveSupport::StringInquirer) }
-  def inquiry; end
-
-  sig { returns(T::Boolean) }
-  def is_utf8?; end
-
-  sig { params(limit: Integer).returns(String) }
-  def last(limit = 1); end
-
-  sig { returns(ActiveSupport::Multibyte::Chars) }
-  def mb_chars; end
-
-  sig { params(separator: String, preserve_case: T::Boolean, locale: T.nilable(Symbol)).returns(String) }
-  def parameterize(separator: "-", preserve_case: false, locale: nil); end
-
-  sig { params(count: T.nilable(T.any(Integer, Symbol)), locale: T.nilable(Symbol)).returns(String) }
-  def pluralize(count = nil, locale = :en); end
-
-  sig { returns(T::Boolean) }
-  def present?; end
-
-  sig { params(patterns: T.any(String, Regexp)).returns(String) }
-  def remove(*patterns); end
-
-  sig { params(patterns: T.any(String, Regexp)).returns(String) }
-  def remove!(*patterns); end
-
-  sig { returns(T.untyped) }
-  def safe_constantize; end
-
-  sig { params(locale: Symbol).returns(String) }
-  def singularize(locale = :en); end
-
-  sig { returns(String) }
-  def squish; end
-
-  sig { returns(String) }
-  def squish!; end
-
-  # alias for `#start_with?`
-  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
-  def starts_with?(*string_or_regexp); end
-
-  sig { returns(String) }
-  def strip_heredoc; end
-
-  sig { returns(String) }
-  def tableize; end
-
-  sig { params(keep_id_suffix: T::Boolean).returns(String) }
-  def titlecase(keep_id_suffix: false); end
-
-  sig { params(keep_id_suffix: T::Boolean).returns(String) }
-  def titleize(keep_id_suffix: false); end
-
-  sig { params(position: Integer).returns(String) }
-  def to(position); end
-
-  sig { returns(::Date) }
-  def to_date; end
-
-  sig { returns(::DateTime) }
-  def to_datetime; end
-
-  sig { params(form: T.nilable(Symbol)).returns(T.nilable(Time)) }
-  def to_time(form = :local); end
-
-  sig { params(truncate_to: Integer, options: T::Hash[Symbol, T.anything]).returns(String) }
-  def truncate(truncate_to, options = {}); end
-
-  sig { params(truncate_to: Integer, omission: T.nilable(String)).returns(String) }
-  def truncate_bytes(truncate_to, omission: "…"); end
-
-  sig { params(words_count: Integer, options: T::Hash[Symbol, T.anything]).returns(String) }
-  def truncate_words(words_count, options = {}); end
-
-  sig { returns(String) }
-  def underscore; end
-
-  sig { returns(String) }
-  def upcase_first; end
-end
-
-class ActiveSupport::ErrorReporter
-  # @version >= 7.1.0.beta1
-  sig { type_parameters(:Block, :Fallback).params(error_classes: T.class_of(Exception), severity: T.nilable(Symbol), context: T.nilable(T::Hash[Symbol, T.untyped]), fallback: T.nilable(T.proc.returns(T.type_parameter(:Fallback))), source: T.nilable(String), blk: T.proc.returns(T.type_parameter(:Block))).returns(T.any(T.type_parameter(:Block), T.type_parameter(:Fallback))) }
-  def handle(*error_classes, severity: T.unsafe(nil), context: T.unsafe(nil), fallback: T.unsafe(nil), source: T.unsafe(nil), &blk); end
-
-  # @version >= 7.1.0.beta1
-  sig { type_parameters(:Block).params(error_classes: T.class_of(Exception), severity: T.nilable(Symbol), context: T.nilable(T::Hash[Symbol, T.untyped]), source: T.nilable(String), blk: T.proc.returns(T.type_parameter(:Block))).returns(T.type_parameter(:Block)) }
-  def record(*error_classes, severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil), &blk); end
-
-  # @version >= 7.1.0.beta1
-  sig { params(error: Exception, handled: T::Boolean, severity: T.nilable(Symbol), context: T::Hash[Symbol, T.untyped], source: T.nilable(String)).void }
-  def report(error, handled: true, severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil)); end
-
-  # @version >= 7.2.0.beta1
-  sig { params(error: T.any(Exception, String), severity: T.nilable(Symbol), context: T::Hash[Symbol, T.untyped], source: T.nilable(String)).void }
-  def unexpected(error, severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil)); end
-end