torque-postgresql 4.0.1 → 4.1.1

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

data/sig/torque/postgresql/inheritance.rbs

@@ -0,0 +1,47 @@
+module Torque
+  module PostgreSQL
+    class InheritanceError < ArgumentError
+    end
+
+    module Inheritance
+      extend ActiveSupport::Concern
+
+      type dependents = Hash[String, model]
+
+      module ClassMethods
+        def _record_class_attribute: () -> Symbol
+        def _record_class_column_name: () -> String
+        def inheritance_merged_attributes: () -> Array[String]
+        def inheritance_mergeable_attributes: () -> Array[String]
+        def physically_inherited?: () -> bool
+        def inheritance_dependents: () -> Array[String]
+        def physically_inheritances?: () -> bool
+        def inheritance_column_prefix: () -> String
+        def physically_inheritance_root: () -> model
+        def inheritance_foreign_attribute_names: () -> Set[String]
+        def inheritance_dependent_prefixes: () -> Set[String]
+        def casted_dependents: () -> dependents
+        def inheritance_expandable_dependents: () -> dependents
+        def reset_table_name: () -> (String | TableName)
+        def decorated_table_name: () -> String
+        def base_class: () -> model
+        def primary_key: () -> (String | Array[String] | nil)
+        def compute_table_name: () -> (String | TableName)
+        def raise_unable_to_cast: (String record_class_value) -> bot
+        def reload_schema_from_cache: (?bool recursive) -> untyped
+
+        private
+
+        def inheritance_cache: (Symbol name) { () -> untyped } -> untyped
+        def instantiate_instance_of: (model klass, Hash[String, untyped] attributes, ?Hash[String, type_caster] types) ?{ (record) -> void } -> record
+        def sanitize_attributes: (model real_class, Hash[String, untyped] attributes, Hash[String, type_caster] types) -> [Hash[String, untyped], Hash[String, type_caster]]
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Torque::PostgreSQL::Inheritance
+  extend Torque::PostgreSQL::Inheritance::ClassMethods
+  include Torque::PostgreSQL::Inheritance::Record
+end

data/sig/torque/postgresql/insert_all.rbs

@@ -0,0 +1,22 @@
+module Torque
+  module PostgreSQL
+    module InsertAll
+      attr_reader where: String | relation | nil
+
+      def initialize: (*untyped args, ?where: String | relation | nil, **untyped xargs) -> void
+
+      module Builder
+        def where: () -> (String | relation | nil)
+        def where_condition?: () -> bool
+      end
+    end
+  end
+end
+
+class ActiveRecord::InsertAll
+  prepend Torque::PostgreSQL::InsertAll
+
+  class Builder
+    include Torque::PostgreSQL::InsertAll::Builder
+  end
+end

data/sig/torque/postgresql/migration/command_recorder.rbs

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Migration
+      module CommandRecorder
+        type inversion = [Symbol, Array[untyped]]
+
+        def rename_type: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_rename_type: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def create_composite_type: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_create_composite_type: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def change_composite_type: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def add_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_add_composite_column: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def remove_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_remove_composite_column: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def change_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def rename_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_rename_composite_column: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def sync_inheritance_features: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_sync_inheritance_features: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def create_schema: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_create_schema: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+      end
+    end
+  end
+end
+
+class ActiveRecord::Migration::CommandRecorder
+  include Torque::PostgreSQL::Migration::CommandRecorder
+end

data/sig/torque/postgresql/migration.rbs

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

data/sig/torque/postgresql/predicate_builder/arel_attribute_handler.rbs

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class ArelAttributeHandler
+        def self.call: (arel_node attribute, arel_node value) -> arel_node
+        def initialize: (*untyped) -> void
+        def call: (arel_node attribute, arel_node value) -> arel_node
+
+        private
+
+        def array_typed?: (arel_node attribute) -> bool
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/array_handler.rbs

@@ -0,0 +1,26 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      module ArrayHandler
+        def call: (arel_node attribute, untyped value) -> arel_node
+        def call_for_array: (arel_node attribute, untyped value) -> arel_node
+
+        private
+
+        def call_with_value: (arel_node attribute, untyped value) -> ::Arel::Nodes::InfixOperation
+        def call_with_array: (arel_node attribute, Array[untyped] value) -> ::Arel::Nodes::InfixOperation
+        def call_with_empty: (arel_node attribute) -> arel_node
+        def id_of: (untyped entry) -> untyped
+        def array_attribute?: (arel_node attribute) -> bool
+      end
+    end
+  end
+end
+
+class ActiveRecord::PredicateBuilder::ArrayHandler
+  prepend Torque::PostgreSQL::PredicateBuilder::ArrayHandler
+end
+
+class ActiveRecord::PredicateBuilder::BasicObjectHandler
+  prepend Torque::PostgreSQL::PredicateBuilder::ArrayHandler
+end

