module EncodedId
  module Rails
    VERSION: ::String

    class Configuration
      attr_accessor salt: ::String
      attr_accessor group_separator: ::String
      attr_accessor character_group_size: ::Integer
      attr_accessor alphabet: ::EncodedId::Alphabet
      attr_accessor id_length: ::Integer
      attr_accessor slugged_id_separator: ::String

      def initialize: () -> void
    end

    attr_reader self.configuration: Configuration

    def self.configure: () { (Configuration config) -> void } -> void

    class Coder
      def initialize: (salt: ::String, id_length: ::Integer, character_group_size: ::Integer, separator: ::String, alphabet: ::EncodedId::Alphabet) -> void
      def encode: (::Integer | ::Array[::Integer]) -> String
      def decode: (::String) -> ::Array[::Integer]?

      @salt: ::String
      @id_length: ::Integer
      @character_group_size: ::Integer
      @separator: ::String
      @alphabet: ::EncodedId::Alphabet

      private

      def coder: -> ::EncodedId::ReversibleId
    end

    class Salt
      def initialize: (Class klass, ::String salt) -> void

      @klass: Class
      @salt: ::String

      def generate!: -> ::String
    end

    class SluggedId
      def initialize: (untyped from_object, ?slug_method: ::Symbol, ?id_method: ::Symbol, ?separator: ::String)-> void

      @from_object: untyped
      @slug_method: ::Symbol
      @id_method: ::Symbol
      @separator: ::String

      def slugged_id: -> ::String
    end

    class SluggedIdParser
      def initialize: (::String slugged_id, ?separator: ::String) -> void

      attr_reader slug: ::String?
      attr_reader id: ::String?
    end

    module EncoderMethods
      def encode_encoded_id: (untyped id, ?::Hash[::Symbol, untyped] options) -> ::String
      def decode_encoded_id: (::String slugged_encoded_id, ?::Hash[::Symbol, untyped] options) -> ::Array[::Integer]?
      def encoded_id_salt: () -> ::String
      def encoded_id_parser: (::String slugged_encoded_id) -> ::EncodedId::Rails::SluggedIdParser
      def encoded_id_coder: (?::Hash[::Symbol, untyped] options) -> ::EncodedId::Rails::Coder
    end

    interface _ActiveRecordFinderMethod
      def find_by: (*untyped) -> (nil | untyped)
    end

    module FinderMethods : EncoderMethods, _ActiveRecordFinderMethod
      def find_by_encoded_id: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> untyped?
      def find_by_encoded_id!: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> untyped
    end

    interface _ActiveRecordQueryMethod
      def where: (*untyped) -> untyped
    end

    module QueryMethods : EncoderMethods, _ActiveRecordQueryMethod
      def where_encoded_id: (::String slugged_encoded_id) -> untyped
    end

    module Model : ActiveRecord::Base
      extend ActiveRecord::FinderMethods
      extend ActiveRecord::QueryMethods

      extend EncoderMethods
      extend FinderMethods
      extend QueryMethods

      @encoded_id: ::String
      @slugged_encoded_id: ::String

      def encoded_id: () -> ::String
      def slugged_encoded_id: (?with: ::Symbol) -> ::String
      def name_for_encoded_id_slug: () -> ::String
    end

    interface _ActiveRecordToParam
      def to_param: () -> ::String
    end

    module PathParam : Model, _ActiveRecordToParam
    end

    module SluggedPathParam : Model, _ActiveRecordToParam
    end
  end

  Model: singleton(Rails::Model)
  PathParam: singleton(Rails::PathParam)
  SluggedPathParam: singleton(Rails::SluggedPathParam)
end