1358 lines
43 KiB
Ruby
Generated
1358 lines
43 KiB
Ruby
Generated
# typed: true
|
|
|
|
# DO NOT EDIT MANUALLY
|
|
# This is an autogenerated file for dynamic methods in `BlobEntry`.
|
|
# Please instead update this file by running `bin/tapioca dsl BlobEntry`.
|
|
|
|
|
|
class BlobEntry
|
|
include GeneratedAssociationMethods
|
|
include GeneratedAttributeMethods
|
|
extend CommonRelationMethods
|
|
extend GeneratedRelationMethods
|
|
|
|
sig { returns(ColorLogger) }
|
|
def logger; end
|
|
|
|
private
|
|
|
|
sig { returns(NilClass) }
|
|
def to_ary; end
|
|
|
|
class << self
|
|
sig { returns(ColorLogger) }
|
|
def logger; end
|
|
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def new(attributes = nil, &block); end
|
|
end
|
|
|
|
module CommonRelationMethods
|
|
sig { params(block: T.nilable(T.proc.params(record: ::BlobEntry).returns(T.untyped))).returns(T::Boolean) }
|
|
def any?(&block); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
|
|
def average(column_name); end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(object: ::BlobEntry).void)).returns(::BlobEntry) }
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def build(attributes = nil, &block); end
|
|
|
|
sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
|
|
def calculate(operation, column_name); end
|
|
|
|
sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
|
|
sig { params(column_name: NilClass, block: T.proc.params(object: ::BlobEntry).void).returns(Integer) }
|
|
def count(column_name = nil, &block); end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(object: ::BlobEntry).void)).returns(::BlobEntry) }
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def create(attributes = nil, &block); end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(object: ::BlobEntry).void)).returns(::BlobEntry) }
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def create!(attributes = nil, &block); end
|
|
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def create_or_find_by(attributes, &block); end
|
|
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def create_or_find_by!(attributes, &block); end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def destroy_all; end
|
|
|
|
sig { params(conditions: T.untyped).returns(T::Boolean) }
|
|
def exists?(conditions = :none); end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def fifth; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def fifth!; end
|
|
|
|
sig do
|
|
params(
|
|
args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])
|
|
).returns(::BlobEntry)
|
|
end
|
|
sig do
|
|
params(
|
|
args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]
|
|
).returns(T::Enumerable[::BlobEntry])
|
|
end
|
|
sig { params(args: NilClass, block: T.proc.params(object: ::BlobEntry).void).returns(T.nilable(::BlobEntry)) }
|
|
def find(args = nil, &block); end
|
|
|
|
sig { params(args: T.untyped).returns(T.nilable(::BlobEntry)) }
|
|
def find_by(*args); end
|
|
|
|
sig { params(args: T.untyped).returns(::BlobEntry) }
|
|
def find_by!(*args); end
|
|
|
|
sig do
|
|
params(
|
|
start: T.untyped,
|
|
finish: T.untyped,
|
|
batch_size: Integer,
|
|
error_on_ignore: T.untyped,
|
|
order: Symbol,
|
|
block: T.proc.params(object: ::BlobEntry).void
|
|
).void
|
|
end
|
|
sig do
|
|
params(
|
|
start: T.untyped,
|
|
finish: T.untyped,
|
|
batch_size: Integer,
|
|
error_on_ignore: T.untyped,
|
|
order: Symbol
|
|
).returns(T::Enumerator[::BlobEntry])
|
|
end
|
|
def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
|
|
|
|
sig do
|
|
params(
|
|
start: T.untyped,
|
|
finish: T.untyped,
|
|
batch_size: Integer,
|
|
error_on_ignore: T.untyped,
|
|
order: Symbol,
|
|
block: T.proc.params(object: T::Array[::BlobEntry]).void
|
|
).void
|
|
end
|
|
sig do
|
|
params(
|
|
start: T.untyped,
|
|
finish: T.untyped,
|
|
batch_size: Integer,
|
|
error_on_ignore: T.untyped,
|
|
order: Symbol
|
|
).returns(T::Enumerator[T::Enumerator[::BlobEntry]])
|
|
end
|
|
def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
|
|
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def find_or_create_by(attributes, &block); end
|
|
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def find_or_create_by!(attributes, &block); end
|
|
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def find_or_initialize_by(attributes, &block); end
|
|
|
|
sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::BlobEntry)) }
|
|
def find_signed(signed_id, purpose: nil); end
|
|
|
|
sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::BlobEntry) }
|
|
def find_signed!(signed_id, purpose: nil); end
|
|
|
|
sig { params(arg: T.untyped, args: T.untyped).returns(::BlobEntry) }
|
|
def find_sole_by(arg, *args); end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
sig { params(limit: Integer).returns(T::Array[::BlobEntry]) }
|
|
def first(limit = nil); end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def first!; end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def forty_two; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def forty_two!; end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def fourth; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def fourth!; end
|
|
|
|
sig { returns(Array) }
|
|
def ids; end
|
|
|
|
sig do
|
|
params(
|
|
of: Integer,
|
|
start: T.untyped,
|
|
finish: T.untyped,
|
|
load: T.untyped,
|
|
error_on_ignore: T.untyped,
|
|
order: Symbol,
|
|
use_ranges: T.untyped,
|
|
block: T.proc.params(object: PrivateRelation).void
|
|
).void
|
|
end
|
|
sig do
|
|
params(
|
|
of: Integer,
|
|
start: T.untyped,
|
|
finish: T.untyped,
|
|
load: T.untyped,
|
|
error_on_ignore: T.untyped,
|
|
order: Symbol,
|
|
use_ranges: T.untyped
|
|
).returns(::ActiveRecord::Batches::BatchEnumerator)
|
|
end
|
|
def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
|
|
|
|
sig { params(record: T.untyped).returns(T::Boolean) }
|
|
def include?(record); end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
sig { params(limit: Integer).returns(T::Array[::BlobEntry]) }
|
|
def last(limit = nil); end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def last!; end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(record: ::BlobEntry).returns(T.untyped))).returns(T::Boolean) }
|
|
def many?(&block); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
|
|
def maximum(column_name); end
|
|
|
|
sig { params(record: T.untyped).returns(T::Boolean) }
|
|
def member?(record); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
|
|
def minimum(column_name); end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(object: ::BlobEntry).void)).returns(::BlobEntry) }
|
|
sig do
|
|
params(
|
|
attributes: T::Array[T.untyped],
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
sig do
|
|
params(
|
|
attributes: T.untyped,
|
|
block: T.nilable(T.proc.params(object: ::BlobEntry).void)
|
|
).returns(::BlobEntry)
|
|
end
|
|
def new(attributes = nil, &block); end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(record: ::BlobEntry).returns(T.untyped))).returns(T::Boolean) }
|
|
def none?(&block); end
|
|
|
|
sig { params(block: T.nilable(T.proc.params(record: ::BlobEntry).returns(T.untyped))).returns(T::Boolean) }
|
|
def one?(&block); end
|
|
|
|
sig { params(column_names: T.untyped).returns(T.untyped) }
|
|
def pick(*column_names); end
|
|
|
|
sig { params(column_names: T.untyped).returns(T.untyped) }
|
|
def pluck(*column_names); end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def second; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def second!; end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def second_to_last; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def second_to_last!; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def sole; end
|
|
|
|
sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
|
|
sig do
|
|
type_parameters(:U)
|
|
.params(
|
|
initial_value_or_column: T.nilable(T.type_parameter(:U)),
|
|
block: T.proc.params(object: ::BlobEntry).returns(T.type_parameter(:U))
|
|
).returns(T.type_parameter(:U))
|
|
end
|
|
def sum(initial_value_or_column = nil, &block); end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
sig { params(limit: Integer).returns(T::Array[::BlobEntry]) }
|
|
def take(limit = nil); end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def take!; end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def third; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def third!; end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def third_to_last; end
|
|
|
|
sig { returns(::BlobEntry) }
|
|
def third_to_last!; end
|
|
end
|
|
|
|
module GeneratedAssociationMethods
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def base; end
|
|
|
|
sig { params(value: T.nilable(::BlobEntry)).void }
|
|
def base=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def base_changed?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def base_previously_changed?; end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(::BlobEntry) }
|
|
def build_base(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(::BlobEntry) }
|
|
def create_base(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(::BlobEntry) }
|
|
def create_base!(*args, &blk); end
|
|
|
|
sig { returns(T.nilable(::BlobEntry)) }
|
|
def reload_base; end
|
|
|
|
sig { void }
|
|
def reset_base; end
|
|
end
|
|
|
|
module GeneratedAssociationRelationMethods
|
|
sig { returns(PrivateAssociationRelation) }
|
|
def all; end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def and(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def annotate(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def arel_columns(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def create_with(*args, &blk); end
|
|
|
|
sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
|
|
def distinct(value = true); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def eager_load(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def except(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def excluding(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def extending(*args, &blk); end
|
|
|
|
sig { params(association: Symbol).returns(T::Array[T.untyped]) }
|
|
def extract_associated(association); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def from(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
|
|
def group(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def having(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def in_order_of(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def includes(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def invert_where(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def joins(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def left_joins(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def left_outer_joins(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def limit(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def lock(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def merge(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def none(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def null_relation?(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def offset(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def only(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def optimizer_hints(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def or(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def order(*args, &blk); end
|
|
|
|
sig do
|
|
params(
|
|
num: T.any(Integer, String)
|
|
).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
|
|
end
|
|
def page(num = nil); end
|
|
|
|
sig do
|
|
params(
|
|
num: Integer
|
|
).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
|
|
end
|
|
def per(num); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def preload(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def readonly(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def references(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def regroup(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def reorder(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def reselect(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def reverse_order(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def rewhere(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
|
|
sig { params(blk: T.proc.params(record: ::BlobEntry).returns(T::Boolean)).returns(T::Array[::BlobEntry]) }
|
|
def select(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def strict_loading(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def structurally_compatible?(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def uniq!(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def unscope(*args, &blk); end
|
|
|
|
sig { returns(PrivateAssociationRelationWhereChain) }
|
|
sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
|
|
def where(*args); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def with(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def with_recursive(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
|
|
def without(*args, &blk); end
|
|
|
|
sig do
|
|
returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
|
|
end
|
|
def without_count; end
|
|
end
|
|
|
|
module GeneratedAttributeMethods
|
|
sig { returns(T.nilable(::String)) }
|
|
def base_sha256; end
|
|
|
|
sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
|
|
def base_sha256=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def base_sha256?; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def base_sha256_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def base_sha256_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def base_sha256_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def base_sha256_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def base_sha256_change_to_be_saved; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def base_sha256_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def base_sha256_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def base_sha256_previous_change; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def base_sha256_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def base_sha256_previously_was; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def base_sha256_was; end
|
|
|
|
sig { void }
|
|
def base_sha256_will_change!; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def content_type; end
|
|
|
|
sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
|
|
def content_type=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def content_type?; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def content_type_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def content_type_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def content_type_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def content_type_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def content_type_change_to_be_saved; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def content_type_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def content_type_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def content_type_previous_change; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def content_type_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def content_type_previously_was; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def content_type_was; end
|
|
|
|
sig { void }
|
|
def content_type_will_change!; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def contents; end
|
|
|
|
sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
|
|
def contents=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def contents?; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def contents_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def contents_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def contents_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def contents_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def contents_change_to_be_saved; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def contents_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def contents_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def contents_previous_change; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def contents_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def contents_previously_was; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def contents_was; end
|
|
|
|
sig { void }
|
|
def contents_will_change!; end
|
|
|
|
sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
|
|
def created_at; end
|
|
|
|
sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
|
|
def created_at=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def created_at?; end
|
|
|
|
sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
|
|
def created_at_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def created_at_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def created_at_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
|
|
def created_at_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
|
|
def created_at_change_to_be_saved; end
|
|
|
|
sig do
|
|
params(
|
|
from: T.nilable(::ActiveSupport::TimeWithZone),
|
|
to: T.nilable(::ActiveSupport::TimeWithZone)
|
|
).returns(T::Boolean)
|
|
end
|
|
def created_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
|
|
def created_at_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
|
|
def created_at_previous_change; end
|
|
|
|
sig do
|
|
params(
|
|
from: T.nilable(::ActiveSupport::TimeWithZone),
|
|
to: T.nilable(::ActiveSupport::TimeWithZone)
|
|
).returns(T::Boolean)
|
|
end
|
|
def created_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
|
|
def created_at_previously_was; end
|
|
|
|
sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
|
|
def created_at_was; end
|
|
|
|
sig { void }
|
|
def created_at_will_change!; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def id; end
|
|
|
|
sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
|
|
def id=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def id?; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def id_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def id_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def id_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def id_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def id_change_to_be_saved; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def id_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def id_previous_change; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def id_previously_was; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def id_was; end
|
|
|
|
sig { void }
|
|
def id_will_change!; end
|
|
|
|
sig { void }
|
|
def restore_base_sha256!; end
|
|
|
|
sig { void }
|
|
def restore_content_type!; end
|
|
|
|
sig { void }
|
|
def restore_contents!; end
|
|
|
|
sig { void }
|
|
def restore_created_at!; end
|
|
|
|
sig { void }
|
|
def restore_id!; end
|
|
|
|
sig { void }
|
|
def restore_sha256!; end
|
|
|
|
sig { void }
|
|
def restore_size!; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def saved_change_to_base_sha256; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_base_sha256?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def saved_change_to_content_type; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_content_type?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def saved_change_to_contents; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_contents?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
|
|
def saved_change_to_created_at; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_created_at?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def saved_change_to_id; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_id?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def saved_change_to_sha256; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_sha256?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
|
|
def saved_change_to_size; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def saved_change_to_size?; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def sha256; end
|
|
|
|
sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
|
|
def sha256=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def sha256?; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def sha256_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def sha256_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def sha256_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def sha256_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def sha256_change_to_be_saved; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def sha256_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def sha256_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
|
|
def sha256_previous_change; end
|
|
|
|
sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
|
|
def sha256_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def sha256_previously_was; end
|
|
|
|
sig { returns(T.nilable(::String)) }
|
|
def sha256_was; end
|
|
|
|
sig { void }
|
|
def sha256_will_change!; end
|
|
|
|
sig { returns(T.nilable(::Integer)) }
|
|
def size; end
|
|
|
|
sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
|
|
def size=(value); end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def size?; end
|
|
|
|
sig { returns(T.nilable(::Integer)) }
|
|
def size_before_last_save; end
|
|
|
|
sig { returns(T.untyped) }
|
|
def size_before_type_cast; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def size_came_from_user?; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
|
|
def size_change; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
|
|
def size_change_to_be_saved; end
|
|
|
|
sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
|
|
def size_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::Integer)) }
|
|
def size_in_database; end
|
|
|
|
sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
|
|
def size_previous_change; end
|
|
|
|
sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
|
|
def size_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
|
|
|
|
sig { returns(T.nilable(::Integer)) }
|
|
def size_previously_was; end
|
|
|
|
sig { returns(T.nilable(::Integer)) }
|
|
def size_was; end
|
|
|
|
sig { void }
|
|
def size_will_change!; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_base_sha256?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_content_type?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_contents?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_created_at?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_id?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_sha256?; end
|
|
|
|
sig { returns(T::Boolean) }
|
|
def will_save_change_to_size?; end
|
|
end
|
|
|
|
module GeneratedRelationMethods
|
|
sig { returns(PrivateRelation) }
|
|
def all; end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def and(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def annotate(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def arel_columns(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def create_with(*args, &blk); end
|
|
|
|
sig { params(value: T::Boolean).returns(PrivateRelation) }
|
|
def distinct(value = true); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def eager_load(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def except(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def excluding(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def extending(*args, &blk); end
|
|
|
|
sig { params(association: Symbol).returns(T::Array[T.untyped]) }
|
|
def extract_associated(association); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def from(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
|
|
def group(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def having(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def in_order_of(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def includes(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def invert_where(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def joins(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def left_joins(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def left_outer_joins(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def limit(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def lock(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def merge(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def none(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def null_relation?(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def offset(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def only(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def optimizer_hints(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def or(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def order(*args, &blk); end
|
|
|
|
sig do
|
|
params(
|
|
num: T.any(Integer, String)
|
|
).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
|
|
end
|
|
def page(num = nil); end
|
|
|
|
sig do
|
|
params(
|
|
num: Integer
|
|
).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
|
|
end
|
|
def per(num); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def preload(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def readonly(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def references(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def regroup(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def reorder(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def reselect(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def reverse_order(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def rewhere(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped).returns(PrivateRelation) }
|
|
sig { params(blk: T.proc.params(record: ::BlobEntry).returns(T::Boolean)).returns(T::Array[::BlobEntry]) }
|
|
def select(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def strict_loading(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def structurally_compatible?(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def uniq!(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def unscope(*args, &blk); end
|
|
|
|
sig { returns(PrivateRelationWhereChain) }
|
|
sig { params(args: T.untyped).returns(PrivateRelation) }
|
|
def where(*args); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def with(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def with_recursive(*args, &blk); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
|
|
def without(*args, &blk); end
|
|
|
|
sig { returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) }
|
|
def without_count; end
|
|
end
|
|
|
|
class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation
|
|
include CommonRelationMethods
|
|
include GeneratedAssociationRelationMethods
|
|
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def to_a; end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def to_ary; end
|
|
end
|
|
|
|
class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
|
|
def average(column_name); end
|
|
|
|
sig do
|
|
params(
|
|
operation: Symbol,
|
|
column_name: T.any(String, Symbol)
|
|
).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
|
|
end
|
|
def calculate(operation, column_name); end
|
|
|
|
sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
|
|
def count(column_name = nil); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
|
|
def having(*args, &blk); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
|
|
def maximum(column_name); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
|
|
def minimum(column_name); end
|
|
|
|
sig do
|
|
params(
|
|
column_name: T.nilable(T.any(String, Symbol)),
|
|
block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
|
|
).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
|
|
end
|
|
def size(column_name = nil, &block); end
|
|
|
|
sig do
|
|
params(
|
|
column_name: T.nilable(T.any(String, Symbol)),
|
|
block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
|
|
).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
|
|
end
|
|
def sum(column_name = nil, &block); end
|
|
end
|
|
|
|
class PrivateAssociationRelationWhereChain
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
|
|
def associated(*args); end
|
|
|
|
sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
|
|
def missing(*args); end
|
|
|
|
sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
|
|
def not(opts, *rest); end
|
|
end
|
|
|
|
class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
|
|
include CommonRelationMethods
|
|
include GeneratedAssociationRelationMethods
|
|
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig do
|
|
params(
|
|
records: T.any(::BlobEntry, T::Enumerable[T.any(::BlobEntry, T::Enumerable[::BlobEntry])])
|
|
).returns(PrivateCollectionProxy)
|
|
end
|
|
def <<(*records); end
|
|
|
|
sig do
|
|
params(
|
|
records: T.any(::BlobEntry, T::Enumerable[T.any(::BlobEntry, T::Enumerable[::BlobEntry])])
|
|
).returns(PrivateCollectionProxy)
|
|
end
|
|
def append(*records); end
|
|
|
|
sig { returns(PrivateCollectionProxy) }
|
|
def clear; end
|
|
|
|
sig do
|
|
params(
|
|
records: T.any(::BlobEntry, T::Enumerable[T.any(::BlobEntry, T::Enumerable[::BlobEntry])])
|
|
).returns(PrivateCollectionProxy)
|
|
end
|
|
def concat(*records); end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def load_target; end
|
|
|
|
sig do
|
|
params(
|
|
records: T.any(::BlobEntry, T::Enumerable[T.any(::BlobEntry, T::Enumerable[::BlobEntry])])
|
|
).returns(PrivateCollectionProxy)
|
|
end
|
|
def prepend(*records); end
|
|
|
|
sig do
|
|
params(
|
|
records: T.any(::BlobEntry, T::Enumerable[T.any(::BlobEntry, T::Enumerable[::BlobEntry])])
|
|
).returns(PrivateCollectionProxy)
|
|
end
|
|
def push(*records); end
|
|
|
|
sig do
|
|
params(
|
|
other_array: T.any(::BlobEntry, T::Enumerable[T.any(::BlobEntry, T::Enumerable[::BlobEntry])])
|
|
).returns(T::Array[::BlobEntry])
|
|
end
|
|
def replace(other_array); end
|
|
|
|
sig { returns(PrivateAssociationRelation) }
|
|
def scope; end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def target; end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def to_a; end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def to_ary; end
|
|
end
|
|
|
|
class PrivateRelation < ::ActiveRecord::Relation
|
|
include CommonRelationMethods
|
|
include GeneratedRelationMethods
|
|
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def to_a; end
|
|
|
|
sig { returns(T::Array[::BlobEntry]) }
|
|
def to_ary; end
|
|
end
|
|
|
|
class PrivateRelationGroupChain < PrivateRelation
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
|
|
def average(column_name); end
|
|
|
|
sig do
|
|
params(
|
|
operation: Symbol,
|
|
column_name: T.any(String, Symbol)
|
|
).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
|
|
end
|
|
def calculate(operation, column_name); end
|
|
|
|
sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
|
|
def count(column_name = nil); end
|
|
|
|
sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
|
|
def having(*args, &blk); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
|
|
def maximum(column_name); end
|
|
|
|
sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
|
|
def minimum(column_name); end
|
|
|
|
sig do
|
|
params(
|
|
column_name: T.nilable(T.any(String, Symbol)),
|
|
block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
|
|
).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
|
|
end
|
|
def size(column_name = nil, &block); end
|
|
|
|
sig do
|
|
params(
|
|
column_name: T.nilable(T.any(String, Symbol)),
|
|
block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
|
|
).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
|
|
end
|
|
def sum(column_name = nil, &block); end
|
|
end
|
|
|
|
class PrivateRelationWhereChain
|
|
Elem = type_member { { fixed: ::BlobEntry } }
|
|
|
|
sig { params(args: T.untyped).returns(PrivateRelation) }
|
|
def associated(*args); end
|
|
|
|
sig { params(args: T.untyped).returns(PrivateRelation) }
|
|
def missing(*args); end
|
|
|
|
sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
|
|
def not(opts, *rest); end
|
|
end
|
|
end
|