torque-postgresql 4.0.1 → 4.1.1

data/sig/torque/postgresql/associations/preloader/association.rbs

@@ -0,0 +1,32 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Preloader
+        module Association
+          @run: bool
+          @records_by_owner: Hash[record, Array[record]]
+          @preloaded_records: Array[record]
+          @owners_by_key: Hash[untyped, Array[record]]
+
+          def connected_through_array?: () -> untyped
+          def run: () -> self
+          def set_inverse: (record record) -> untyped
+          def load_records: (?Array[record]? raw_records) -> untyped
+          def owners_by_key: () -> Hash[untyped, Array[record]]
+
+          private
+
+          def run_array_for_belongs_to_many: () -> untyped
+          def run_array_for_has_many: () -> untyped
+          def records_for: (Array[untyped] ids) ?{ (record) -> void } -> Array[record]
+          def associate_records_to_owner: (record owner, Array[record] records) -> untyped
+          def groupped_records: () -> Hash[untyped, Array[record]]
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::Preloader::Association
+  prepend Torque::PostgreSQL::Associations::Preloader::Association
+end

data/sig/torque/postgresql/associations/preloader/loader_query.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Preloader
+        module LoaderQuery
+          @foreign_column: column?
+
+          def foreign_column: () -> column?
+          def load_records_for_keys: (Enumerable[untyped] keys) ?{ (record) -> void } -> (Array[record] | relation)
+          def query_condition_for: (Enumerable[untyped] keys) -> arel_node?
+          def connected_through_array?: () -> untyped
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::Preloader::Association::LoaderQuery
+  prepend Torque::PostgreSQL::Associations::Preloader::LoaderQuery
+end

data/sig/torque/postgresql/associations/preloader.rbs

@@ -0,0 +1,8 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Preloader
+      end
+    end
+  end
+end

data/sig/torque/postgresql/associations.rbs

@@ -0,0 +1,17 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      class BelongsToManyAssociation
+        prepend ForeignAssociation
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::HasManyAssociation
+  prepend Torque::PostgreSQL::Associations::ForeignAssociation
+end
+
+class ActiveRecord::Associations::JoinDependency
+  prepend Torque::PostgreSQL::Associations::JoinDependency
+end

data/sig/torque/postgresql/attributes/base.rbs

@@ -0,0 +1,37 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Base
+        include ActiveModel::Model
+        include ActiveModel::Attributes
+        include ActiveModel::Serialization
+        include ActiveModel::Serializers::JSON
+        include ActiveModel::Dirty
+        include ActiveModel::Validations::Callbacks
+        include SimpleEnum
+        extend SimpleEnum::ClassMethods
+        include ActiveRecord::Store
+        include ActiveModel::Attributes::Normalization
+        include ActiveRecord::Encryption::EncryptableRecord
+
+        def self.filter_attributes: () -> Array[Symbol | String | Regexp | Proc]
+        def self.filter_attributes=: (Array[Symbol | String | Regexp | Proc] value) -> Array[Symbol | String | Regexp | Proc]
+        def self.columns_hash: () -> Hash[String, column]
+        def self.encrypts: (*column_ref names, **untyped options) -> untyped
+        def self.inspection_filter: () -> ActiveSupport::ParameterFilter
+
+        def inspect: () -> String
+        def []: (column_ref key) -> untyped
+        def []=: (column_ref key, untyped value) -> untyped
+        def ==: (untyped other) -> bool
+        alias eql? ==
+        def empty?: () -> bool
+        def hash: () -> Integer
+        def to_h: () -> Hash[Symbol, untyped]
+        def type_for_attribute: (column_ref name) ?{ (?) -> untyped } -> type_caster
+        def read_attribute_before_type_cast: (column_ref name) -> untyped
+        def read_attribute_for_database: (column_ref name) -> untyped
+      end
+    end
+  end
+end

data/sig/torque/postgresql/attributes/builder/enum.rbs

