From 53ed7e1aeae7a255e89db3c262f4070e6bbff6ee Mon Sep 17 00:00:00 2001 From: Matthew Landauer Date: Wed, 11 Sep 2024 04:02:54 +0000 Subject: [PATCH] bin/tapioca dsl -e=test --- sorbet/rbi/dsl/api_key.rbi | 14 + sorbet/rbi/dsl/authority.rbi | 14 + .../rbi/dsl/generated_path_helpers_module.rbi | 3 + .../rbi/dsl/generated_url_helpers_module.rbi | 3 + sorbet/rbi/dsl/paper_trail/version.rbi | 1401 +++++++++++++++++ 5 files changed, 1435 insertions(+) create mode 100644 sorbet/rbi/dsl/paper_trail/version.rbi diff --git a/sorbet/rbi/dsl/api_key.rbi b/sorbet/rbi/dsl/api_key.rbi index bd58bb7b9..c6c5e2a7d 100644 --- a/sorbet/rbi/dsl/api_key.rbi +++ b/sorbet/rbi/dsl/api_key.rbi @@ -300,6 +300,20 @@ class ApiKey sig { params(value: T.nilable(::User)).void } def user=(value); end + + sig { returns(T::Array[T.untyped]) } + def version_ids; end + + sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } + def version_ids=(ids); end + + # This method is created by ActiveRecord on the `ApiKey` class because it declared `has_many :versions`. + # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) + sig { returns(::PaperTrail::Version::PrivateCollectionProxy) } + def versions; end + + sig { params(value: T::Enumerable[::PaperTrail::Version]).void } + def versions=(value); end end module GeneratedAssociationRelationMethods diff --git a/sorbet/rbi/dsl/authority.rbi b/sorbet/rbi/dsl/authority.rbi index 2f353a545..f8daf6e6b 100644 --- a/sorbet/rbi/dsl/authority.rbi +++ b/sorbet/rbi/dsl/authority.rbi @@ -359,6 +359,20 @@ class Authority sig { void } def reset_github_issue; end + + sig { returns(T::Array[T.untyped]) } + def version_ids; end + + sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } + def version_ids=(ids); end + + # This method is created by ActiveRecord on the `Authority` class because it declared `has_many :versions`. + # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) + sig { returns(::PaperTrail::Version::PrivateCollectionProxy) } + def versions; end + + sig { params(value: T::Enumerable[::PaperTrail::Version]).void } + def versions=(value); end end module GeneratedAssociationRelationMethods diff --git a/sorbet/rbi/dsl/generated_path_helpers_module.rbi b/sorbet/rbi/dsl/generated_path_helpers_module.rbi index 79f432489..1cd84e806 100644 --- a/sorbet/rbi/dsl/generated_path_helpers_module.rbi +++ b/sorbet/rbi/dsl/generated_path_helpers_module.rbi @@ -57,6 +57,9 @@ module GeneratedPathHelpersModule sig { params(args: T.untyped).returns(String) } def admin_flipper_path(*args); end + sig { params(args: T.untyped).returns(String) } + def admin_homes_path(*args); end + sig { params(args: T.untyped).returns(String) } def admin_report_path(*args); end diff --git a/sorbet/rbi/dsl/generated_url_helpers_module.rbi b/sorbet/rbi/dsl/generated_url_helpers_module.rbi index acb441ffb..66c9e7713 100644 --- a/sorbet/rbi/dsl/generated_url_helpers_module.rbi +++ b/sorbet/rbi/dsl/generated_url_helpers_module.rbi @@ -57,6 +57,9 @@ module GeneratedUrlHelpersModule sig { params(args: T.untyped).returns(String) } def admin_flipper_url(*args); end + sig { params(args: T.untyped).returns(String) } + def admin_homes_url(*args); end + sig { params(args: T.untyped).returns(String) } def admin_report_url(*args); end diff --git a/sorbet/rbi/dsl/paper_trail/version.rbi b/sorbet/rbi/dsl/paper_trail/version.rbi new file mode 100644 index 000000000..00653334b --- /dev/null +++ b/sorbet/rbi/dsl/paper_trail/version.rbi @@ -0,0 +1,1401 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `PaperTrail::Version`. +# Please instead update this file by running `bin/tapioca dsl PaperTrail::Version`. + + +class PaperTrail::Version + include GeneratedAssociationMethods + include GeneratedAttributeMethods + extend CommonRelationMethods + extend GeneratedRelationMethods + + private + + sig { returns(NilClass) } + def to_ary; end + + module CommonRelationMethods + sig do + params( + block: T.nilable(T.proc.params(record: ::PaperTrail::Version).returns(T.untyped)) + ).returns(T::Boolean) + end + def any?(&block); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) } + def average(column_name); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + 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: ::PaperTrail::Version).void).returns(Integer) } + def count(column_name = nil, &block); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def create(attributes = nil, &block); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def create!(attributes = nil, &block); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def create_or_find_by(attributes, &block); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def create_or_find_by!(attributes, &block); end + + sig { returns(T::Array[::PaperTrail::Version]) } + def destroy_all; end + + sig { params(conditions: T.untyped).returns(T::Boolean) } + def exists?(conditions = :none); end + + sig { returns(T.nilable(::PaperTrail::Version)) } + def fifth; end + + sig { returns(::PaperTrail::Version) } + 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(::PaperTrail::Version) + 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[::PaperTrail::Version]) + end + sig do + params( + args: NilClass, + block: T.proc.params(object: ::PaperTrail::Version).void + ).returns(T.nilable(::PaperTrail::Version)) + end + def find(args = nil, &block); end + + sig { params(args: T.untyped).returns(T.nilable(::PaperTrail::Version)) } + def find_by(*args); end + + sig { params(args: T.untyped).returns(::PaperTrail::Version) } + 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: ::PaperTrail::Version).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[::PaperTrail::Version]) + 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[::PaperTrail::Version]).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[::PaperTrail::Version]]) + 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.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def find_or_create_by(attributes, &block); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def find_or_create_by!(attributes, &block); end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def find_or_initialize_by(attributes, &block); end + + sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::PaperTrail::Version)) } + def find_signed(signed_id, purpose: nil); end + + sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::PaperTrail::Version) } + def find_signed!(signed_id, purpose: nil); end + + sig { params(arg: T.untyped, args: T.untyped).returns(::PaperTrail::Version) } + def find_sole_by(arg, *args); end + + sig { params(limit: NilClass).returns(T.nilable(::PaperTrail::Version)) } + sig { params(limit: Integer).returns(T::Array[::PaperTrail::Version]) } + def first(limit = nil); end + + sig { returns(::PaperTrail::Version) } + def first!; end + + sig { returns(T.nilable(::PaperTrail::Version)) } + def forty_two; end + + sig { returns(::PaperTrail::Version) } + def forty_two!; end + + sig { returns(T.nilable(::PaperTrail::Version)) } + def fourth; end + + sig { returns(::PaperTrail::Version) } + 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 { params(limit: NilClass).returns(T.nilable(::PaperTrail::Version)) } + sig { params(limit: Integer).returns(T::Array[::PaperTrail::Version]) } + def last(limit = nil); end + + sig { returns(::PaperTrail::Version) } + def last!; end + + sig do + params( + block: T.nilable(T.proc.params(record: ::PaperTrail::Version).returns(T.untyped)) + ).returns(T::Boolean) + end + 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 do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::PaperTrail::Version).void) + ).returns(::PaperTrail::Version) + end + def new(attributes = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(record: ::PaperTrail::Version).returns(T.untyped)) + ).returns(T::Boolean) + end + def none?(&block); end + + sig do + params( + block: T.nilable(T.proc.params(record: ::PaperTrail::Version).returns(T.untyped)) + ).returns(T::Boolean) + end + 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(::PaperTrail::Version)) } + def second; end + + sig { returns(::PaperTrail::Version) } + def second!; end + + sig { returns(T.nilable(::PaperTrail::Version)) } + def second_to_last; end + + sig { returns(::PaperTrail::Version) } + def second_to_last!; end + + sig { returns(::PaperTrail::Version) } + 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: ::PaperTrail::Version).returns(T.type_parameter(:U)) + ).returns(T.type_parameter(:U)) + end + def sum(initial_value_or_column = nil, &block); end + + sig { params(limit: NilClass).returns(T.nilable(::PaperTrail::Version)) } + sig { params(limit: Integer).returns(T::Array[::PaperTrail::Version]) } + def take(limit = nil); end + + sig { returns(::PaperTrail::Version) } + def take!; end + + sig { returns(T.nilable(::PaperTrail::Version)) } + def third; end + + sig { returns(::PaperTrail::Version) } + def third!; end + + sig { returns(T.nilable(::PaperTrail::Version)) } + def third_to_last; end + + sig { returns(::PaperTrail::Version) } + def third_to_last!; end + end + + module GeneratedAssociationMethods + sig { returns(T.untyped) } + def item; end + + sig { params(value: T.untyped).void } + def item=(value); end + + sig { returns(T.untyped) } + def reload_item; end + + sig { void } + def reset_item; 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 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 do + params( + attributes: Hash, + returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), + unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) + ).returns(ActiveRecord::Result) + end + def insert(attributes, returning: nil, unique_by: nil); end + + sig do + params( + attributes: Hash, + returning: T.nilable(T.any(T::Array[Symbol], FalseClass)) + ).returns(ActiveRecord::Result) + end + def insert!(attributes, returning: nil); end + + sig do + params( + attributes: T::Array[Hash], + returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), + unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) + ).returns(ActiveRecord::Result) + end + def insert_all(attributes, returning: nil, unique_by: nil); end + + sig do + params( + attributes: T::Array[Hash], + returning: T.nilable(T.any(T::Array[Symbol], FalseClass)) + ).returns(ActiveRecord::Result) + end + def insert_all!(attributes, returning: nil); 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 { 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, blk: T.untyped).returns(PrivateAssociationRelation) } + 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 do + params( + attributes: Hash, + returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), + unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) + ).returns(ActiveRecord::Result) + end + def upsert(attributes, returning: nil, unique_by: nil); end + + sig do + params( + attributes: T::Array[Hash], + returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), + unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) + ).returns(ActiveRecord::Result) + end + def upsert_all(attributes, returning: nil, unique_by: nil); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationWhereChain) } + def where(*args, &blk); 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 without(*args, &blk); end + end + + module GeneratedAttributeMethods + 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(::String) } + def event; end + + sig { params(value: ::String).returns(::String) } + def event=(value); end + + sig { returns(T::Boolean) } + def event?; end + + sig { returns(T.nilable(::String)) } + def event_before_last_save; end + + sig { returns(T.untyped) } + def event_before_type_cast; end + + sig { returns(T::Boolean) } + def event_came_from_user?; end + + sig { returns(T.nilable([::String, ::String])) } + def event_change; end + + sig { returns(T.nilable([::String, ::String])) } + def event_change_to_be_saved; end + + sig { params(from: ::String, to: ::String).returns(T::Boolean) } + def event_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def event_in_database; end + + sig { returns(T.nilable([::String, ::String])) } + def event_previous_change; end + + sig { params(from: ::String, to: ::String).returns(T::Boolean) } + def event_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def event_previously_was; end + + sig { returns(T.nilable(::String)) } + def event_was; end + + sig { void } + def event_will_change!; end + + sig { returns(::Integer) } + def id; end + + sig { params(value: ::Integer).returns(::Integer) } + def id=(value); end + + sig { returns(T::Boolean) } + def id?; end + + sig { returns(T.nilable(::Integer)) } + 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([::Integer, ::Integer])) } + def id_change; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def id_change_to_be_saved; end + + sig { params(from: ::Integer, to: ::Integer).returns(T::Boolean) } + def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_in_database; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def id_previous_change; end + + sig { params(from: ::Integer, to: ::Integer).returns(T::Boolean) } + def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_previously_was; end + + sig { returns(::Integer) } + def id_value; end + + sig { params(value: ::Integer).returns(::Integer) } + def id_value=(value); end + + sig { returns(T::Boolean) } + def id_value?; end + + sig { returns(T.nilable(::Integer)) } + def id_value_before_last_save; end + + sig { returns(T.untyped) } + def id_value_before_type_cast; end + + sig { returns(T::Boolean) } + def id_value_came_from_user?; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def id_value_change; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def id_value_change_to_be_saved; end + + sig { params(from: ::Integer, to: ::Integer).returns(T::Boolean) } + def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_value_in_database; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def id_value_previous_change; end + + sig { params(from: ::Integer, to: ::Integer).returns(T::Boolean) } + def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_value_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def id_value_was; end + + sig { void } + def id_value_will_change!; end + + sig { returns(T.nilable(::Integer)) } + def id_was; end + + sig { void } + def id_will_change!; end + + sig { returns(::Integer) } + def item_id; end + + sig { params(value: ::Integer).returns(::Integer) } + def item_id=(value); end + + sig { returns(T::Boolean) } + def item_id?; end + + sig { returns(T.nilable(::Integer)) } + def item_id_before_last_save; end + + sig { returns(T.untyped) } + def item_id_before_type_cast; end + + sig { returns(T::Boolean) } + def item_id_came_from_user?; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def item_id_change; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def item_id_change_to_be_saved; end + + sig { params(from: ::Integer, to: ::Integer).returns(T::Boolean) } + def item_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def item_id_in_database; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def item_id_previous_change; end + + sig { params(from: ::Integer, to: ::Integer).returns(T::Boolean) } + def item_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def item_id_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def item_id_was; end + + sig { void } + def item_id_will_change!; end + + sig { returns(::String) } + def item_type; end + + sig { params(value: ::String).returns(::String) } + def item_type=(value); end + + sig { returns(T::Boolean) } + def item_type?; end + + sig { returns(T.nilable(::String)) } + def item_type_before_last_save; end + + sig { returns(T.untyped) } + def item_type_before_type_cast; end + + sig { returns(T::Boolean) } + def item_type_came_from_user?; end + + sig { returns(T.nilable([::String, ::String])) } + def item_type_change; end + + sig { returns(T.nilable([::String, ::String])) } + def item_type_change_to_be_saved; end + + sig { params(from: ::String, to: ::String).returns(T::Boolean) } + def item_type_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def item_type_in_database; end + + sig { returns(T.nilable([::String, ::String])) } + def item_type_previous_change; end + + sig { params(from: ::String, to: ::String).returns(T::Boolean) } + def item_type_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def item_type_previously_was; end + + sig { returns(T.nilable(::String)) } + def item_type_was; end + + sig { void } + def item_type_will_change!; end + + sig { returns(T.untyped) } + def object; end + + sig { params(value: T.untyped).returns(T.untyped) } + def object=(value); end + + sig { returns(T::Boolean) } + def object?; end + + sig { returns(T.untyped) } + def object_before_last_save; end + + sig { returns(T.untyped) } + def object_before_type_cast; end + + sig { returns(T::Boolean) } + def object_came_from_user?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def object_change; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def object_change_to_be_saved; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def object_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def object_changes; end + + sig { params(value: T.untyped).returns(T.untyped) } + def object_changes=(value); end + + sig { returns(T::Boolean) } + def object_changes?; end + + sig { returns(T.untyped) } + def object_changes_before_last_save; end + + sig { returns(T.untyped) } + def object_changes_before_type_cast; end + + sig { returns(T::Boolean) } + def object_changes_came_from_user?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def object_changes_change; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def object_changes_change_to_be_saved; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def object_changes_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def object_changes_in_database; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def object_changes_previous_change; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def object_changes_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def object_changes_previously_was; end + + sig { returns(T.untyped) } + def object_changes_was; end + + sig { void } + def object_changes_will_change!; end + + sig { returns(T.untyped) } + def object_in_database; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def object_previous_change; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def object_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def object_previously_was; end + + sig { returns(T.untyped) } + def object_was; end + + sig { void } + def object_will_change!; end + + sig { void } + def restore_created_at!; end + + sig { void } + def restore_event!; end + + sig { void } + def restore_id!; end + + sig { void } + def restore_id_value!; end + + sig { void } + def restore_item_id!; end + + sig { void } + def restore_item_type!; end + + sig { void } + def restore_object!; end + + sig { void } + def restore_object_changes!; end + + sig { void } + def restore_whodunnit!; 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([::String, ::String])) } + def saved_change_to_event; end + + sig { returns(T::Boolean) } + def saved_change_to_event?; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def saved_change_to_id; end + + sig { returns(T::Boolean) } + def saved_change_to_id?; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def saved_change_to_id_value; end + + sig { returns(T::Boolean) } + def saved_change_to_id_value?; end + + sig { returns(T.nilable([::Integer, ::Integer])) } + def saved_change_to_item_id; end + + sig { returns(T::Boolean) } + def saved_change_to_item_id?; end + + sig { returns(T.nilable([::String, ::String])) } + def saved_change_to_item_type; end + + sig { returns(T::Boolean) } + def saved_change_to_item_type?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def saved_change_to_object; end + + sig { returns(T::Boolean) } + def saved_change_to_object?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def saved_change_to_object_changes; end + + sig { returns(T::Boolean) } + def saved_change_to_object_changes?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def saved_change_to_whodunnit; end + + sig { returns(T::Boolean) } + def saved_change_to_whodunnit?; end + + sig { returns(T.nilable(::String)) } + def whodunnit; end + + sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } + def whodunnit=(value); end + + sig { returns(T::Boolean) } + def whodunnit?; end + + sig { returns(T.nilable(::String)) } + def whodunnit_before_last_save; end + + sig { returns(T.untyped) } + def whodunnit_before_type_cast; end + + sig { returns(T::Boolean) } + def whodunnit_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def whodunnit_change; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def whodunnit_change_to_be_saved; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def whodunnit_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def whodunnit_in_database; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def whodunnit_previous_change; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def whodunnit_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def whodunnit_previously_was; end + + sig { returns(T.nilable(::String)) } + def whodunnit_was; end + + sig { void } + def whodunnit_will_change!; end + + sig { returns(T::Boolean) } + def will_save_change_to_created_at?; end + + sig { returns(T::Boolean) } + def will_save_change_to_event?; end + + sig { returns(T::Boolean) } + def will_save_change_to_id?; end + + sig { returns(T::Boolean) } + def will_save_change_to_id_value?; end + + sig { returns(T::Boolean) } + def will_save_change_to_item_id?; end + + sig { returns(T::Boolean) } + def will_save_change_to_item_type?; end + + sig { returns(T::Boolean) } + def will_save_change_to_object?; end + + sig { returns(T::Boolean) } + def will_save_change_to_object_changes?; end + + sig { returns(T::Boolean) } + def will_save_change_to_whodunnit?; 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 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 { 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, blk: T.untyped).returns(PrivateRelation) } + 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 { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationWhereChain) } + def where(*args, &blk); 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 without(*args, &blk); end + end + + class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation + include CommonRelationMethods + include GeneratedAssociationRelationMethods + + Elem = type_member { { fixed: ::PaperTrail::Version } } + + sig { returns(T::Array[::PaperTrail::Version]) } + def to_a; end + + sig { returns(T::Array[::PaperTrail::Version]) } + def to_ary; end + end + + class PrivateAssociationRelationGroupChain < PrivateAssociationRelation + Elem = type_member { { fixed: ::PaperTrail::Version } } + + 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 sum(column_name = nil, &block); end + end + + class PrivateAssociationRelationWhereChain < PrivateAssociationRelation + Elem = type_member { { fixed: ::PaperTrail::Version } } + + 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: ::PaperTrail::Version } } + + sig do + params( + records: T.any(::PaperTrail::Version, T::Enumerable[T.any(::PaperTrail::Version, T::Enumerable[::PaperTrail::Version])]) + ).returns(PrivateCollectionProxy) + end + def <<(*records); end + + sig do + params( + records: T.any(::PaperTrail::Version, T::Enumerable[T.any(::PaperTrail::Version, T::Enumerable[::PaperTrail::Version])]) + ).returns(PrivateCollectionProxy) + end + def append(*records); end + + sig { returns(PrivateCollectionProxy) } + def clear; end + + sig do + params( + records: T.any(::PaperTrail::Version, T::Enumerable[T.any(::PaperTrail::Version, T::Enumerable[::PaperTrail::Version])]) + ).returns(PrivateCollectionProxy) + end + def concat(*records); end + + sig do + params( + records: T.any(::PaperTrail::Version, Integer, String, T::Enumerable[T.any(::PaperTrail::Version, Integer, String, T::Enumerable[::PaperTrail::Version])]) + ).returns(T::Array[::PaperTrail::Version]) + end + def delete(*records); end + + sig do + params( + records: T.any(::PaperTrail::Version, Integer, String, T::Enumerable[T.any(::PaperTrail::Version, Integer, String, T::Enumerable[::PaperTrail::Version])]) + ).returns(T::Array[::PaperTrail::Version]) + end + def destroy(*records); end + + sig { returns(T::Array[::PaperTrail::Version]) } + def load_target; end + + sig do + params( + records: T.any(::PaperTrail::Version, T::Enumerable[T.any(::PaperTrail::Version, T::Enumerable[::PaperTrail::Version])]) + ).returns(PrivateCollectionProxy) + end + def prepend(*records); end + + sig do + params( + records: T.any(::PaperTrail::Version, T::Enumerable[T.any(::PaperTrail::Version, T::Enumerable[::PaperTrail::Version])]) + ).returns(PrivateCollectionProxy) + end + def push(*records); end + + sig do + params( + other_array: T.any(::PaperTrail::Version, T::Enumerable[T.any(::PaperTrail::Version, T::Enumerable[::PaperTrail::Version])]) + ).returns(T::Array[::PaperTrail::Version]) + end + def replace(other_array); end + + sig { returns(PrivateAssociationRelation) } + def scope; end + + sig { returns(T::Array[::PaperTrail::Version]) } + def target; end + + sig { returns(T::Array[::PaperTrail::Version]) } + def to_a; end + + sig { returns(T::Array[::PaperTrail::Version]) } + def to_ary; end + end + + class PrivateRelation < ::ActiveRecord::Relation + include CommonRelationMethods + include GeneratedRelationMethods + + Elem = type_member { { fixed: ::PaperTrail::Version } } + + sig { returns(T::Array[::PaperTrail::Version]) } + def to_a; end + + sig { returns(T::Array[::PaperTrail::Version]) } + def to_ary; end + end + + class PrivateRelationGroupChain < PrivateRelation + Elem = type_member { { fixed: ::PaperTrail::Version } } + + 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 sum(column_name = nil, &block); end + end + + class PrivateRelationWhereChain < PrivateRelation + Elem = type_member { { fixed: ::PaperTrail::Version } } + + 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