torque-postgresql 4.0.1 → 4.1.1

data/sig/torque/postgresql/predicate_builder.rbs

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    # initialize is not declared: the handler files reopen this module before
+    # it is defined, and the runtime checker hooks it eagerly
+    module PredicateBuilder
+      type handler = singleton(CompositeHandler) | singleton(StructHandler) | singleton(LtreeHandler)
+
+      ARRAY_OID: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array)
+
+      def self.handler_for: (type_caster? type, ?untyped value) -> handler?
+      def build: (arel_node attribute, untyped value, ?Symbol? operator) -> arel_node
+      def resolve_arel_attribute: (column_ref table_name, column_ref column_name) ?{ (?) -> untyped } -> arel_node
+
+      private
+
+      def handler_for_path: (arel_node attribute, untyped value) -> singleton(StructHandler)?
+    end
+  end
+end
+
+class ActiveRecord::PredicateBuilder
+  prepend Torque::PostgreSQL::PredicateBuilder
+end

data/sig/torque/postgresql/predicate_table.rbs

@@ -0,0 +1,24 @@
+module Torque
+  module PostgreSQL
+    class PredicateTable
+      type handler = PredicateBuilder::CompositeHandler | PredicateBuilder::StructHandler
+      type node = Arel::Nodes::Column | Arel::Nodes::Property
+
+      @handler: handler
+      @source: arel_node
+      @node: singleton(::Arel::Nodes::Binary)
+
+      def initialize: (handler handler, arel_node source, singleton(::Arel::Nodes::Binary) node) -> void
+      def arel_table: () -> self
+      def []: (column_ref | Integer name) -> node
+      def type: (column_ref | Integer name) -> type_caster?
+      def has_column?: (*untyped) -> true
+      def primary_key: () -> nil
+      def associated_with: (*untyped) -> false
+      alias associated_with? associated_with
+      def aggregated_with?: (*untyped) -> false
+      def polymorphic_association?: () -> false
+      def through_association?: () -> false
+    end
+  end
+end

data/sig/torque/postgresql/railtie.rbs

@@ -0,0 +1,10 @@
+module Torque
+  module PostgreSQL
+    class Railtie < Rails::Railtie
+    end
+  end
+end
+
+module ActiveRecord::Schema::Definition
+  include Torque::PostgreSQL::Adapter::Definition
+end

data/sig/torque/postgresql/reflection/abstract_reflection.rbs

@@ -0,0 +1,22 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module AbstractReflection
+        AREL_ATTR: singleton(::Arel::Attributes::Attribute)
+        AREL_NODE: singleton(::Arel::Nodes::Node)
+
+        def connected_through_array?: () -> bool
+        def join_scope: (table_node table, table_node foreign_table, model | relation foreign_klass) -> relation
+        def build_join_constraint: (table_node table, table_node foreign_table) -> arel_node
+
+        private
+
+        def build_id_constraint_between: (table_node table, table_node foreign_table) -> arel_node
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::AbstractReflection
+  prepend Torque::PostgreSQL::Reflection::AbstractReflection
+end

data/sig/torque/postgresql/reflection/association_reflection.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module AssociationReflection
+        def initialize: (Symbol name, Proc? scope, Hash[Symbol, untyped] options, model active_record) -> void
+
+        private
+
+        def derive_foreign_key: (*untyped, **untyped) -> String
+        def automatic_inverse_of: () -> Symbol?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::AssociationReflection
+  prepend Torque::PostgreSQL::Reflection::AssociationReflection
+end

data/sig/torque/postgresql/reflection/belongs_to_many_reflection.rbs

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      class BelongsToManyReflection < ::ActiveRecord::Reflection::AssociationReflection
+        @foreign_key: String
+        @association_foreign_key: String
+        @active_record_primary_key: String?
+
+        def macro: () -> :belongs_to_many
+        def connected_through_array?: () -> true
+        def belongs_to?: () -> true
+        def collection?: () -> true
+        def association_class: () -> singleton(Associations::BelongsToManyAssociation)
+        def foreign_key: () -> String
+        def association_foreign_key: () -> String
+        def active_record_primary_key: () -> String?
+        def join_primary_key: (*untyped) -> String?
+        def join_foreign_key: () -> String
+        def array_attribute: () -> arel_attribute
+
+        private
+
+        def derive_primary_key: () -> String?
+        def derive_foreign_key: () -> String
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::BelongsToManyReflection = Torque::PostgreSQL::Reflection::BelongsToManyReflection

