torque-postgresql 4.0.1 → 4.1.1

data/sig/torque/postgresql/adapter/schema_definitions.rbs

@@ -0,0 +1,55 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      type search_columns = column_ref | Array[column_ref] | Hash[column_ref, String]
+      type column_options = { ?limit: Integer, ?precision: Integer, ?scale: Integer, ?array: bool, ?null: bool, ?default: untyped, ?enum_type: table_ref, ?composite_type: table_ref, ?comment: String }
+
+      module ColumnMethods
+        def search_language: (*column_ref names, **untyped options) -> Array[column_ref]
+        def search_vector: (*column_ref names, columns: search_columns, **untyped options) -> Array[column_ref]
+        def composite: (*column_ref names, composite_type: table_ref, **untyped options) -> Array[column_ref]
+        def ltree: (*column_ref names, **untyped options) -> Array[column_ref]
+        def lquery: (*column_ref names, **untyped options) -> Array[column_ref]
+      end
+
+      module TableDefinition
+        include ColumnMethods
+
+        attr_reader inherits: Array[table_ref]?
+
+        def initialize: (*untyped args, **untyped options) -> void
+        def set_primary_key: (table_ref tn, untyped id, untyped primary_key, *untyped, **untyped) -> untyped
+
+        private
+
+        def create_column_definition: (column_ref name, Symbol | String type, Hash[Symbol, untyped]? options) -> untyped
+      end
+
+      class CompositeTypeDefinition < ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+        attr_reader changes: Array[untyped]
+        attr_reader removals: Array[String]
+        attr_reader renames: Array[[String, String]]
+
+        def initialize: (*untyped args, **untyped xargs) -> void
+        def change: (column_ref name, Symbol | String type, **untyped options) -> Array[untyped]
+        def remove: (*column_ref names) -> Array[String]
+        def rename: (column_ref name, column_ref new_name) -> Array[[String, String]]
+      end
+
+      module Definition
+        def create_function: (String name, version: Integer, ?dir: String | Array[String]) -> untyped
+        def create_type: (String name, version: Integer, ?dir: String | Array[String]) -> untyped
+        def create_view: (String name, version: Integer, ?dir: String | Array[String]) -> untyped
+        def create_trigger: (String name, version: Integer, ?dir: String | Array[String]) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::PostgreSQL::Table
+  include Torque::PostgreSQL::Adapter::ColumnMethods
+end
+
+class ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+  include Torque::PostgreSQL::Adapter::TableDefinition
+end

data/sig/torque/postgresql/adapter/schema_dumper.rbs

@@ -0,0 +1,37 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaDumper
+        SEARCH_VECTOR_SCANNER: Regexp
+
+        @versioned_commands: VersionedCommands::SchemaTable
+
+        def initialize: (*untyped) -> void
+        def dump: (stream stream) -> stream
+
+        private
+
+        def types: (stream stream) -> untyped
+        def composite_types: (stream stream) -> untyped
+        def tables: (stream stream) -> untyped
+        def around_tables: (stream stream) { () -> void } -> untyped
+        def dump_tables: (stream stream) -> untyped
+        def remove_prefix_and_suffix: (String table) -> String
+        def schemas: (stream stream) -> untyped
+        def schema_type_with_virtual: (column column) -> Symbol
+        def schema_type: (column column) -> Symbol
+        def prepare_column_options: (column column) -> Hash[Symbol, untyped]
+        def parse_search_vector_options: (column column, Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]?
+        def parse_search_vector_columns: (Array[Array[String?]] settings) -> (String | Hash[String, String])
+        def versioned_commands: (stream stream, Symbol type, ?bool add_newline) -> untyped
+        def list_existing_versioned_commands: (Symbol type) -> Set[String]
+        def with_versioned_commands?: () -> bool
+        def fx_functions_position: () -> Symbol?
+      end
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper
+  prepend Torque::PostgreSQL::Adapter::SchemaDumper
+end

data/sig/torque/postgresql/adapter/schema_overrides.rbs

@@ -0,0 +1,46 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaOverrides
+        def quote_table_name: (table_ref name) -> String
+        def table_exists?: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def indexes: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def index_exists?: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def columns: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def column_exists?: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def primary_key: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def create_table: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def change_table: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def add_column: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def add_columns: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def remove_columns: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def remove_column: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def change_column: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def change_column_default: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def change_column_null: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def rename_column: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def add_index: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def remove_index: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def rename_index: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def index_name_exists?: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def foreign_keys: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def add_timestamps: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def remove_timestamps: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def change_table_comment: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def change_column_comment: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def bulk_change_table: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def rename_table: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def add_foreign_key: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def remove_foreign_key: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def foreign_key_exists?: (table_ref table_name, *untyped args, **untyped options) ?{ (?) -> untyped } -> untyped
+        def drop_table: (*table_ref table_names, **untyped options) -> untyped
+
+        private
+
+        def validate_table_length!: (table_ref table_name) -> untyped
+      end
+
+      include SchemaOverrides
+    end
+  end
+end