@@ -0,0 +1,38 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        class Enum
+          type methods = Hash[String, [String, String, String, String]]
+
+          VALID_TYPES: Array[Symbol]
+          FN: String
+
+          attr_accessor klass: model
+          attr_accessor attribute: String
+          attr_accessor subtype: Adapter::OID::Enum
+          attr_accessor options: Hash[Symbol, untyped]
+          attr_accessor values: Array[String]
+          attr_accessor klass_module: Module?
+          attr_accessor instance_module: Module?
+
+          @values_methods: methods
+
+          def initialize: (model klass, column_ref attribute, Hash[Symbol, untyped] options) -> void
+          def values_methods: () -> methods
+          def set_features?: () -> bool
+          def conflicting?: () -> untyped
+          def build: () -> untyped
+
+          private
+
+          def dangerous?: (String | Symbol method_name, ?bool class_method) -> untyped
+          def plural: () -> untyped
+          def set_scopes: () -> untyped
+          def stringify: () -> untyped
+          def all_values: () -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/attributes/builder/full_text_search.rbs

@@ -0,0 +1,27 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        class FullTextSearch
+          attr_accessor klass: model
+          attr_accessor attribute: column_ref
+          attr_accessor options: Hash[Symbol, untyped]
+          attr_accessor klass_module: Module?
+          attr_accessor default_rank: String?
+          attr_accessor default_mode: Symbol
+          attr_accessor default_order: (:asc | :desc | false)
+          attr_accessor default_language: String | Symbol
+
+          @scope_name: String
+
+          def initialize: (model klass, column_ref attribute, ?Hash[Symbol, untyped] options) -> void
+          def scope_name: () -> String
+          def conflicting?: () -> untyped
+          def build: () -> untyped
+          def add_scope_to_module: () -> untyped
+          def scope_args: () -> String
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/attributes/builder/period.rbs

@@ -0,0 +1,106 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        class Period
+          type threshold = Symbol | ActiveSupport::Duration | Numeric | nil
+          type method_names = Hash[Symbol, String | Symbol]
+
+          DIRECT_ACCESS_REGEX: Regexp
+          SUPPORTED_TYPES: Array[Symbol]
+          CURRENT_GETTERS: Hash[Symbol, String]
+          TYPE_CASTERS: Hash[Symbol, Symbol]
+          FN: String
+
+          attr_accessor klass: model
+          attr_accessor attribute: String
+          attr_accessor options: Hash[Symbol, untyped]
+          attr_accessor type: Symbol
+          attr_accessor default: bool
+          attr_accessor current_getter: String
+          attr_accessor type_caster: Symbol
+          attr_writer threshold: threshold
+          attr_accessor dynamic_threshold: untyped
+          attr_accessor klass_module: Module?
+          attr_accessor instance_module: Module?
+
+          @threshold: threshold
+          @method_names: method_names
+          @klass_method_names: method_names
+          @instance_method_names: method_names
+          @arel_attribute: String
+          @arel_default_sql: String
+          @arel_threshold_value: String?
+          @arel_start_at: String
+          @arel_finish_at: String
+          @arel_real_start_at: String
+          @arel_real_finish_at: String
+          @arel_real_attribute: String
+
+          def initialize: (model klass, column_ref attribute, Hash[Symbol, untyped] options) -> void
+          def threshold: () -> threshold
+          def method_names: () -> method_names
+          def klass_method_names: () -> method_names
+          def instance_method_names: () -> method_names
+          def conflicting?: () -> untyped
+          def build: () -> untyped
+          def build_method_helper: (Symbol type, Symbol key, ?Array[String] args) -> untyped
+
+          private
+
+          def default_method_names: () -> method_names
+          def dangerous?: (String | Symbol method_name, ?bool class_method) -> untyped
+          def define_string_method: (String | Symbol name, String body, ?Array[String] args) -> String
+          def arel_attribute: () -> String
+          def arel_default_sql: () -> String
+          def arel_sql_bind: (String value) -> String
+          def arel_threshold_value: () -> String?
+          def arel_start_at: () -> String
+          def arel_finish_at: () -> String
+          def arel_real_start_at: () -> String
+          def arel_real_finish_at: () -> String
+          def arel_real_attribute: () -> String
+          def arel_convert_to_type: (String left, ?String? right, ?Symbol? set_type) -> String
+          def arel_named_function: (String | Symbol name, *String args) -> String
+          def arel_nullif: (*String args) -> String
+          def arel_coalesce: (*String args) -> String
+          def arel_empty_value: () -> String
+          def arel_daterange: (?bool real) -> String
+          def arel_check_condition: (Symbol type) -> String
+          def arel_formatting_value: (?String? condition, ?String value, ?cast: Symbol?) -> String
+          def arel_formatting_left_right: (String condition, ?Symbol? set_type, ?cast: Symbol?) -> String
+          def klass_current_on: () -> String
+          def klass_current: () -> String
+          def klass_not_current: () -> String
+          def klass_containing: () -> String
+          def klass_not_containing: () -> String
+          def klass_overlapping: () -> String
+          def klass_not_overlapping: () -> String
+          def klass_starting_after: () -> String
+          def klass_starting_before: () -> String
+          def klass_finishing_after: () -> String
+          def klass_finishing_before: () -> String
+          def klass_real_containing: () -> String
+          def klass_real_overlapping: () -> String
+          def klass_real_starting_after: () -> String
+          def klass_real_starting_before: () -> String
+          def klass_real_finishing_after: () -> String
+          def klass_real_finishing_before: () -> String
+          def klass_containing_date: () -> String
+          def klass_not_containing_date: () -> String
+          def klass_overlapping_date: () -> String
+          def klass_not_overlapping_date: () -> String
+          def klass_real_containing_date: () -> String
+          def klass_real_overlapping_date: () -> String
+          def instance_current?: () -> String
+          def instance_current_on?: () -> String
+          def instance_start: () -> String
+          def instance_finish: () -> String
+          def instance_real: () -> String
+          def instance_real_start: () -> String
+          def instance_real_finish: () -> String
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/attributes/builder.rbs