data/sig/torque/postgresql/reflection/has_many_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module HasManyReflection
+        def connected_through_array?: () -> bool?
+        def array_attribute: () -> arel_attribute
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::HasManyReflection
+  include Torque::PostgreSQL::Reflection::HasManyReflection
+end

data/sig/torque/postgresql/reflection/runtime_reflection.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module RuntimeReflection
+        def klass: () -> model
+        def active_record: () -> model
+        def connected_through_array?: () -> bool?
+        def macro: () -> Symbol
+        def name: () -> Symbol
+        def array_attribute: () -> arel_attribute
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::RuntimeReflection
+  include Torque::PostgreSQL::Reflection::RuntimeReflection
+end

data/sig/torque/postgresql/reflection/through_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module ThroughReflection
+        def build_id_constraint: (*untyped) -> arel_node
+        def connected_through_array?: () -> bool?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::ThroughReflection
+  include Torque::PostgreSQL::Reflection::ThroughReflection
+end

data/sig/torque/postgresql/reflection.rbs

@@ -0,0 +1,11 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      def create: (Symbol macro, Symbol name, Proc? scope, Hash[Symbol, untyped] options, model ar) -> reflection?
+    end
+  end
+end
+
+module ActiveRecord::Reflection
+  extend Torque::PostgreSQL::Reflection
+end

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

@@ -0,0 +1,29 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module AuxiliaryStatement
+        type statement = Symbol | singleton(PostgreSQL::AuxiliaryStatement)
+
+        def auxiliary_statements_values: () -> Array[PostgreSQL::AuxiliaryStatement]
+        def auxiliary_statements_values=: (Array[PostgreSQL::AuxiliaryStatement] value) -> Array[PostgreSQL::AuxiliaryStatement]
+        def with: (*statement args, ?recursive: bool, **untyped settings) -> relation
+        def with!: (*statement args, ?recursive: bool, **untyped settings) -> self
+        alias auxiliary_statements with
+        alias auxiliary_statements! with!
+        def bound_attributes: () -> Array[untyped]
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+        def instantiate_auxiliary_statements: (*statement args, **untyped options) -> Array[PostgreSQL::AuxiliaryStatement]
+        def build_auxiliary_statements: (::Arel::SelectManager arel) -> Array[untyped]?
+        def auxiliary_statement_type: () -> (:recursive)?
+        def auxiliary_statement_error: (Symbol | String name) -> bot
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::AuxiliaryStatement
+end

data/sig/torque/postgresql/relation/buckets.rbs

@@ -0,0 +1,35 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Buckets
+        type keys = Array[untyped] | ::Range[untyped]
+        type value = [arel_node, keys, Integer?, column_ref?, column_ref?]
+
+        def buckets_value: () -> value?
+        def buckets_value=: (value? value) -> value?
+        def buckets: (column_spec | arel_node attribute, keys values, ?count: Integer?, ?cast: column_ref?, ?as: column_ref?) -> relation
+        def buckets!: (column_spec | arel_node attribute, keys values, ?count: Integer?, ?cast: column_ref?, ?as: column_ref?) -> self
+        def calculate: (*untyped) -> untyped
+
+        module Initializer
+          def records: () -> (Array[record] | Hash[untyped, Array[record]])
+        end
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+        def build_buckets_node: () -> ::Arel::Nodes::NamedFunction
+        def buckets_column: () -> String
+        def buckets_keys: () -> Array[untyped]
+      end
+
+      module Initializer
+        include Buckets::Initializer
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::Buckets
+end

data/sig/torque/postgresql/relation/cross_join.rbs

