redux-scraper/sorbet/rbi/dsl/good_job/job.rbi

# typed: true

# DO NOT EDIT MANUALLY
# This is an autogenerated file for dynamic methods in `GoodJob::Job`.
# Please instead update this file by running `bin/tapioca dsl GoodJob::Job`.


class GoodJob::Job
  include GeneratedAssociationMethods
  include GeneratedAttributeMethods
  include EnumMethodsModule
  extend CommonRelationMethods
  extend GeneratedRelationMethods

  private

  sig { returns(NilClass) }
  def to_ary; end

  class << self
    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
    def error_events; end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def new(attributes = nil, &block); end
  end

  module CommonRelationMethods
    sig { params(block: T.nilable(T.proc.params(record: ::GoodJob::Job).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: ::GoodJob::Job).void)).returns(::GoodJob::Job) }
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    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: ::GoodJob::Job).void).returns(Integer) }
    def count(column_name = nil, &block); end

    sig { params(block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)).returns(::GoodJob::Job) }
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def create(attributes = nil, &block); end

    sig { params(block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)).returns(::GoodJob::Job) }
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def create!(attributes = nil, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def create_or_find_by(attributes, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def create_or_find_by!(attributes, &block); end

    sig { returns(T::Array[::GoodJob::Job]) }
    def destroy_all; end

    sig { params(conditions: T.untyped).returns(T::Boolean) }
    def exists?(conditions = :none); end

    sig { returns(T.nilable(::GoodJob::Job)) }
    def fifth; end

    sig { returns(::GoodJob::Job) }
    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(::GoodJob::Job)
    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[::GoodJob::Job])
    end
    sig do
      params(
        args: NilClass,
        block: T.proc.params(object: ::GoodJob::Job).void
      ).returns(T.nilable(::GoodJob::Job))
    end
    def find(args = nil, &block); end

    sig { params(args: T.untyped).returns(T.nilable(::GoodJob::Job)) }
    def find_by(*args); end

    sig { params(args: T.untyped).returns(::GoodJob::Job) }
    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: ::GoodJob::Job).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[::GoodJob::Job])
    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[::GoodJob::Job]).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[::GoodJob::Job]])
    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: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def find_or_create_by(attributes, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def find_or_create_by!(attributes, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def find_or_initialize_by(attributes, &block); end

    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::GoodJob::Job)) }
    def find_signed(signed_id, purpose: nil); end

    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::GoodJob::Job) }
    def find_signed!(signed_id, purpose: nil); end

    sig { params(arg: T.untyped, args: T.untyped).returns(::GoodJob::Job) }
    def find_sole_by(arg, *args); end

    sig { returns(T.nilable(::GoodJob::Job)) }
    sig { params(limit: Integer).returns(T::Array[::GoodJob::Job]) }
    def first(limit = nil); end

    sig { returns(::GoodJob::Job) }
    def first!; end

    sig { returns(T.nilable(::GoodJob::Job)) }
    def forty_two; end

    sig { returns(::GoodJob::Job) }
    def forty_two!; end

    sig { returns(T.nilable(::GoodJob::Job)) }
    def fourth; end

    sig { returns(::GoodJob::Job) }
    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(::GoodJob::Job)) }
    sig { params(limit: Integer).returns(T::Array[::GoodJob::Job]) }
    def last(limit = nil); end

    sig { returns(::GoodJob::Job) }
    def last!; end

    sig { params(block: T.nilable(T.proc.params(record: ::GoodJob::Job).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: ::GoodJob::Job).void)).returns(::GoodJob::Job) }
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(T::Array[::GoodJob::Job])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::GoodJob::Job).void)
      ).returns(::GoodJob::Job)
    end
    def new(attributes = nil, &block); end

    sig { params(block: T.nilable(T.proc.params(record: ::GoodJob::Job).returns(T.untyped))).returns(T::Boolean) }
    def none?(&block); end

    sig { params(block: T.nilable(T.proc.params(record: ::GoodJob::Job).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(::GoodJob::Job)) }
    def second; end

    sig { returns(::GoodJob::Job) }
    def second!; end

    sig { returns(T.nilable(::GoodJob::Job)) }
    def second_to_last; end

    sig { returns(::GoodJob::Job) }
    def second_to_last!; end

    sig { returns(::GoodJob::Job) }
    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: ::GoodJob::Job).returns(T.type_parameter(:U))
        ).returns(T.type_parameter(:U))
    end
    def sum(initial_value_or_column = nil, &block); end

    sig { returns(T.nilable(::GoodJob::Job)) }
    sig { params(limit: Integer).returns(T::Array[::GoodJob::Job]) }
    def take(limit = nil); end

    sig { returns(::GoodJob::Job) }
    def take!; end

    sig { returns(T.nilable(::GoodJob::Job)) }
    def third; end

    sig { returns(::GoodJob::Job) }
    def third!; end

    sig { returns(T.nilable(::GoodJob::Job)) }
    def third_to_last; end

    sig { returns(::GoodJob::Job) }
    def third_to_last!; end
  end

  module EnumMethodsModule
    sig { void }
    def discarded!; end

    sig { returns(T::Boolean) }
    def discarded?; end

    sig { void }
    def handled!; end

    sig { returns(T::Boolean) }
    def handled?; end

    sig { void }
    def interrupted!; end

    sig { returns(T::Boolean) }
    def interrupted?; end

    sig { void }
    def retried!; end

    sig { returns(T::Boolean) }
    def retried?; end

    sig { void }
    def retry_stopped!; end

    sig { returns(T::Boolean) }
    def retry_stopped?; end

    sig { void }
    def unhandled!; end

    sig { returns(T::Boolean) }
    def unhandled?; end
  end

  module GeneratedAssociationMethods
    sig { returns(T.nilable(::GoodJob::BatchRecord)) }
    def batch; end

    sig { params(value: T.nilable(::GoodJob::BatchRecord)).void }
    def batch=(value); end

    sig { returns(T::Boolean) }
    def batch_changed?; end

    sig { returns(T::Boolean) }
    def batch_previously_changed?; end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) }
    def build_batch(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) }
    def build_callback_batch(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::Process) }
    def build_locked_by_process(*args, &blk); end

    sig { returns(T.nilable(::GoodJob::BatchRecord)) }
    def callback_batch; end

    sig { params(value: T.nilable(::GoodJob::BatchRecord)).void }
    def callback_batch=(value); end

    sig { returns(T::Boolean) }
    def callback_batch_changed?; end

    sig { returns(T::Boolean) }
    def callback_batch_previously_changed?; end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) }
    def create_batch(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) }
    def create_batch!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) }
    def create_callback_batch(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) }
    def create_callback_batch!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::Process) }
    def create_locked_by_process(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::Process) }
    def create_locked_by_process!(*args, &blk); end

    sig { returns(T::Array[T.untyped]) }
    def execution_ids; end

    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
    def execution_ids=(ids); end

    # This method is created by ActiveRecord on the `GoodJob::Job` class because it declared `has_many :executions`.
    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
    sig { returns(::GoodJob::Execution::PrivateCollectionProxy) }
    def executions; end

    sig { params(value: T::Enumerable[::GoodJob::Execution]).void }
    def executions=(value); end

    sig { returns(T.nilable(::GoodJob::Process)) }
    def locked_by_process; end

    sig { params(value: T.nilable(::GoodJob::Process)).void }
    def locked_by_process=(value); end

    sig { returns(T::Boolean) }
    def locked_by_process_changed?; end

    sig { returns(T::Boolean) }
    def locked_by_process_previously_changed?; end

    sig { returns(T.nilable(::GoodJob::BatchRecord)) }
    def reload_batch; end

    sig { returns(T.nilable(::GoodJob::BatchRecord)) }
    def reload_callback_batch; end

    sig { returns(T.nilable(::GoodJob::Process)) }
    def reload_locked_by_process; end

    sig { void }
    def reset_batch; end

    sig { void }
    def reset_callback_batch; end

    sig { void }
    def reset_locked_by_process; end
  end

  module GeneratedAssociationRelationMethods
    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def active_job_id(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def advisory_lock(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def advisory_locked(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def advisory_unlocked(*args, &blk); end

    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(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def creation_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def dequeueing_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def discarded(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def display_all(*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 finished(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def finished_before(*args, &blk); 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 includes_advisory_locks(*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 job_class(*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 joins_advisory_locks(*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 only_scheduled(*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 owns_advisory_locked(*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 priority_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def queue_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def queue_string(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def queued(*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 retried(*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 running(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def schedule_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def scheduled(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def search_text(*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 succeeded(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def unfinished(*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 active_job_id; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def active_job_id=(value); end

    sig { returns(T::Boolean) }
    def active_job_id?; end

    sig { returns(T.nilable(::String)) }
    def active_job_id_before_last_save; end

    sig { returns(T.untyped) }
    def active_job_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def active_job_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def active_job_id_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def active_job_id_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def active_job_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def active_job_id_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def active_job_id_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def active_job_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def active_job_id_previously_was; end

    sig { returns(T.nilable(::String)) }
    def active_job_id_was; end

    sig { void }
    def active_job_id_will_change!; end

    sig { returns(T.nilable(::String)) }
    def batch_callback_id; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def batch_callback_id=(value); end

    sig { returns(T::Boolean) }
    def batch_callback_id?; end

    sig { returns(T.nilable(::String)) }
    def batch_callback_id_before_last_save; end

    sig { returns(T.untyped) }
    def batch_callback_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def batch_callback_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def batch_callback_id_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def batch_callback_id_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def batch_callback_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def batch_callback_id_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def batch_callback_id_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def batch_callback_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def batch_callback_id_previously_was; end

    sig { returns(T.nilable(::String)) }
    def batch_callback_id_was; end

    sig { void }
    def batch_callback_id_will_change!; end

    sig { returns(T.nilable(::String)) }
    def batch_id; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def batch_id=(value); end

    sig { returns(T::Boolean) }
    def batch_id?; end

    sig { returns(T.nilable(::String)) }
    def batch_id_before_last_save; end

    sig { returns(T.untyped) }
    def batch_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def batch_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def batch_id_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def batch_id_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def batch_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def batch_id_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def batch_id_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def batch_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def batch_id_previously_was; end

    sig { returns(T.nilable(::String)) }
    def batch_id_was; end

    sig { void }
    def batch_id_will_change!; end

    sig { returns(T.nilable(::String)) }
    def concurrency_key; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def concurrency_key=(value); end

    sig { returns(T::Boolean) }
    def concurrency_key?; end

    sig { returns(T.nilable(::String)) }
    def concurrency_key_before_last_save; end

    sig { returns(T.untyped) }
    def concurrency_key_before_type_cast; end

    sig { returns(T::Boolean) }
    def concurrency_key_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def concurrency_key_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def concurrency_key_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def concurrency_key_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def concurrency_key_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def concurrency_key_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def concurrency_key_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def concurrency_key_previously_was; end

    sig { returns(T.nilable(::String)) }
    def concurrency_key_was; end

    sig { void }
    def concurrency_key_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(::ActiveSupport::TimeWithZone)) }
    def cron_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def cron_at=(value); end

    sig { returns(T::Boolean) }
    def cron_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def cron_at_before_last_save; end

    sig { returns(T.untyped) }
    def cron_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def cron_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def cron_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def cron_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def cron_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def cron_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def cron_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def cron_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def cron_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def cron_at_was; end

    sig { void }
    def cron_at_will_change!; end

    sig { returns(T.nilable(::String)) }
    def cron_key; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def cron_key=(value); end

    sig { returns(T::Boolean) }
    def cron_key?; end

    sig { returns(T.nilable(::String)) }
    def cron_key_before_last_save; end

    sig { returns(T.untyped) }
    def cron_key_before_type_cast; end

    sig { returns(T::Boolean) }
    def cron_key_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def cron_key_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def cron_key_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def cron_key_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def cron_key_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def cron_key_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def cron_key_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def cron_key_previously_was; end

    sig { returns(T.nilable(::String)) }
    def cron_key_was; end

    sig { void }
    def cron_key_will_change!; end

    sig { returns(T.nilable(::String)) }
    def error; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def error=(value); end

    sig { returns(T::Boolean) }
    def error?; end

    sig { returns(T.nilable(::String)) }
    def error_before_last_save; end

    sig { returns(T.untyped) }
    def error_before_type_cast; end

    sig { returns(T::Boolean) }
    def error_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def error_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def error_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def error_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def error_event; end

    sig do
      params(
        value: T.nilable(T.any(::String, ::Symbol, ::Integer))
      ).returns(T.nilable(T.any(::String, ::Symbol, ::Integer)))
    end
    def error_event=(value); end

    sig { returns(T::Boolean) }
    def error_event?; end

    sig { returns(T.nilable(::String)) }
    def error_event_before_last_save; end

    sig { returns(T.untyped) }
    def error_event_before_type_cast; end

    sig { returns(T::Boolean) }
    def error_event_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def error_event_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def error_event_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(T.any(::String, ::Symbol, ::Integer)),
        to: T.nilable(T.any(::String, ::Symbol, ::Integer))
      ).returns(T::Boolean)
    end
    def error_event_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def error_event_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def error_event_previous_change; end

    sig do
      params(
        from: T.nilable(T.any(::String, ::Symbol, ::Integer)),
        to: T.nilable(T.any(::String, ::Symbol, ::Integer))
      ).returns(T::Boolean)
    end
    def error_event_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def error_event_previously_was; end

    sig { returns(T.nilable(::String)) }
    def error_event_was; end

    sig { void }
    def error_event_will_change!; end

    sig { returns(T.nilable(::String)) }
    def error_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def error_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def error_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def error_previously_was; end

    sig { returns(T.nilable(::String)) }
    def error_was; end

    sig { void }
    def error_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def executions_count; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def executions_count=(value); end

    sig { returns(T::Boolean) }
    def executions_count?; end

    sig { returns(T.nilable(::Integer)) }
    def executions_count_before_last_save; end

    sig { returns(T.untyped) }
    def executions_count_before_type_cast; end

    sig { returns(T::Boolean) }
    def executions_count_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def executions_count_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def executions_count_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def executions_count_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def executions_count_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def executions_count_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def executions_count_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def executions_count_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def executions_count_was; end

    sig { void }
    def executions_count_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def finished_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def finished_at=(value); end

    sig { returns(T::Boolean) }
    def finished_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def finished_at_before_last_save; end

    sig { returns(T.untyped) }
    def finished_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def finished_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def finished_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def finished_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def finished_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def finished_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def finished_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def finished_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def finished_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def finished_at_was; end

    sig { void }
    def finished_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_value; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def id_value=(value); end

    sig { returns(T::Boolean) }
    def id_value?; end

    sig { returns(T.nilable(::String)) }
    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([T.nilable(::String), T.nilable(::String)])) }
    def id_value_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def id_value_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def id_value_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def id_value_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def id_value_previously_was; end

    sig { returns(T.nilable(::String)) }
    def id_value_was; end

    sig { void }
    def id_value_will_change!; end

    sig { returns(T.nilable(::String)) }
    def id_was; end

    sig { void }
    def id_will_change!; end

    sig { returns(T.nilable(::String)) }
    def job_class; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def job_class=(value); end

    sig { returns(T::Boolean) }
    def job_class?; end

    sig { returns(T.nilable(::String)) }
    def job_class_before_last_save; end

    sig { returns(T.untyped) }
    def job_class_before_type_cast; end

    sig { returns(T::Boolean) }
    def job_class_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def job_class_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def job_class_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def job_class_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def job_class_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def job_class_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def job_class_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def job_class_previously_was; end

    sig { returns(T.nilable(::String)) }
    def job_class_was; end

    sig { void }
    def job_class_will_change!; end

    sig { returns(T.nilable(T::Array[::String])) }
    def labels; end

    sig { params(value: T.nilable(T::Array[::String])).returns(T.nilable(T::Array[::String])) }
    def labels=(value); end

    sig { returns(T::Boolean) }
    def labels?; end

    sig { returns(T.nilable(T::Array[::String])) }
    def labels_before_last_save; end

    sig { returns(T.untyped) }
    def labels_before_type_cast; end

    sig { returns(T::Boolean) }
    def labels_came_from_user?; end

    sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) }
    def labels_change; end

    sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) }
    def labels_change_to_be_saved; end

    sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) }
    def labels_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(T::Array[::String])) }
    def labels_in_database; end

    sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) }
    def labels_previous_change; end

    sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) }
    def labels_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(T::Array[::String])) }
    def labels_previously_was; end

    sig { returns(T.nilable(T::Array[::String])) }
    def labels_was; end

    sig { void }
    def labels_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def locked_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def locked_at=(value); end

    sig { returns(T::Boolean) }
    def locked_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def locked_at_before_last_save; end

    sig { returns(T.untyped) }
    def locked_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def locked_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def locked_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def locked_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def locked_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def locked_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def locked_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def locked_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def locked_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def locked_at_was; end

    sig { void }
    def locked_at_will_change!; end

    sig { returns(T.nilable(::String)) }
    def locked_by_id; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def locked_by_id=(value); end

    sig { returns(T::Boolean) }
    def locked_by_id?; end

    sig { returns(T.nilable(::String)) }
    def locked_by_id_before_last_save; end

    sig { returns(T.untyped) }
    def locked_by_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def locked_by_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def locked_by_id_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def locked_by_id_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def locked_by_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def locked_by_id_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def locked_by_id_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def locked_by_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def locked_by_id_previously_was; end

    sig { returns(T.nilable(::String)) }
    def locked_by_id_was; end

    sig { void }
    def locked_by_id_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def performed_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def performed_at=(value); end

    sig { returns(T::Boolean) }
    def performed_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def performed_at_before_last_save; end

    sig { returns(T.untyped) }
    def performed_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def performed_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def performed_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def performed_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def performed_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def performed_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def performed_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def performed_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def performed_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def performed_at_was; end

    sig { void }
    def performed_at_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def priority; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def priority=(value); end

    sig { returns(T::Boolean) }
    def priority?; end

    sig { returns(T.nilable(::Integer)) }
    def priority_before_last_save; end

    sig { returns(T.untyped) }
    def priority_before_type_cast; end

    sig { returns(T::Boolean) }
    def priority_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def priority_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def priority_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def priority_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def priority_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def priority_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def priority_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def priority_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def priority_was; end

    sig { void }
    def priority_will_change!; end

    sig { returns(T.nilable(::String)) }
    def queue_name; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def queue_name=(value); end

    sig { returns(T::Boolean) }
    def queue_name?; end

    sig { returns(T.nilable(::String)) }
    def queue_name_before_last_save; end

    sig { returns(T.untyped) }
    def queue_name_before_type_cast; end

    sig { returns(T::Boolean) }
    def queue_name_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def queue_name_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def queue_name_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def queue_name_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def queue_name_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def queue_name_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def queue_name_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def queue_name_previously_was; end

    sig { returns(T.nilable(::String)) }
    def queue_name_was; end

    sig { void }
    def queue_name_will_change!; end

    sig { void }
    def restore_active_job_id!; end

    sig { void }
    def restore_batch_callback_id!; end

    sig { void }
    def restore_batch_id!; end

    sig { void }
    def restore_concurrency_key!; end

    sig { void }
    def restore_created_at!; end

    sig { void }
    def restore_cron_at!; end

    sig { void }
    def restore_cron_key!; end

    sig { void }
    def restore_error!; end

    sig { void }
    def restore_error_event!; end

    sig { void }
    def restore_executions_count!; end

    sig { void }
    def restore_finished_at!; end

    sig { void }
    def restore_id!; end

    sig { void }
    def restore_id_value!; end

    sig { void }
    def restore_job_class!; end

    sig { void }
    def restore_labels!; end

    sig { void }
    def restore_locked_at!; end

    sig { void }
    def restore_locked_by_id!; end

    sig { void }
    def restore_performed_at!; end

    sig { void }
    def restore_priority!; end

    sig { void }
    def restore_queue_name!; end

    sig { void }
    def restore_scheduled_at!; end

    sig { void }
    def restore_serialized_params!; end

    sig { void }
    def restore_updated_at!; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_active_job_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_active_job_id?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_batch_callback_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_batch_callback_id?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_batch_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_batch_id?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_concurrency_key; end

    sig { returns(T::Boolean) }
    def saved_change_to_concurrency_key?; 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(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_cron_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_cron_at?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_cron_key; end

    sig { returns(T::Boolean) }
    def saved_change_to_cron_key?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_error; end

    sig { returns(T::Boolean) }
    def saved_change_to_error?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_error_event; end

    sig { returns(T::Boolean) }
    def saved_change_to_error_event?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_executions_count; end

    sig { returns(T::Boolean) }
    def saved_change_to_executions_count?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_finished_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_finished_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_id_value; end

    sig { returns(T::Boolean) }
    def saved_change_to_id_value?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_job_class; end

    sig { returns(T::Boolean) }
    def saved_change_to_job_class?; end

    sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) }
    def saved_change_to_labels; end

    sig { returns(T::Boolean) }
    def saved_change_to_labels?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_locked_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_locked_at?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_locked_by_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_locked_by_id?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_performed_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_performed_at?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_priority; end

    sig { returns(T::Boolean) }
    def saved_change_to_priority?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_queue_name; end

    sig { returns(T::Boolean) }
    def saved_change_to_queue_name?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_scheduled_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_scheduled_at?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def saved_change_to_serialized_params; end

    sig { returns(T::Boolean) }
    def saved_change_to_serialized_params?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_updated_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_updated_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def scheduled_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def scheduled_at=(value); end

    sig { returns(T::Boolean) }
    def scheduled_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def scheduled_at_before_last_save; end

    sig { returns(T.untyped) }
    def scheduled_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def scheduled_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def scheduled_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def scheduled_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def scheduled_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def scheduled_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def scheduled_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def scheduled_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def scheduled_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def scheduled_at_was; end

    sig { void }
    def scheduled_at_will_change!; end

    sig { returns(T.untyped) }
    def serialized_params; end

    sig { params(value: T.untyped).returns(T.untyped) }
    def serialized_params=(value); end

    sig { returns(T::Boolean) }
    def serialized_params?; end

    sig { returns(T.untyped) }
    def serialized_params_before_last_save; end

    sig { returns(T.untyped) }
    def serialized_params_before_type_cast; end

    sig { returns(T::Boolean) }
    def serialized_params_came_from_user?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def serialized_params_change; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def serialized_params_change_to_be_saved; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def serialized_params_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def serialized_params_in_database; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def serialized_params_previous_change; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def serialized_params_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def serialized_params_previously_was; end

    sig { returns(T.untyped) }
    def serialized_params_was; end

    sig { void }
    def serialized_params_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at=(value); end

    sig { returns(T::Boolean) }
    def updated_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_before_last_save; end

    sig { returns(T.untyped) }
    def updated_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def updated_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def updated_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def updated_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def updated_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def updated_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def updated_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_was; end

    sig { void }
    def updated_at_will_change!; end

    sig { returns(T::Boolean) }
    def will_save_change_to_active_job_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_batch_callback_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_batch_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_concurrency_key?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_created_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_cron_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_cron_key?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_error?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_error_event?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_executions_count?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_finished_at?; 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_job_class?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_labels?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_locked_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_locked_by_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_performed_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_priority?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_queue_name?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_scheduled_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_serialized_params?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_updated_at?; end
  end

  module GeneratedRelationMethods
    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def active_job_id(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def advisory_lock(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def advisory_locked(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def advisory_unlocked(*args, &blk); end

    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(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def creation_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def dequeueing_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def discarded(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def display_all(*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 finished(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def finished_before(*args, &blk); 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 includes_advisory_locks(*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 job_class(*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 joins_advisory_locks(*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 only_scheduled(*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 owns_advisory_locked(*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 priority_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def queue_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def queue_string(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def queued(*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 retried(*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 running(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def schedule_ordered(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def scheduled(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def search_text(*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 succeeded(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def unfinished(*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: ::GoodJob::Job } }

    sig { returns(T::Array[::GoodJob::Job]) }
    def to_a; end

    sig { returns(T::Array[::GoodJob::Job]) }
    def to_ary; end
  end

  class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
    Elem = type_member { { fixed: ::GoodJob::Job } }

    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
    Elem = type_member { { fixed: ::GoodJob::Job } }

    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: ::GoodJob::Job } }

    sig do
      params(
        records: T.any(::GoodJob::Job, T::Enumerable[T.any(::GoodJob::Job, T::Enumerable[::GoodJob::Job])])
      ).returns(PrivateCollectionProxy)
    end
    def <<(*records); end

    sig do
      params(
        records: T.any(::GoodJob::Job, T::Enumerable[T.any(::GoodJob::Job, T::Enumerable[::GoodJob::Job])])
      ).returns(PrivateCollectionProxy)
    end
    def append(*records); end

    sig { returns(PrivateCollectionProxy) }
    def clear; end

    sig do
      params(
        records: T.any(::GoodJob::Job, T::Enumerable[T.any(::GoodJob::Job, T::Enumerable[::GoodJob::Job])])
      ).returns(PrivateCollectionProxy)
    end
    def concat(*records); end

    sig { returns(T::Array[::GoodJob::Job]) }
    def load_target; end

    sig do
      params(
        records: T.any(::GoodJob::Job, T::Enumerable[T.any(::GoodJob::Job, T::Enumerable[::GoodJob::Job])])
      ).returns(PrivateCollectionProxy)
    end
    def prepend(*records); end

    sig do
      params(
        records: T.any(::GoodJob::Job, T::Enumerable[T.any(::GoodJob::Job, T::Enumerable[::GoodJob::Job])])
      ).returns(PrivateCollectionProxy)
    end
    def push(*records); end

    sig do
      params(
        other_array: T.any(::GoodJob::Job, T::Enumerable[T.any(::GoodJob::Job, T::Enumerable[::GoodJob::Job])])
      ).returns(T::Array[::GoodJob::Job])
    end
    def replace(other_array); end

    sig { returns(PrivateAssociationRelation) }
    def scope; end

    sig { returns(T::Array[::GoodJob::Job]) }
    def target; end

    sig { returns(T::Array[::GoodJob::Job]) }
    def to_a; end

    sig { returns(T::Array[::GoodJob::Job]) }
    def to_ary; end
  end

  class PrivateRelation < ::ActiveRecord::Relation
    include CommonRelationMethods
    include GeneratedRelationMethods

    Elem = type_member { { fixed: ::GoodJob::Job } }

    sig { returns(T::Array[::GoodJob::Job]) }
    def to_a; end

    sig { returns(T::Array[::GoodJob::Job]) }
    def to_ary; end
  end

  class PrivateRelationGroupChain < PrivateRelation
    Elem = type_member { { fixed: ::GoodJob::Job } }

    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
    Elem = type_member { { fixed: ::GoodJob::Job } }

    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