torque-postgresql 4.1.0 → 4.1.1

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

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

@@ -0,0 +1,38 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Struct < Base
+        type struct_class = Class | String | Symbol
+        type delegate = column_ref | Array[column_ref] | nil
+
+        class Uninitialized < ActiveModel::Attribute::Uninitialized
+          def original_value: () -> nil
+        end
+
+        @strict: bool
+        @_struct_default_attributes: ActiveModel::AttributeSet
+
+        def self.strict=: (bool value) -> bool
+        def self.strict?: () -> bool
+        def self._default_attributes: () -> ActiveModel::AttributeSet
+        def self.include_on: (model klass, ?Symbol? method_name) -> untyped
+        def self.build_on: (model model, column_ref column, struct_class klass, ?default: untyped, ?array: bool?, ?delegate: delegate, ?backfill: Adapter::OID::Struct::backfill, ?strict: bool?) -> untyped
+
+        private
+
+        def self.reset_default_attributes!: () -> untyped
+        def self.resolve_default_on: (model model, String column, Proc | Symbol default) -> untyped
+
+        public
+
+        def attribute_writer_missing: (column_ref name, untyped value) -> untyped
+      end
+    end
+
+    class Struct = Attributes::Struct
+  end
+end
+
+class ActiveRecord::Base
+  def self.struct_for: (Torque::PostgreSQL::column_ref column, Torque::PostgreSQL::Attributes::Struct::struct_class struct_klass, ?default: untyped, ?array: bool?, ?delegate: Torque::PostgreSQL::Attributes::Struct::delegate, ?backfill: Torque::PostgreSQL::Adapter::OID::Struct::backfill, ?strict: bool?) -> untyped
+end

data/sig/torque/postgresql/attributes.rbs

@@ -0,0 +1,6 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+    end
+  end
+end

data/sig/torque/postgresql/autosave_association.rbs

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module AutosaveAssociation
+      module ClassMethods
+        def add_autosave_association_callbacks: (reflection reflection) -> untyped
+      end
+
+      def save_belongs_to_many_association: (reflection reflection) -> untyped
+    end
+  end
+end
+
+class ActiveRecord::Base
+  extend Torque::PostgreSQL::AutosaveAssociation::ClassMethods
+  include Torque::PostgreSQL::AutosaveAssociation
+end

data/sig/torque/postgresql/auxiliary_statement/recursive.rbs

@@ -0,0 +1,22 @@
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+      class Recursive < AuxiliaryStatement
+        @connect: [Symbol, Symbol] | Array[column_ref] | nil
+        @union_all: bool?
+        @sub_query: query?
+        @depth: [String, untyped, String?]?
+        @path: [String, String?, String?]?
+
+        def initialize: (*untyped, **untyped options) -> void
+
+        private
+
+        def build_query: (relation base) -> (arel_node | ::Arel::SelectManager)
+        def prepare: (relation base, Settings | OpenStruct settings) -> untyped
+        def prepare_sub_query: (relation base, Settings | OpenStruct settings) -> untyped
+        def extra_columns: (relation base, Array[arel_node] columns, Array[arel_node] sub_columns) -> untyped
+      end
+    end
+  end
+end

data/sig/torque/postgresql/auxiliary_statement/settings.rbs