@@ -0,0 +1,63 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module CrossJoin
+        type row = Hash[column_ref, untyped] | Array[untyped]
+        type source = arel_node | relation | ::Arel::SelectManager | Array[row]
+        type ordinality = bool | column_ref
+
+        class Entry < ::Struct[untyped]
+          def node: () -> ::Arel::Nodes::Join
+          def node=: (::Arel::Nodes::Join value) -> ::Arel::Nodes::Join
+          def table: () -> arel_table
+          def table=: (arel_table value) -> arel_table
+        end
+
+        def self.build: (untyped source, column_ref as, Array[column_ref]? columns, Symbol | String mode, ordinality with_ordinality, ?Hash[column_ref, String?]? definitions) -> Entry
+
+        private
+
+        def self.columns_for: (untyped source, Array[column_ref]? columns) -> Array[column_ref]?
+        def self.ordinality_for: (ordinality value) -> column_ref?
+        def self.validate_ordinality!: (column_ref? ordinality, Array[column_ref]? columns, Hash[column_ref, String?]? definitions) -> nil
+        def self.source_for: (untyped source, Array[column_ref]? columns) -> [arel_node, bool]
+        def self.unnest_rows: (Array[row] rows, Array[column_ref]? columns) -> ::Arel::Nodes::NamedFunction
+        def self.row_values: (row row, Array[Symbol] keys) -> Array[untyped]
+        def self.join_for: (Symbol | String mode, Torque::PostgreSQL::Arel::Nodes::FromItem item) -> ::Arel::Nodes::Join
+
+        public
+
+        def cross_joins_value: () -> Hash[Symbol, Entry]
+        def cross_joins_value=: (Hash[Symbol, Entry] value) -> Hash[Symbol, Entry]
+        def cross_join: (untyped source, as: column_ref, ?columns: Array[column_ref]?, ?mode: Symbol | String, ?with_ordinality: ordinality) -> relation
+        def cross_join!: (untyped source, as: column_ref, ?columns: Array[column_ref]?, ?mode: Symbol | String, ?with_ordinality: ordinality) -> self
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+
+        public
+
+        module Merger
+          def merge: () -> relation
+
+          private
+
+          def merge_cross_joins: () -> untyped
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::CrossJoin
+end
+
+class ActiveRecord::Relation::Merger
+  prepend Torque::PostgreSQL::Relation::CrossJoin::Merger
+end
+
+class ActiveRecord::Base
+  def self.cross_join: (untyped source, as: Torque::PostgreSQL::column_ref, ?columns: Array[Torque::PostgreSQL::column_ref]?, ?mode: Symbol | String, ?with_ordinality: Torque::PostgreSQL::Relation::CrossJoin::ordinality) -> ActiveRecord::Relation
+end