@@ -0,0 +1,19 @@
+# The macros these builders install on models (torque_enum, torque_enum_set,
+# period_for, torque_search_for, struct_for) are declared under their default
+# names next to each feature. The per-attribute methods they generate, like
+# `roles`, `admin?`, the period scopes and the search scope, depend on the
+# model's columns and on config, so RBS cannot express them.
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        type builder_class = singleton(Enum) | singleton(Period) | singleton(FullTextSearch)
+
+        def self.include_on: (model klass, Symbol method_name, builder_class builder_klass, **untyped extra) ?{ (Enum | Period | FullTextSearch builder) -> void } -> untyped
+        def self.search_vector_options: (columns: Adapter::search_columns, ?language: String | Symbol | nil, ?stored: bool, **untyped options) -> Hash[Symbol, untyped]
+        def self.to_search_weights: (Adapter::search_columns columns) -> Hash[String, String]
+        def self.to_search_vector_operation: (String | Symbol | nil language, Hash[String, String] weights) -> arel_node
+      end
+    end
+  end
+end

data/sig/torque/postgresql/attributes/composite.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Composite < Base
+        @type_name: String
+        @columns: Hash[String, type_caster]
+        @load_columns_monitor: Monitor
+
+        def self.type_name=: (String value) -> String
+        def self.lookup: (table_ref name) -> singleton(Composite)
+        def self.inherited: (singleton(Composite) subclass) -> untyped
+        def self.type_name: () -> String
+        def self.columns: () -> Hash[String, type_caster]?
+        def self.load_columns: () -> untyped
+        def self.reset_columns!: () -> untyped
+        def self.new: (*untyped args, **untyped xargs) ?{ (?) -> untyped } -> instance
+        def self.encrypts: (*column_ref names, **untyped options) -> untyped
+        def self.enum: (column_ref name, ?SimpleEnum::values values, **untyped options) -> untyped
+
+        private
+
+        def self.resolve: (singleton(Composite) klass, String name) -> singleton(Composite)
+      end
+    end
+
+    class Composite = Attributes::Composite
+  end
+end

data/sig/torque/postgresql/attributes/enum.rbs