@@ -0,0 +1,63 @@
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+      class Settings
+        attr_reader base: base
+        attr_reader source: statement_class
+        attr_reader depth: [String, untyped, String?]?
+        attr_reader path: [String, String?, String?]?
+
+        @recursive: bool?
+        @query: query?
+        @sub_query: query?
+        @connect: [Symbol, Symbol] | Array[column_ref] | nil
+        @union_all: bool?
+        @query_table: arel_table?
+
+        def attributes: (*untyped) -> Hash[untyped, untyped]?
+        def attributes=: (Hash[untyped, untyped] value) -> Hash[untyped, untyped]
+        alias select attributes
+        def join: (*untyped) -> Hash[untyped, untyped]?
+        def join=: (Hash[untyped, untyped] value) -> Hash[untyped, untyped]
+        def join_type: (*untyped) -> join_type?
+        def join_type=: (join_type value) -> join_type
+        def requires: (*untyped) -> (Symbol | Array[untyped] | nil)
+        def requires=: (Symbol | Array[untyped] value) -> (Symbol | Array[untyped])
+        def polymorphic: (*untyped) -> untyped
+        def polymorphic=: (untyped value) -> untyped
+        def through: (*untyped) -> (Symbol | String | nil)
+        def through=: (Symbol | String value) -> (Symbol | String)
+        def union_all: (*untyped) -> bool?
+        def union_all=: (bool value) -> bool
+        alias cte source
+
+        def relation_query?: (untyped obj) -> bool
+        def table: () -> arel_table
+        def table_name: () -> (String | Symbol)?
+        def sql: (String raw) -> ::Arel::Nodes::SqlLiteral
+
+        def initialize: (base base, statement_class source, ?bool? recursive) -> void
+        def base_name: () -> String
+        def base_table: () -> arel_table
+        def recursive?: () -> bool?
+        def depth?: () -> String?
+        def path?: () -> String?
+        def with_depth: (?column_ref name, ?start: untyped, ?as: column_ref?) -> [String, untyped, String?]?
+        def with_path: (?column_ref name, ?source: column_ref?, ?as: column_ref?) -> [String, String?, String?]?
+        def union_all!: () -> true?
+        def with_depth_and_path: () -> untyped
+        def query_table: () -> arel_table?
+        def col: (column_ref name) -> arel_attribute
+        alias column col
+        def query: (?query? value, ?untyped command) -> untyped
+        def sub_query: (?query? value, ?untyped command) -> untyped
+        def connect: (?column_ref | Hash[column_ref, column_ref] | Array[column_ref] | nil value) -> ([Symbol, Symbol] | Array[column_ref] | nil)
+        alias connect= connect
+
+        private
+
+        def sanitize_query: (query value, ?untyped command) -> untyped
+      end
+    end
+  end
+end

data/sig/torque/postgresql/auxiliary_statement.rbs

@@ -0,0 +1,57 @@
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+      type query = relation | ::Arel::SelectManager | String | Symbol | Proc | _Callable
+      type base = relation | model
+      type statement_class = AuxiliaryStatement | singleton(AuxiliaryStatement)
+      type join_type = :inner | :left | :right | :full
+
+      TABLE_COLUMN_AS_STRING: Regexp
+
+      @table: arel_table
+      @join: Hash[untyped, untyped]
+      @args: Hash[Symbol, untyped]
+      @where: Hash[untyped, untyped] | String
+      @select: Hash[untyped, untyped]
+      @join_type: join_type?
+      @dependencies: Array[untyped]
+      @query: query
+      @association: String?
+
+      def self.config: () -> (Proc | OpenStruct | nil)
+      def self.table_name: () -> (String | Symbol)?
+      def self.lookup: (Symbol | String name, model base) -> singleton(AuxiliaryStatement)
+      def self.instantiate: (Symbol statement, model | relation base, **untyped options) -> AuxiliaryStatement
+      def self.build: (Symbol statement, relation base, ?Array[untyped] bound_attributes, ?Array[::Arel::Nodes::Join] join_sources, **untyped options) -> [Array[untyped], ::Arel::Nodes::As]
+      def self.relation_query?: (untyped obj) -> bool
+      def self.arel_query?: (untyped obj) -> bool
+      def self.create: (String | Symbol | model | relation | Hash[Symbol, untyped] table_or_settings) ?{ (Settings) -> void } -> singleton(AuxiliaryStatement)
+      def self.configurator: (Proc | Hash[Symbol, untyped] | nil config) -> (Proc | OpenStruct | nil)
+      def self.configure: (base base, statement_class instance) -> (Settings | OpenStruct)
+      def self.table: () -> arel_table
+
+      def config: () -> (Proc | OpenStruct | nil)
+      def table: () -> arel_table
+      def table_name: () -> (String | Symbol)?
+      def relation: (*untyped) -> untyped
+      def configure: (base base, statement_class instance) -> (Settings | OpenStruct)
+      def relation_query?: (untyped obj) -> bool
+
+      attr_reader bound_attributes: Array[untyped]
+      attr_reader join_sources: Array[::Arel::Nodes::Join]
+
+      def initialize: (*untyped, **untyped options) -> void
+      def build: (relation base) -> [Array[untyped], ::Arel::Nodes::As]
+
+      private
+
+      def prepare: (relation base, Settings | OpenStruct settings) -> untyped
+      def build_query: (relation base) -> (arel_node | ::Arel::SelectManager)
+      def build_join: (relation base) -> ::Arel::Nodes::Join
+      def arel_join: () -> singleton(::Arel::Nodes::Join)
+      def expose_columns: (relation base, ?arel_table? query_table) -> Array[arel_node]
+      def ensure_dependencies: (Array[untyped] list, relation base) -> Array[untyped]
+      def project: (column_ref | arel_node column, ?arel_table? arel_table) -> arel_node
+    end
+  end
+end