data/sig/torque/postgresql/relation/distinct_on.rbs

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module DistinctOn
+        def distinct_on_values: () -> Array[column_spec]
+        def distinct_on_values=: (Array[column_spec] value) -> Array[column_spec]
+        def distinct_on: (*column_spec value) -> relation
+        def distinct_on!: (*column_spec value) -> self
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Inheritance
+        RECORD_CLASS_TOKEN: Symbol
+
+        def expand_records_values: () -> Array[model]
+        def expand_records_values=: (Array[model] value) -> Array[model]
+        def expand_records_eager_load_value: () -> bool?
+        def expand_records_eager_load_value=: (bool? value) -> bool?
+        def expand_records_scoped_value: () -> Hash[model, Array[model]]
+        def expand_records_scoped_value=: (Hash[model, Array[model]] value) -> Hash[model, Array[model]]
+        def itself_only_value: () -> bool?
+        def itself_only_value=: (bool? value) -> bool?
+        def quote_table_name: (table_ref name) -> String
+        def quote_column_name: (column_ref name) -> String
+        def itself_only: () -> relation
+        def itself_only!: (*untyped) -> self
+        def expand_records: (*model types, ?eager_load: bool, ?filter: bool) -> relation
+        def expand_records!: (*model types, ?eager_load: bool, ?filter: bool) -> self
+        def select: (*untyped fields) ?{ (?) -> untyped } -> untyped
+
+        private
+
+        def raise_itself_only_conflict!: () -> bot
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+        def inheritance_discriminated?: () -> bool
+        def build_record_class_marker: () -> ::Arel::Nodes::As
+        def build_inheritances: (::Arel::SelectManager arel) -> untyped
+        def build_inheritances_joins: (::Arel::SelectManager arel, Array[model] types) -> Hash[String, Array[::Arel::Nodes::TableAlias]]
+        def regclass: () -> Torque::PostgreSQL::Arel::Nodes::Cast
+
+        public
+
+        module Expansion
+          def preload_associations: (Array[record] records) -> untyped
+
+          private
+
+          def exec_queries: () ?{ (record) -> void } -> Array[record]
+          def preloaded_association_names: () -> Array[Symbol]
+          def warn_about_missing_record_class: (Array[record] records) -> untyped
+          def record_class_marker?: (arel_node | column_ref value) -> bool
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/relation/join_series.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module JoinSeries
+        type step = Numeric | ActiveSupport::Duration | Symbol | String
+        type with = column_ref | Hash[column_ref, untyped] | arel_node
+
+        def self.build: (relation relation, untyped range, ?with: with?, ?as: column_ref, ?step: step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> ::Arel::Nodes::Join
+
+        private
+
+        def self.validate_build!: (untyped range, step? step) -> nil
+        def self.bind_value: (untyped value) -> arel_node
+        def self.arel_join: (Symbol | String mode) -> singleton(::Arel::Nodes::Join)
+        def self.build_join_on: (Torque::PostgreSQL::Arel::Nodes::Ref result, relation relation, with? with, column_ref? cast) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> arel_node
+
+        public
+
+        def join_series: (untyped range, ?with: with?, ?as: column_ref, ?step: step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> relation
+        def join_series!: (untyped range, ?with: with?, ?as: column_ref, ?step: step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> self
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::JoinSeries
+end

data/sig/torque/postgresql/relation/merger.rbs

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Merger
+        def merge: () -> relation
+
+        private
+
+        def merge_select_extra: () -> untyped
+        def merge_distinct_on: () -> untyped
+        def merge_auxiliary_statements: () -> untyped
+        def merge_inheritance: () -> untyped
+        def raise_eager_load_conflict!: () -> bot
+        def merge_buckets: () -> untyped
+        def merge_segments: () -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation::Merger
+  prepend Torque::PostgreSQL::Relation::Merger
+end

data/sig/torque/postgresql/relation/segments.rbs

@@ -0,0 +1,27 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Segments
+        type condition = relation | Symbol | Proc | Hash[untyped, untyped] | String | Array[untyped] | arel_node | nil
+
+        def segments_value: () -> Hash[Symbol, arel_node?]
+        def segments_value=: (Hash[Symbol, arel_node?] value) -> Hash[Symbol, arel_node?]
+        def segments: (**condition map) -> relation
+        def segments!: (**condition map) -> self
+
+        private
+
+        def execute_simple_calculation: (String operation, column_spec | arel_node | nil column_name, bool? distinct) -> untyped
+        def execute_grouped_calculation: (String operation, column_spec | arel_node | nil column_name, bool? distinct) -> untyped
+        def execute_segments_calculation: (String operation, column_spec | arel_node | nil column_name, bool? distinct) -> untyped
+        def segments_projections: (Array[arel_node] groups, arel_node aggregate, connection connection) -> Array[::Arel::Nodes::As]
+        def segments_result: (ActiveRecord::Result data, Array[arel_node] groups, arel_node column, String operation) -> (Hash[untyped, untyped] | nil)
+        def segment_predicate_for: (Symbol name, condition condition) -> arel_node?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::Segments
+end

data/sig/torque/postgresql/relation.rbs

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      extend ActiveSupport::Concern
+      include DistinctOn
+      include Inheritance
+
+      type column_spec = column_ref | Hash[column_ref, untyped] | Array[untyped]
+
+      SINGLE_VALUE_METHODS: Array[Symbol]
+      MULTI_VALUE_METHODS: Array[Symbol]
+      VALUE_METHODS: Array[Symbol]
+      FROZEN_EMPTY_ARRAY: Array[untyped]
+      ARColumn: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::Column)
+
+      def select_extra_values: () -> Array[arel_node]
+      def select_extra_values=: (Array[arel_node] value) -> Array[arel_node]
+      def calculate: (Symbol | String operation, column_spec | nil column_name) -> untyped
+      def resolve_column: (column_spec list, ?column_ref | false base) -> Array[arel_node]
+      def resolve_base_table: (column_ref | false relation) -> (model | PredicateTable | nil)
+      def cast_for_condition: (column_ref | column column, untyped value) -> untyped
+
+      private
+
+      def build_arel: (*untyped) -> ::Arel::SelectManager
+      def part_table_for: (ActiveRecord::TableMetadata table, String name) -> PredicateTable?
+
+      public
+
+      module ClassMethods
+        def _record_class_attribute: () -> Symbol
+        def _record_class_column_name: () -> String
+      end
+
+      module Initializer
+        def initialize: (model klass, *untyped, **untyped) -> void
+        def upsert_all: (Array[Hash[column_ref, untyped]] attributes, ?where: String | relation | nil, **untyped xargs) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation
+  extend Torque::PostgreSQL::Relation::ClassMethods
+  prepend Torque::PostgreSQL::Relation::Initializer
+  prepend Torque::PostgreSQL::Relation::Inheritance::Expansion
+end

data/sig/torque/postgresql/schema_cache/bound_schema_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module BoundSchemaReflection
+      def add_model_name: (String table_name, model model) -> model?
+      def dependencies: (String table_name) -> Array[String]?
+      def associations: (String table_name) -> Array[String]?
+      def lookup_model: (String table_name, ?String | model scoped_class) -> model
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::BoundSchemaReflection
+  prepend Torque::PostgreSQL::BoundSchemaReflection
+end

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

@@ -0,0 +1,12 @@
+module Torque
+  module PostgreSQL
+    module SchemaCache
+      module Inheritance
+        def lookup_model: (String table_name, ?String | model scoped_class, source_to_model: Hash[String, model]) -> model
+        def find_model: (String | Array[String] max_name, String table_name, ?Module scope) -> model?
+        def generate_associations: (Hash[String, Array[String]] inheritance_dependencies) -> Hash[String, Array[String]]
+        def prepare_irregular_models: (Array[String] data_sources) -> Hash[String, model]
+      end
+    end
+  end
+end

data/sig/torque/postgresql/schema_cache/schema_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module SchemaReflection
+      def add_model_name: (SchemaCache::source source, String table_name, model model) -> model?
+      def dependencies: (SchemaCache::source source, String table_name) -> Array[String]?
+      def associations: (SchemaCache::source source, String table_name) -> Array[String]?
+      def lookup_model: (SchemaCache::source source, String table_name, String | model scoped_class) -> model
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::SchemaReflection
+  prepend Torque::PostgreSQL::SchemaReflection
+end

data/sig/torque/postgresql/schema_cache.rbs

@@ -0,0 +1,43 @@
+module Torque
+  module PostgreSQL
+    class LookupError < ArgumentError
+    end
+
+    # initialize is not declared: schema_cache/inheritance.rb reopens this
+    # module before it is defined, and the runtime checker hooks it eagerly
+    module SchemaCache
+      include SchemaCache::Inheritance
+
+      type source = connection | pool
+
+      @data_sources_model_names: Hash[String, model]
+      @inheritance_dependencies: Hash[String, Array[String]]
+      @inheritance_associations: Hash[String, Array[String]]
+      @inheritance_loaded: bool
+
+      def initialize_dup: (*untyped) -> untyped
+      def encode_with: (untyped coder) -> untyped
+      def init_with: (untyped coder) -> untyped
+      def add: (source | String connection_or_table_name, ?String table_name, *untyped) -> untyped
+      def clear!: () -> untyped
+      def size: () -> Integer
+      def clear_data_source_cache!: (source | String connection_or_name, ?String name) -> untyped
+      def marshal_dump: () -> Array[untyped]
+      def marshal_load: (Array[untyped] array) -> untyped
+      def add_model_name: (*untyped args) -> model?
+      def dependencies: (source | String source, ?String table_name) -> Array[String]?
+      def associations: (source | String source, ?String table_name) -> Array[String]?
+      def lookup_model: (String table_name, ?String | model scoped_class) -> model
+
+      private
+
+      def reload_inheritance_data!: (source source) -> untyped
+      def generate_associations: () -> Hash[String, Array[String]]
+      def add_all: (?source? source) -> untyped
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::SchemaCache
+  prepend Torque::PostgreSQL::SchemaCache
+end

data/sig/torque/postgresql/table_name.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    class TableName < Delegator
+      @klass: model
+      @table_name: String
+      @schema: String?
+
+      def initialize: (model klass, String table_name) -> void
+      def schema: () -> String?
+      def to_s: () -> String
+      alias __getobj__ to_s
+      def ==: (untyped other) -> Integer?
+      def __setobj__: (String value) -> String
+
+      private
+
+      def search_path_schemes: () -> Array[String]
+    end
+  end
+end

data/sig/torque/postgresql/validations.rbs

@@ -0,0 +1,13 @@
+module Torque
+  module PostgreSQL
+    module Validations
+      class NestedValidator < ActiveModel::EachValidator
+        def validate_each: (ActiveModel::Validations record, column_ref attribute, untyped value) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Torque::PostgreSQL::Validations
+end

data/sig/torque/postgresql/version.rbs

@@ -0,0 +1,5 @@
+module Torque
+  module PostgreSQL
+    VERSION: String
+  end
+end