data/sig/torque/postgresql/adapter/schema_statements.rbs

@@ -0,0 +1,50 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaStatements
+        type schema_options = { ?schema: table_ref }
+        type drop_options = { ?force: Symbol | String | nil, ?check: bool, ?schema: table_ref? }
+        type create_type_options = { ?force: Symbol | bool | nil, ?schema: table_ref }
+        type composite_column_options = { ?schema: table_ref, ?limit: Integer, ?precision: Integer, ?scale: Integer, ?array: bool, ?enum_type: table_ref, ?composite_type: table_ref }
+        type search_vector_options = { ?language: String | Symbol, ?stored: bool, ?index: bool | Hash[Symbol, untyped] }
+        type enum_values_options = { ?before: String | Symbol | false, ?after: String | Symbol | false, ?prepend: bool, ?prefix: String | bool, ?suffix: String | bool, ?schema: table_ref }
+
+        def drop_type: (table_ref name, ?drop_options options) -> untyped
+        def rename_type: (table_ref type_name, table_ref new_name, ?schema_options options) -> untyped
+        def create_composite_type: (table_ref name, ?create_type_options options) ?{ (CompositeTypeDefinition td) -> void } -> untyped
+        def change_composite_type: (table_ref name, ?schema_options options) { (CompositeTypeDefinition td) -> void } -> untyped
+        def add_composite_column: (table_ref type_name, column_ref column_name, Symbol | String type, ?composite_column_options options) -> untyped
+        def remove_composite_column: (table_ref type_name, column_ref column_name, ?Symbol | String | nil type, ?schema_options options) -> untyped
+        def change_composite_column: (table_ref type_name, column_ref column_name, Symbol | String type, ?composite_column_options options) -> untyped
+        def rename_composite_column: (table_ref type_name, column_ref column_name, column_ref new_name, ?schema_options options) -> untyped
+        def add_search_language: (table_ref table, column_ref name, ?Hash[Symbol, untyped] options) -> untyped
+        def add_search_vector: (table_ref table, column_ref name, search_columns columns, ?search_vector_options options) -> untyped
+        def add_enum_values: (table_ref name, Array[String | Symbol] values, ?enum_values_options options) -> Array[String]
+        def enum_values: (table_ref name) -> Array[String]
+        def create_table: (table_ref table_name, ?sync: bool | Hash[Symbol, bool], ?inherits: table_ref | Array[table_ref], ?schema: table_ref, **untyped options) ?{ (?) -> untyped } -> untyped
+        def primary_key: (table_ref table_name) -> (String | Array[String] | nil)
+        def table_options: (table_ref table_name) -> Hash[Symbol, untyped]
+        def quoted_scope: (?table_ref? name, ?type: String?) -> Hash[Symbol, String]
+        def data_source_sql: (?table_ref? name, ?type: String?) -> String
+        def valid_table_definition_options: () -> Array[Symbol]
+        def valid_column_definition_options: () -> Array[Symbol]
+        def type_to_sql: (Symbol | String type, ?composite_type: table_ref?, **untyped options) -> untyped
+        def assume_migrated_upto_version: (Integer | String version) -> untyped
+        def insert_versions_sql: (Array[Integer] versions) -> String
+
+        private
+
+        def sequence_name_from_parts: (String table_name, column_ref column_name, String suffix) -> String
+        def sanitize_name_with_schema: (table_ref name, Hash[Symbol, untyped]? options) -> table_ref
+        def create_composite_type_definition: (table_ref name) -> CompositeTypeDefinition
+        def alter_composite_type: (table_ref name, table_ref? schema, Array[String] actions) -> untyped
+        def composite_type_actions: (table_ref name, CompositeTypeDefinition td) -> Array[String]
+        def validate_composite_type!: (table_ref name, CompositeTypeDefinition td) -> nil
+        def composite_column_definition: (table_ref name, untyped column) -> String
+        def composite_column_type: (table_ref name, untyped column) -> untyped
+        def reset_composite_type: (table_ref name) -> untyped
+        def quote_enum_values: (table_ref name, Array[String | Symbol] values, enum_values_options options) -> Array[String]
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter.rbs