data/sig/torque/postgresql/predicate_builder/composite_handler.rbs

@@ -0,0 +1,26 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class CompositeHandler
+        @predicate_builder: ActiveRecord::PredicateBuilder
+        @composite: Adapter::OID::Composite?
+
+        def self.candidate?: (type_caster? type, ?untyped value) -> bool
+        def self.columns?: (untyped value) -> bool
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_node attribute, type_caster type, untyped value) -> arel_node
+        def table_for: (arel_node source, type_caster type) -> PredicateTable
+        def type_of: (column_ref name) -> [type_caster]
+
+        private
+
+        def predicate_builder: () -> ActiveRecord::PredicateBuilder
+        def composite: () -> Adapter::OID::Composite?
+        def call_for_record: (arel_node attribute, untyped value, bool array) -> arel_node
+        def call_for_array: (arel_node attribute, untyped value) -> arel_node
+        def conditions_for: (arel_node source, untyped value) -> arel_node
+        def group_for: (arel_node source, untyped entry) -> ::Arel::Nodes::Grouping
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/enumerator_lazy_handler.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class EnumeratorLazyHandler < ::ActiveRecord::PredicateBuilder::ArrayHandler
+        class Timeout < ::Timeout::Error
+        end
+
+        def call: (arel_attribute attribute, Enumerator::Lazy[untyped, untyped] value) -> arel_node
+
+        private
+
+        def with_timeout: () { () -> arel_node } -> arel_node
+        def timeout: () -> Numeric?
+        def limit: () -> Integer?
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/ltree_handler.rbs

@@ -0,0 +1,36 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class LtreeHandler
+        @predicate_builder: ActiveRecord::PredicateBuilder
+        @attribute: arel_attribute
+        @column: Adapter::OID::Ltree
+        @array: bool
+        @list: bool
+
+        def self.candidate?: (type_caster? type) -> bool
+        def self.column_of: (type_caster? type) -> type_caster?
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_attribute attribute, type_caster type, untyped value) -> arel_node
+
+        private
+
+        def attribute: () -> arel_attribute
+        def column: () -> Adapter::OID::Ltree
+        def array: () -> bool
+        def list: () -> bool
+        def list?: (untyped value) -> bool
+        def lquery_column?: () -> bool
+        def lquery: () -> Adapter::OID::Lquery
+        def ltree: () -> Adapter::OID::Ltree
+        def bind: (untyped value, type_caster type) -> ::Arel::Nodes::BindParam
+        def equality: (Array[untyped] values) -> arel_node
+        def single_equality: (arel_node target, arel_node bind) -> arel_node
+        def empty_equality: (arel_node target) -> arel_node
+        def match: (Array[untyped] values) -> arel_node
+        def single_match: (arel_node bind) -> arel_node
+        def list_match: (arel_node binds) -> arel_node
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/regexp_handler.rbs

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class RegexpHandler
+        @predicate_builder: ActiveRecord::PredicateBuilder
+
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_attribute attribute, Regexp value) -> ::Arel::Nodes::InfixOperation
+
+        private
+
+        def predicate_builder: () -> ActiveRecord::PredicateBuilder
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/struct_handler.rbs

@@ -0,0 +1,24 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class StructHandler
+        PLAIN_TYPES: Array[Symbol]
+
+        @predicate_builder: ActiveRecord::PredicateBuilder
+        @struct: type_caster?
+
+        def self.candidate?: (type_caster? type, ?untyped value) -> bool
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_node attribute, type_caster struct, Hash[untyped, untyped] value) -> ::Arel::Nodes::Grouping
+        def table_for: (arel_node attribute, type_caster? struct) -> PredicateTable
+        def property_for: (arel_node attribute, type_caster? struct, Array[path_key] path) -> arel_node
+        def type_of: (path_key name) -> [type_caster?, String?]
+
+        private
+
+        def predicate_builder: () -> ActiveRecord::PredicateBuilder
+        def cast_for: (type_caster? type) -> String?
+      end
+    end
+  end
+end