@@ -0,0 +1,69 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Enum < String
+        include Comparable
+        extend Enumerable[untyped]
+
+        class EnumError < ArgumentError
+        end
+
+        LAZY_VALUE: String
+
+        @values: Array[String]
+        @type_name: String
+        @load_values_monitor: Monitor
+
+        def self.each: (*untyped) ?{ (instance) -> untyped } -> untyped
+        def self.sample: (*untyped) -> instance?
+        def self.size: () -> Integer
+        def self.length: () -> Integer
+        def self.lookup: (table_ref name) -> singleton(Enum)
+        def self.include_on: (model klass, ?Symbol? method_name) -> untyped
+        def self.new: (untyped value) -> untyped
+        def self.inherited: (singleton(Enum) subclass) -> untyped
+        def self.values: () -> Array[String]?
+        def self.keys: () -> Array[Symbol]
+        def self.members: () -> Array[instance]
+        def self.texts: () -> Array[String]
+        def self.to_options: () -> Array[[String, String]]
+        def self.fetch: (String | Symbol value, *untyped) -> instance?
+        alias self.[] self.fetch
+        def self.type_name: () -> String
+        def self.valid?: (untyped value) -> bool
+        def self.scope: (arel_attribute attribute, String | Symbol value) -> ::Arel::Nodes::Equality
+
+        private
+
+        def self.respond_to_missing?: (Symbol method_name, ?bool include_private) -> bool
+        def self.method_missing: (Symbol method_name, *untyped arguments) -> untyped
+
+        public
+
+        def initialize: (untyped value) -> void
+        def <=>: (untyped other) -> Integer?
+        def ==: (untyped other) -> bool
+        alias eql? ==
+        def nil?: () -> bool
+        alias empty? nil?
+        def replace: (String | Symbol value) -> self
+        def text: (?column_ref? attr, ?untyped model) -> String
+        def to_s: () -> String
+        def to_i: () -> Integer?
+        def inspect: () -> String
+
+        private
+
+        def i18n_keys: (?column_ref? attr, ?untyped model) -> Array[Symbol]
+        def respond_to_missing?: (Symbol method_name, ?bool include_private) -> untyped
+        def method_missing: (Symbol method_name, *untyped arguments) -> untyped
+        def raise_invalid: (untyped value) -> bot
+        def raise_comparison: (untyped other) -> bot
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.torque_enum: (*Torque::PostgreSQL::column_ref attributes, ?only: Array[Torque::PostgreSQL::column_ref] | Torque::PostgreSQL::column_ref, ?except: Array[Torque::PostgreSQL::column_ref] | Torque::PostgreSQL::column_ref, ?prefix: bool | Torque::PostgreSQL::column_ref, ?suffix: bool | Torque::PostgreSQL::column_ref, ?force: bool) -> untyped
+end

data/sig/torque/postgresql/attributes/enum_set.rbs