@@ -0,0 +1,24 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      include Quoting
+      include DatabaseStatements
+      include InheritanceStatements
+      include SchemaStatements
+
+      @version: Gem::Version
+
+      class DeduplicatableArray < ::Array[untyped]
+        def deduplicate: () -> Array[untyped]
+        alias -@ deduplicate
+      end
+
+      def version: () -> Gem::Version
+      def build_insert_sql: (ActiveRecord::InsertAll::Builder insert) -> String
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  prepend Torque::PostgreSQL::Adapter
+end

data/sig/torque/postgresql/arel/infix_operation.rbs

@@ -0,0 +1,79 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module Math
+        def contained_by: (untyped other) -> ::Arel::Nodes::ContainedBy
+        def has_key: (untyped other) -> ::Arel::Nodes::HasKey
+        def has_all_keys: (untyped other) -> ::Arel::Nodes::HasAllKeys
+        def has_any_keys: (untyped other) -> ::Arel::Nodes::HasAnyKeys
+        def strictly_left: (untyped other) -> ::Arel::Nodes::StrictlyLeft
+        def strictly_right: (untyped other) -> ::Arel::Nodes::StrictlyRight
+        def doesnt_right_extend: (untyped other) -> ::Arel::Nodes::DoesntRightExtend
+        def doesnt_left_extend: (untyped other) -> ::Arel::Nodes::DoesntLeftExtend
+        def adjacent_to: (untyped other) -> ::Arel::Nodes::AdjacentTo
+        def matches_lquery: (untyped other) -> ::Arel::Nodes::MatchesLquery
+        def matches_any_lquery: (untyped other) -> ::Arel::Nodes::MatchesAnyLquery
+      end
+
+      def self.build_operations: (Hash[Symbol | String, String]? operations) -> Hash[Symbol | String, String]?
+    end
+  end
+end
+
+module Arel
+  module Nodes
+    class ContainedBy < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class HasKey < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class HasAllKeys < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class HasAnyKeys < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class StrictlyLeft < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class StrictlyRight < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class DoesntRightExtend < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class DoesntLeftExtend < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class AdjacentTo < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class MatchesLquery < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class MatchesAnyLquery < InfixOperation
+      def initialize: (untyped left, untyped right) -> void
+    end
+
+    class Node
+      include Torque::PostgreSQL::Arel::Math
+    end
+  end
+
+  module Attributes
+    class Attribute
+      include Torque::PostgreSQL::Arel::Math
+    end
+  end
+end

data/sig/torque/postgresql/arel/join_source.rbs

@@ -0,0 +1,19 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module JoinSource
+        attr_accessor only: bool?
+
+        def only?: () -> bool
+      end
+    end
+  end
+end
+
+module Arel
+  module Nodes
+    class JoinSource
+      include Torque::PostgreSQL::Arel::JoinSource
+    end
+  end
+end

data/sig/torque/postgresql/arel/nodes.rbs

@@ -0,0 +1,83 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module Nodes
+        class Cast < ::Arel::Nodes::Binary
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::AliasPredication
+          include ::Arel::OrderPredications
+          include ::Arel::Math
+
+          def initialize: (arel_node left, column_ref right, ?bool | Symbol array) -> void
+        end
+
+        class Column < ::Arel::Nodes::Binary
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::AliasPredication
+          include ::Arel::OrderPredications
+          include ::Arel::Math
+
+          attr_reader type_caster: type_caster?
+          alias name right
+
+          def initialize: (arel_node source, column_ref name, type_caster? type_caster) -> void
+          def able_to_type_cast?: () -> true
+          def type_cast_for_database: (untyped value) -> untyped
+        end
+
+        class Property < ::Arel::Nodes::Binary
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::AliasPredication
+          include ::Arel::OrderPredications
+          include ::Arel::Math
+
+          attr_reader type_caster: type_caster?
+          attr_reader cast: column_ref?
+          alias path right
+
+          def initialize: (arel_node source, path_key key, type_caster? type_caster, ?column_ref? cast) -> void
+          def name: () -> String
+          def able_to_type_cast?: () -> true
+          def type_cast_for_database: (untyped value) -> untyped
+        end
+
+        class CrossJoin < ::Arel::Nodes::Join
+          def initialize: (arel_node left, ?arel_node? right) -> void
+        end
+
+        class FromItem < ::Arel::Nodes::Binary
+          attr_reader columns: Array[column_ref]?
+          attr_reader definitions: Hash[column_ref, String?]?
+          attr_reader ordinality: String?
+          attr_reader lateral: bool
+          alias name right
+
+          def initialize: (arel_node source, column_ref name, ?columns: Array[column_ref] | column_ref | nil, ?definitions: Hash[column_ref, String?]?, ?ordinality: column_ref?, ?lateral: bool) -> void
+          def rows_from?: () -> bool
+          def alias_columns: () -> Hash[column_ref, String?]
+        end
+
+        class Ref < ::Arel::Nodes::Unary
+          attr_reader reference: arel_node?
+          alias to_s expr
+
+          def initialize: (String | arel_node expr, ?arel_node? reference) -> void
+          def as: (column_ref other) -> ::Arel::Nodes::As
+        end
+      end
+    end
+  end
+end
+
+module Arel
+  def self.array: (*untyped values, ?cast: Torque::PostgreSQL::column_ref?) -> (::Arel::Nodes::Quoted | Torque::PostgreSQL::Arel::Nodes::Cast)
+
+  module Nodes
+    class Function
+      include ::Arel::Math
+    end
+  end
+end

