torque-postgresql 4.1.0 → 4.1.1

data/sig/torque/postgresql/adapter/oid/lquery.rbs

@@ -0,0 +1,21 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Lquery < Ltree
+          STAR: Regexp
+
+          def type: () -> :lquery
+
+          private
+
+          def value_class: () -> singleton(Attributes::LQuery)
+          def items_of: (untyped entry, bool sanitize) -> ::Array[untyped]
+          def compile: (untyped item) -> String
+          def quantifier: (::Range[Integer?] range) -> String
+          def parse: (String text) -> (String | Symbol | ::Array[String] | ::Range[Integer?])
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/ltree.rbs

@@ -0,0 +1,32 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Ltree < ActiveModel::Type::Value
+          type path = Attributes::LTree | Attributes::LQuery
+
+          def type: () -> :ltree
+          def cast: (untyped value) -> path?
+          def serialize: (untyped value) -> String?
+          def deserialize: (String? value) -> path?
+          def items_for: (untyped value, ?sanitize: bool) -> ::Array[untyped]
+          def type_cast_for_schema: (untyped value) -> String
+          def changed_in_place?: (String? raw_old_value, untyped new_value) -> bool
+          def ==: (untyped other) -> bool
+          alias eql? ==
+          def hash: () -> Integer
+
+          private
+
+          def value_class: () -> (singleton(Attributes::LTree) | singleton(Attributes::LQuery))
+          def items_of: (untyped entry, bool sanitize) -> ::Array[untyped]
+          def labels_of: (String text, bool sanitize) -> ::Array[untyped]
+          def record_label: (record record) -> String
+          def sanitize: (String text) -> String
+          def compile: (untyped item) -> String
+          def parse: (String text) -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/range.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Range < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range[untyped]
+          HASH_PICK: ::Array[Symbol]
+
+          module Comparison
+            def <=>: (untyped other) -> Integer?
+          end
+
+          def cast_value: (untyped value) -> untyped
+          def map: (untyped value) { (untyped) -> untyped } -> untyped
+
+          private
+
+          def cast_custom: (untyped from, untyped to) -> ::Range[untyped]
+          def custom_cast_single: (untyped value, ?bool negative) -> untyped
+          def custom_infinity: (bool negative) -> Float
+        end
+      end
+    end
+  end
+end
+
+class Float
+  prepend Torque::PostgreSQL::Adapter::OID::Range::Comparison
+end

data/sig/torque/postgresql/adapter/oid/segment.rbs

@@ -0,0 +1,38 @@
+module Torque
+  module PostgreSQL
+    class Segment < ::Struct[untyped]
+      def point0: () -> untyped
+      def point0=: (untyped value) -> untyped
+      def point1: () -> untyped
+      def point1=: (untyped value) -> untyped
+
+      def x1=: (Numeric value) -> untyped
+      def x1: () -> Numeric
+      def y1=: (Numeric value) -> untyped
+      def y1: () -> Numeric
+      def x2=: (Numeric value) -> untyped
+      def x2: () -> Numeric
+      def y2=: (Numeric value) -> untyped
+      def y2: () -> Numeric
+
+      private
+
+      def new_point: (Numeric x, Numeric y) -> untyped
+    end
+
+    module Adapter
+      module OID
+        class Segment < Torque::PostgreSQL::GeometryBuilder
+          PIECES: ::Array[Symbol]
+          FORMATION: String
+
+          def point_class: () -> Class
+          def build_klass: (*untyped args) -> untyped
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Segment < Torque::PostgreSQL::Segment
+end

data/sig/torque/postgresql/adapter/oid/struct.rbs

@@ -0,0 +1,41 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Struct < ActiveRecord::Type::Json
+          type backfill = bool | column_ref | ::Array[column_ref] | nil
+          type document = Hash[String, untyped]
+
+          attr_reader klass: Class
+          attr_reader type: Symbol
+          attr_reader backfill: backfill
+
+          @without_backfill: Struct
+
+          def self.state: (untyped value) -> untyped
+          def initialize: (Class klass, ?type: Symbol, ?backfill: backfill) -> void
+          def cast: (untyped value) -> untyped
+          def deserialize: (String | Hash[untyped, untyped] | nil value) -> untyped
+          def serialize: (untyped value) -> String?
+          def changed?: (untyped old_value, untyped new_value, untyped _new_value_before_cast) -> bool
+          def changed_in_place?: (String? raw_old_value, untyped new_value) -> bool
+          def without_backfill: () -> Struct
+          def empty?: (untyped value) -> bool
+          def document_for: (untyped value) -> document?
+          def document: (untyped value) -> document
+          def blank_document: () -> document
+          def ==: (untyped other) -> bool
+          alias eql? ==
+          def hash: () -> Integer
+
+          private
+
+          def parse: (untyped value) -> untyped
+          def build: (untyped data, ?from_database: bool, ?blank: bool) -> untyped
+          def blank!: (untyped instance) -> untyped
+          def load: (untyped instance, Hash[column_ref, untyped] data) -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/struct_list.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class StructList < Struct
+          def cast: (untyped value) -> untyped
+          def deserialize: (untyped value) -> ::Array[Attributes::Struct]
+          def serialize: (untyped value) -> String?
+          def document_for: (untyped value) -> ::Array[untyped]
+          def empty?: (untyped value) -> bool
+          def blank_document: () -> ::Array[untyped]
+
+          private
+
+          def encode: (::Array[untyped] items) -> String
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/struct_set.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class StructSet < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array[untyped]
+          @without_backfill: StructSet
+
+          def deserialize: (untyped value) -> ::Array[untyped]
+          def serialize: (untyped value) -> untyped
+          def changed_in_place?: (untyped raw_old_value, untyped new_value) -> bool
+          def without_backfill: () -> StructSet
+          def empty?: (untyped value) -> bool
+          def blank_document: () -> ::Array[untyped]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        def self.unwrap: (untyped type) -> type_caster?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module Quoting
+        type name = table_ref
+
+        QUOTED_TYPE_NAMES: untyped
+        Name: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::Name)
+        Column: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::Column)
+        ColumnDefinition: untyped
+        Utils: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::Utils)
+
+        def quote_type_name: (name name, *table_ref args) -> String
+        def quote_identifier_name: (name name, ?table_ref? schema) -> String
+        def quote_default_expression: (untyped value, untyped column) -> String
+        def lookup_cast_type_for_column: (column column) -> type_caster
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaCreation
+        def add_table_options!: (String create_sql, ActiveRecord::ConnectionAdapters::TableDefinition o) -> String
+      end
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaCreation
+  prepend Torque::PostgreSQL::Adapter::SchemaCreation
+end

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