@@ -0,0 +1,75 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class EnumSet < Set[untyped]
+        include Comparable
+        extend Enumerable[untyped]
+
+        class EnumSetError < Enum::EnumError
+        end
+
+        @type_name: String
+        @hash: Hash[Enum, bool]
+
+        def self.each: (*untyped) ?{ (Enum) -> untyped } -> untyped
+        def self.values: () -> Array[String]?
+        def self.keys: () -> Array[Symbol]
+        def self.members: () -> Array[Enum]
+        def self.texts: () -> Array[String]
+        def self.to_options: () -> Array[[String, String]]
+        def self.valid?: (untyped value) -> bool
+        def self.size: () -> Integer
+        def self.length: () -> Integer
+        def self.connection_specification_name: (*untyped) -> untyped
+        def self.lookup: (table_ref name, singleton(Enum) enum_klass) -> singleton(EnumSet)
+        def self.include_on: (model klass, ?Symbol? method_name) -> untyped
+        def self.enum_source: () -> singleton(Enum)
+        def self.sample: () -> untyped
+        def self.new: (*untyped values) -> untyped
+        def self.type_name: () -> String
+        def self.fetch: (String | Symbol value, *untyped) -> untyped
+        alias self.[] self.fetch
+        def self.power: (*untyped values) -> Integer?
+        def self.scope: (arel_attribute attribute, untyped value) -> ::Arel::Nodes::InfixOperation
+
+        private
+
+        def self.respond_to_missing?: (Symbol method_name, ?bool include_private) -> bool
+        def self.method_missing: (Symbol method_name, *untyped arguments) -> untyped
+
+        public
+
+        def initialize: (*untyped values) -> void
+        def <=>: (untyped other) -> Integer?
+        def ==: (untyped other) -> bool
+        alias eql? ==
+        def replace: (*untyped values) -> self
+        def text: (?column_ref? attr, ?untyped model) -> String
+        alias to_s text
+        def to_i: () -> Integer?
+        def inspect: () -> String
+        def []=: (untyped key, untyped value) -> untyped
+        def merge: (Enumerable[untyped] other) -> self
+        def &: (Enumerable[untyped] other) -> untyped
+        def add: (untyped other) -> self
+        def delete: (untyped other) -> self
+        def include?: (untyped other) -> bool?
+        def subtract: (untyped other) -> self
+
+        private
+
+        def instantiate: (untyped value) -> untyped
+        def transform_power: (Integer value) -> Array[Enum]
+        def transform_values: (Array[untyped] values) -> Array[Enum]
+        def respond_to_missing?: (Symbol method_name, ?bool include_private) -> untyped
+        def method_missing: (Symbol method_name, *untyped arguments) -> untyped
+        def raise_invalid: (untyped value) -> bot
+        def raise_comparison: (untyped other) -> bot
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.torque_enum_set: (*Torque::PostgreSQL::column_ref attributes, ?only: Array[Torque::PostgreSQL::column_ref] | Torque::PostgreSQL::column_ref, ?except: Array[Torque::PostgreSQL::column_ref] | Torque::PostgreSQL::column_ref, ?prefix: bool | Torque::PostgreSQL::column_ref, ?suffix: bool | Torque::PostgreSQL::column_ref, ?force: bool) -> untyped
+end

data/sig/torque/postgresql/attributes/full_text_search.rbs

@@ -0,0 +1,13 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module FullTextSearch
+        def self.include_on: (model klass, ?Symbol? method_name) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.torque_search_for: (*Torque::PostgreSQL::column_ref attributes, ?with_rank: bool | Torque::PostgreSQL::column_ref, ?mode: Symbol, ?order: bool | Symbol, ?language: String | Symbol, ?prefix: Torque::PostgreSQL::column_ref, ?suffix: Torque::PostgreSQL::column_ref, ?force: bool) -> untyped
+end

data/sig/torque/postgresql/attributes/lazy.rbs

@@ -0,0 +1,17 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Lazy < BasicObject
+        @klass: Class
+        @values: ::Array[untyped]
+
+        def initialize: (Class klass, *untyped values) -> void
+        def ==: (untyped other) -> bool
+        def nil?: () -> true
+        def inspect: () -> String
+        def __class__: () -> singleton(Lazy)
+        def method_missing: (Symbol name, *untyped args) ?{ (?) -> untyped } -> untyped
+      end
+    end
+  end
+end

data/sig/torque/postgresql/attributes/lquery.rbs

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class LQuery
+        include Enumerable[untyped]
+
+        MARKERS: Regexp
+        LEVEL: Regexp
+        VARIANT: Regexp
+
+        attr_reader items: Array[untyped]
+
+        @pattern: Regexp
+
+        def inspect: () -> String
+        def each: (*untyped) ?{ (untyped) -> untyped } -> untyped
+        def size: () -> Integer
+        def empty?: () -> bool
+        def []: (*untyped) -> untyped
+
+        def self.[]: (*untyped items) -> instance
+
+        def initialize: (?untyped value, ?sanitize: bool) -> void
+        def to_s: () -> String
+        def pattern?: () -> bool
+        def pattern: () -> Regexp
+        def match?: (LTree | untyped path) -> bool
+        def =~: (LTree | untyped path) -> Integer?
+        def ==: (untyped other) -> bool
+        alias eql? ==
+        def hash: () -> Integer
+
+        private
+
+        def type: () -> Adapter::OID::Lquery
+        def compile: () -> Regexp
+        def compile_level: (String text) -> String
+        def compile_variants: (Array[String] variants) -> String
+        def compile_variant: (String text) -> String
+        def label: (String name, bool prefix) -> String
+        def words: (String name, bool prefix) -> String
+        def quantifier: (MatchData match) -> String
+      end
+    end
+
+    class LQuery = Attributes::LQuery
+  end
+end