data/sig/torque/postgresql/arel/operations.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module Operations
+        def pg_cast: (column_ref type, ?bool | Symbol array) -> Nodes::Cast
+        def cast: (column_ref type, ?bool | Symbol array) -> untyped
+      end
+    end
+  end
+end
+
+module Arel
+  module Attributes
+    class Attribute
+      include Torque::PostgreSQL::Arel::Operations
+    end
+  end
+
+  module Nodes
+    class SqlLiteral
+      include Torque::PostgreSQL::Arel::Operations
+    end
+
+    class Node
+      include Torque::PostgreSQL::Arel::Operations
+    end
+  end
+end

data/sig/torque/postgresql/arel/select_manager.rbs

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module SelectManager
+        def only: () -> true
+      end
+    end
+  end
+end
+
+module Arel
+  class SelectManager
+    include Torque::PostgreSQL::Arel::SelectManager
+  end
+end

data/sig/torque/postgresql/arel/visitors.rbs

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module Visitors
+        def visit_Arel_Nodes_JoinSource: (::Arel::Nodes::JoinSource o, collector collector) -> collector
+        def visit_Arel_Nodes_Quoted: (::Arel::Nodes::Quoted o, collector collector) -> collector
+        def visit_Torque_PostgreSQL_Arel_Nodes_Ref: (Nodes::Ref o, collector collector) -> collector
+        def visit_Torque_PostgreSQL_Arel_Nodes_Column: (Nodes::Column o, collector collector) -> collector
+        def visit_Torque_PostgreSQL_Arel_Nodes_Property: (Nodes::Property o, collector collector) -> collector
+        def visit_Torque_PostgreSQL_Arel_Nodes_CrossJoin: (Nodes::CrossJoin o, collector collector) -> collector
+        def visit_Torque_PostgreSQL_Arel_Nodes_FromItem: (Nodes::FromItem o, collector collector) -> collector
+        def visit_Torque_PostgreSQL_Arel_Nodes_Cast: (Nodes::Cast o, collector collector) -> collector
+
+        private
+
+        def visit_definitions: (Hash[column_ref, String?] definitions, collector collector) -> collector
+        def visit_alias_columns: (Hash[column_ref, String?] columns, collector collector) -> collector
+        def quote_array: (Enumerable[untyped] value, collector collector) -> collector
+      end
+    end
+  end
+end
+
+module Arel
+  module Visitors
+    class PostgreSQL
+      prepend Torque::PostgreSQL::Arel::Visitors
+    end
+  end
+end

data/sig/torque/postgresql/arel.rbs

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

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

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module AssociationScope
+        class PredicateBuilderArray
+          include PredicateBuilder::ArrayHandler
+
+          def call_with_empty: (arel_node attribute) -> String
+        end
+
+        module ClassMethods
+          def get_bind_values: (*untyped) -> Array[untyped]
+        end
+
+        private
+
+        def last_chain_scope: (relation scope, any_reflection reflection, record owner) -> relation
+        def next_chain_scope: (relation scope, any_reflection reflection, any_reflection next_reflection) -> relation
+        def transform_value: (untyped value) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::AssociationScope
+  extend Torque::PostgreSQL::Associations::AssociationScope::ClassMethods
+  prepend Torque::PostgreSQL::Associations::AssociationScope
+end

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