data/sig/torque/postgresql/base.rbs

@@ -0,0 +1,41 @@
+module Torque
+  module PostgreSQL
+    module Base
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def distinct_on: (*Relation::column_spec value) -> relation
+        def with: (*Relation::AuxiliaryStatement::statement args, ?recursive: bool, **untyped settings) -> relation
+        def itself_only: () -> relation
+        def expand_records: (*model types, ?eager_load: bool, ?filter: bool) -> relation
+        def join_series: (untyped range, ?with: Relation::JoinSeries::with?, ?as: column_ref, ?step: Relation::JoinSeries::step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> relation
+        def buckets: (Relation::column_spec | arel_node attribute, Relation::Buckets::keys values, ?count: Integer?, ?cast: column_ref?, ?as: column_ref?) -> relation
+        def segments: (**Relation::Segments::condition map) -> relation
+        def arel_property_of: (column_ref column, *column_ref | Integer path) -> Torque::PostgreSQL::Arel::Nodes::Property
+        def load_schema!: () -> untyped
+        def reset_table_name: () -> (String | TableName)
+        def inherited: (model subclass) -> untyped
+        def belongs_to_many: (Symbol name, ?Proc? scope, ?class_name: String, ?foreign_key: column_ref, ?primary_key: column_ref, ?dependent: Symbol, ?touch: bool | Symbol, ?optional: bool, ?required: bool, ?default: Proc, ?inverse_of: Symbol, ?autosave: bool, ?validate: bool, **untyped options) ?{ (?) -> untyped } -> untyped
+        def dynamic_attribute: (Symbol name) { (?) -> untyped } -> Symbol
+        def auxiliary_statement: (Symbol table) ?{ (AuxiliaryStatement::Settings) -> void } -> untyped
+        alias cte auxiliary_statement
+        def recursive_auxiliary_statement: (Symbol table) ?{ (AuxiliaryStatement::Settings) -> void } -> untyped
+        alias recursive_cte recursive_auxiliary_statement
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Torque::PostgreSQL::Base
+  extend Torque::PostgreSQL::Base::ClassMethods
+
+  def self.belongs_to_many_required_by_default: () -> bool?
+  def self.belongs_to_many_required_by_default=: (bool? value) -> bool?
+  def self.schema: () -> (String | Symbol | nil)
+  def self.schema=: (String | Symbol | nil value) -> (String | Symbol | nil)
+  def schema: () -> (String | Symbol | nil)
+  def self.auxiliary_statements_list: () -> Hash[Symbol, singleton(Torque::PostgreSQL::AuxiliaryStatement)]
+  def self.auxiliary_statements_list=: (Hash[Symbol, singleton(Torque::PostgreSQL::AuxiliaryStatement)] value) -> Hash[Symbol, singleton(Torque::PostgreSQL::AuxiliaryStatement)]
+  def auxiliary_statements_list: () -> Hash[Symbol, singleton(Torque::PostgreSQL::AuxiliaryStatement)]
+end

data/sig/torque/postgresql/collector.rbs

@@ -0,0 +1,7 @@
+module Torque
+  module PostgreSQL
+    module Collector
+      def self.new: (*Symbol | Array[Symbol] args) -> Class
+    end
+  end
+end

data/sig/torque/postgresql/config.rbs

@@ -0,0 +1,9 @@
+module Torque
+  module PostgreSQL
+    AR810: bool
+
+    def self.config: () -> ActiveSupport::InheritableOptions
+    def self.configure: () { (ActiveSupport::InheritableOptions config) -> void } -> void
+    def self.logger: () -> untyped
+  end
+end

data/sig/torque/postgresql/function.rbs

@@ -0,0 +1,21 @@
+module Torque
+  module PostgreSQL
+    module Function
+      def self.bind: (column_ref name, untyped value, type_caster | ActiveModel::Attributes::Normalization::NormalizedValueType type, ?untyped original_attribute) -> ::Arel::Nodes::BindParam
+      def self.bind_for: (model model, column_ref attribute, untyped value) -> ::Arel::Nodes::BindParam
+      def self.bind_with: (arel_attribute arel_attribute, untyped value) -> ::Arel::Nodes::BindParam
+      def self.bind_type: (untyped value, ?Symbol | type_caster | nil type, ?name: column_ref, ?cast: column_ref?) -> (::Arel::Nodes::BindParam | Arel::Nodes::Cast)
+      def self.infix: (Symbol | String op, arel_node left, arel_node right) -> ::Arel::Nodes::InfixOperation
+      def self.concat: (*arel_node args) -> arel_node
+      def self.group_by: (arel_node arel, column_ref name) -> Arel::Nodes::Ref
+      def self.respond_to_missing?: (*untyped) -> true
+      def self.method_missing: (Symbol name, *untyped args) ?{ (?) -> untyped } -> ::Arel::Nodes::NamedFunction
+
+      private
+
+      def self.ruby_type_to_model_type: (untyped value) -> (Symbol | Adapter::OID::Interval)
+    end
+
+    FN: singleton(Function)
+  end
+end

data/sig/torque/postgresql/geometry_builder.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    class GeometryBuilder < ActiveModel::Type::Value
+      DESTRUCTOR: Regexp
+      NUMBER_SERIALIZER: ^(Numeric) -> String
+
+      def type: () -> (Symbol | String)
+      def pieces: () -> Array[Symbol]
+      def formation: () -> String
+      def cast: (untyped value) -> untyped
+      def serialize: (untyped value) -> String?
+      def deserialize: (String? value) -> untyped
+      def type_cast_for_schema: (untyped value) -> (Array[Numeric] | String)
+      def changed_in_place?: (String? raw_old_value, untyped new_value) -> bool
+      def number_serializer: () -> ^(Numeric) -> String
+      def config_class: () -> Class
+      def build_klass: (*untyped args) -> untyped
+    end
+  end
+end

data/sig/torque/postgresql/i18n.rbs

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module I18n
+      def localize: (Symbol | String locale, untyped object, ?Symbol | String format, ?Hash[Symbol, untyped] options) -> String
+    end
+  end
+end
+
+module I18n
+  module Backend
+    module Base
+      prepend Torque::PostgreSQL::I18n
+    end
+  end
+end

data/sig/torque/postgresql/inheritance/expander.rbs

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    module Inheritance
+      class Expander
+        @model: model
+        @records: Array[record]
+        @targets: Array[model]
+
+        def initialize: (model model, Array[record] records, Array[model] targets) -> void
+        def call: () -> Array[record]
+
+        private
+
+        def model: () -> model
+        def targets: () -> Array[model]
+        def pending: () -> Hash[model, Array[record]]
+        def extra_columns: (model klass) -> Array[String]
+        def fetch: (model klass, Array[untyped] ids) -> Hash[untyped, Hash[String, untyped]]
+        def amend: (model klass, Array[record] records, Hash[untyped, Hash[String, untyped]] rows) -> untyped
+      end
+    end
+  end
+end

data/sig/torque/postgresql/inheritance/record.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    module Inheritance
+      module Record
+        @partial_record: bool?
+        @readonly: bool
+
+        def partial_record?: () -> bool
+        def reload: (*untyped) -> self
+        def destroy: () -> untyped
+
+        private
+
+        def without_readonly: () { () -> untyped } -> untyped
+        def mark_as_partial_record!: () -> untyped
+        def mark_as_full_record!: () -> bool
+      end
+    end
+  end
+end