data/sig/torque/postgresql/attributes/ltree.rbs

@@ -0,0 +1,46 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class LTree
+        include Enumerable[untyped]
+
+        attr_reader items: Array[untyped]
+
+        def inspect: () -> String
+        def each: (*untyped) ?{ (untyped) -> untyped } -> untyped
+        def size: () -> Integer
+        def empty?: () -> bool
+        def []: (*untyped) -> untyped
+        alias depth size
+
+        def self.[]: (*untyped items) -> instance
+        def self.compatible?: (untyped value) -> bool
+        def self.compatible: (untyped value) -> untyped
+
+        def initialize: (?untyped value, ?sanitize: bool) -> void
+        def to_s: () -> String
+        def ==: (untyped other) -> bool
+        alias eql? ==
+        def hash: () -> Integer
+        def root?: () -> bool
+        def root: () -> instance
+        def parent: () -> instance?
+        def /: (untyped other) -> instance
+        alias + /
+        def ancestor_of?: (untyped other) -> bool
+        alias covers? ancestor_of?
+        def descendant_of?: (untyped other) -> bool
+        alias covered_by? descendant_of?
+        def lca: (*untyped others) -> instance
+        def index_of: (untyped subpath, ?Integer offset) -> Integer
+
+        private
+
+        def type: () -> Adapter::OID::Ltree
+        def common_prefix: (Array[untyped] one, Array[untyped] other) -> Array[untyped]
+      end
+    end
+
+    class LTree = Attributes::LTree
+  end
+end

data/sig/torque/postgresql/attributes/period.rbs

@@ -0,0 +1,13 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Period
+        def self.include_on: (model klass, ?Symbol? method_name) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.period_for: (*Torque::PostgreSQL::column_ref attributes, ?pessimistic: bool, ?threshold: bool | Torque::PostgreSQL::column_ref | ActiveSupport::Duration | Numeric, ?methods: Hash[Symbol, Torque::PostgreSQL::column_ref], ?prefixed: bool, ?force: bool) -> untyped
+end

data/sig/torque/postgresql/attributes/simple_enum.rbs

@@ -0,0 +1,39 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module SimpleEnum
+        extend ActiveSupport::Concern
+
+        type values = Hash[column_ref, untyped] | Array[untyped] | nil
+
+        class Methods < Module
+          @klass: singleton(Base)
+
+          def initialize: (singleton(Base) klass) -> void
+
+          private
+
+          def klass: () -> singleton(Base)
+          def define_enum_methods: (column_ref name, String value_method_name, untyped value, untyped _scopes, bool instance_methods) -> Symbol?
+        end
+
+        def defined_enums: () -> Hash[String, type_caster]
+
+        module ClassMethods
+          include ActiveRecord::Enum
+
+          @_enum_methods_module: Methods
+
+          def defined_enums: () -> Hash[String, type_caster]
+          def defined_enums=: (Hash[String, type_caster] value) -> Hash[String, type_caster]
+          def enum: (column_ref name, ?values values, ?prefix: bool | column_ref, ?suffix: bool | column_ref, ?default: untyped, ?validate: bool | Hash[Symbol, untyped], ?instance_methods: bool, **untyped options) -> untyped
+
+          private
+
+          def _enum_methods_module: () -> Methods
+          def detect_enum_conflict!: (column_ref enum_name, String | Symbol method_name, ?bool klass_method) -> nil
+        end
+      end
+    end
+  end
+end