@@ -0,0 +1,51 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      class BelongsToManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
+        include ::ActiveRecord::Associations::ForeignAssociation
+
+        type ids = Array[untyped]
+
+        @_building_changes: bool?
+        @_was_loaded: bool
+
+        def ids_reader: () -> ids
+        def ids_writer: (ids? ids) -> untyped
+        def size: () -> Integer
+        def empty?: () -> bool
+        def include?: (record record) -> untyped
+        def load_target: () -> Array[record]
+        def build_changes: (?bool from_target) { () -> untyped } -> untyped
+        def trigger: (Symbol prefix, ids before_ids, ids after_ids) -> untyped
+        def handle_dependency: () -> untyped
+        def insert_record: (record record, *untyped) ?{ (?) -> untyped } -> bool
+        def default: () { (?) -> untyped } -> untyped
+
+        private
+
+        def _create_record: (Hash[untyped, untyped] | Array[Hash[untyped, untyped]] attributes, ?bool raises) ?{ (record) -> void } -> (record | Array[record])
+        def delete_count: (Symbol? method, relation scope, ids ids) -> Integer
+        def delete_or_nullify_all_records: (Symbol? method) -> Integer
+        def delete_records: (Array[record] records, Symbol? method) -> untyped
+        def source_attr: () -> String
+        def klass_attr: () -> String
+        def read_records_ids: (Array[record] | record | nil records) -> ids?
+        def ids_rewriter: (untyped ids, Symbol operator) -> untyped
+        def column_default_value: () -> untyped
+        def callback: (*untyped) -> true
+        def replace_records: (*untyped) -> untyped
+        def concat_records: (*untyped) -> untyped
+        def delete_or_destroy: (*untyped) -> untyped
+        def difference: (Array[untyped] a, Array[untyped] b) -> Array[untyped]
+        def intersection: (Array[untyped] a, Array[untyped] b) -> Array[untyped]
+        def scope_for_create: () -> Hash[String, untyped]
+        def find_target?: () -> untyped
+        def foreign_key_present?: () -> bool
+        def invertible_for?: (record record) -> untyped
+        def stale_state: () -> ids?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::BelongsToManyAssociation = Torque::PostgreSQL::Associations::BelongsToManyAssociation

data/sig/torque/postgresql/associations/builder/belongs_to_many.rbs

@@ -0,0 +1,24 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Builder
+        class BelongsToMany < ::ActiveRecord::Associations::Builder::CollectionAssociation
+          def self.macro: () -> :belongs_to_many
+          def self.valid_options: (Hash[Symbol, untyped] options) -> Array[Symbol]
+          def self.valid_dependent_options: () -> Array[Symbol]
+          def self.define_callbacks: (model model, Reflection::BelongsToManyReflection reflection) -> untyped
+          def self.define_readers: (Module mixin, Symbol name) -> untyped
+          def self.define_writers: (Module mixin, Symbol name) -> untyped
+          def self.add_default_callbacks: (model model, Reflection::BelongsToManyReflection reflection) -> untyped
+          def self.add_touch_callbacks: (model model, Reflection::BelongsToManyReflection reflection) -> untyped
+          def self.touch_record: (record o, Hash[String, untyped] changes, String foreign_key, Symbol name, bool | Symbol touch, Symbol touch_method) -> untyped
+          def self.add_change_callbacks: (model model, Reflection::BelongsToManyReflection reflection) -> untyped
+          def self.add_destroy_callbacks: (model model, Reflection::BelongsToManyReflection reflection) -> untyped
+          def self.define_validations: (model model, Reflection::BelongsToManyReflection reflection) -> untyped
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::Builder::BelongsToMany = Torque::PostgreSQL::Associations::Builder::BelongsToMany

data/sig/torque/postgresql/associations/builder/has_many.rbs

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Builder
+        module HasMany
+          def valid_options: (Hash[Symbol, untyped] options) -> Array[Symbol]
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::Builder::HasMany
+  extend Torque::PostgreSQL::Associations::Builder::HasMany
+end

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

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

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

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module ForeignAssociation
+        @inversed: bool
+
+        def inversed_from: (record record) -> untyped
+        def skip_statement_cache?: (*untyped) -> untyped
+
+        private
+
+        def set_owner_attributes: (record record) -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module JoinDependency
+        def apply_column_aliases: (relation relation) -> untyped
+
+        private
+
+        def cast_join_root?: (relation relation) -> bool
+        def root_record_class_marker: () -> ::Arel::Nodes::As
+        def joined_record_class_markers: () -> Array[::Arel::Nodes::As]
+        def record_class_column_name: () -> String
+      end
+    end
+  end
+end