# typed: true

# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `diff-lcs` gem.
# Please instead update this file by running `bin/tapioca gem diff-lcs`.

module Diff; end

module Diff::LCS
  # Returns the difference set between +self+ and +other+. See Diff::LCS#diff.
  def diff(other, callbacks = T.unsafe(nil), &block); end

  # Returns an Array containing the longest common subsequence(s) between
  # +self+ and +other+. See Diff::LCS#lcs.
  #
  #   lcs = seq1.lcs(seq2)
  #
  # A note when using objects: Diff::LCS only works properly when each object
  # can be used as a key in a Hash, which typically means that the objects must
  # implement Object#eql? in a way that two identical values compare
  # identically for key purposes. That is:
  #
  #   O.new('a').eql?(O.new('a')) == true
  def lcs(other, &block); end

  # Attempts to patch +self+ with the provided +patchset+. A new sequence based
  # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts
  # to autodiscover the direction of the patch.
  def patch(patchset); end

  # Attempts to patch +self+ with the provided +patchset+. A new sequence based
  # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Does no
  # patch direction autodiscovery.
  def patch!(patchset); end

  # Attempts to patch +self+ with the provided +patchset+, using #patch!. If
  # the sequence this is used on supports #replace, the value of +self+ will be
  # replaced. See Diff::LCS#patch. Does no patch direction autodiscovery.
  def patch_me(patchset); end

  # Returns the balanced ("side-by-side") difference set between +self+ and
  # +other+. See Diff::LCS#sdiff.
  def sdiff(other, callbacks = T.unsafe(nil), &block); end

  # Traverses the discovered longest common subsequences between +self+ and
  # +other+ using the alternate, balanced algorithm. See
  # Diff::LCS#traverse_balanced.
  def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end

  # Traverses the discovered longest common subsequences between +self+ and
  # +other+. See Diff::LCS#traverse_sequences.
  def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end

  # Attempts to patch +self+ with the provided +patchset+. A new sequence based
  # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts
  # to autodiscover the direction of the patch.
  def unpatch(patchset); end

  # Attempts to unpatch +self+ with the provided +patchset+. A new sequence
  # based on +self+ and the +patchset+ will be created. See Diff::LCS#unpatch.
  # Does no patch direction autodiscovery.
  def unpatch!(patchset); end

  # Attempts to unpatch +self+ with the provided +patchset+, using #unpatch!.
  # If the sequence this is used on supports #replace, the value of +self+ will
  # be replaced. See Diff::LCS#unpatch. Does no patch direction autodiscovery.
  def unpatch_me(patchset); end

  class << self
    # :yields seq1[i] for each matched:
    def LCS(seq1, seq2, &block); end

    def callbacks_for(callbacks); end

    # #diff computes the smallest set of additions and deletions necessary to
    # turn the first sequence into the second, and returns a description of these
    # changes.
    #
    # See Diff::LCS::DiffCallbacks for the default behaviour. An alternate
    # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a
    # Class argument is provided for +callbacks+, #diff will attempt to
    # initialise it. If the +callbacks+ object (possibly initialised) responds to
    # #finish, it will be called.
    def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end

    # :yields seq1[i] for each matched:
    def lcs(seq1, seq2, &block); end

    # Applies a +patchset+ to the sequence +src+ according to the +direction+
    # (<tt>:patch</tt> or <tt>:unpatch</tt>), producing a new sequence.
    #
    # If the +direction+ is not specified, Diff::LCS::patch will attempt to
    # discover the direction of the +patchset+.
    #
    # A +patchset+ can be considered to apply forward (<tt>:patch</tt>) if the
    # following expression is true:
    #
    #     patch(s1, diff(s1, s2)) -> s2
    #
    # A +patchset+ can be considered to apply backward (<tt>:unpatch</tt>) if the
    # following expression is true:
    #
    #     patch(s2, diff(s1, s2)) -> s1
    #
    # If the +patchset+ contains no changes, the +src+ value will be returned as
    # either <tt>src.dup</tt> or +src+. A +patchset+ can be deemed as having no
    # changes if the following predicate returns true:
    #
    #     patchset.empty? or
    #       patchset.flatten(1).all? { |change| change.unchanged? }
    #
    # === Patchsets
    #
    # A +patchset+ is always an enumerable sequence of changes, hunks of changes,
    # or a mix of the two. A hunk of changes is an enumerable sequence of
    # changes:
    #
    #     [ # patchset
    #       # change
    #       [ # hunk
    #         # change
    #       ]
    #     ]
    #
    # The +patch+ method accepts <tt>patchset</tt>s that are enumerable sequences
    # containing either Diff::LCS::Change objects (or a subclass) or the array
    # representations of those objects. Prior to application, array
    # representations of Diff::LCS::Change objects will be reified.
    def patch(src, patchset, direction = T.unsafe(nil)); end

    # Given a set of patchset, convert the current version to the next version.
    # Does no auto-discovery.
    def patch!(src, patchset); end

    # #sdiff computes all necessary components to show two sequences and their
    # minimized differences side by side, just like the Unix utility
    # <em>sdiff</em> does:
    #
    #     old        <     -
    #     same             same
    #     before     |     after
    #     -          >     new
    #
    # See Diff::LCS::SDiffCallbacks for the default behaviour. An alternate
    # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a
    # Class argument is provided for +callbacks+, #diff will attempt to
    # initialise it. If the +callbacks+ object (possibly initialised) responds to
    # #finish, it will be called.
    #
    # Each element of a returned array is a Diff::LCS::ContextChange object,
    # which can be implicitly converted to an array.
    #
    #   Diff::LCS.sdiff(a, b).each do |action, (old_pos, old_element), (new_pos, new_element)|
    #     case action
    #     when '!'
    #       # replace
    #     when '-'
    #       # delete
    #     when '+'
    #       # insert
    #     end
    #   end
    def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end

    # #traverse_balanced is an alternative to #traverse_sequences. It uses a
    # different algorithm to iterate through the entries in the computed longest
    # common subsequence. Instead of viewing the changes as insertions or
    # deletions from one of the sequences, #traverse_balanced will report
    # <em>changes</em> between the sequences.
    #
    # The arguments to #traverse_balanced are the two sequences to traverse and a
    # callback object, like this:
    #
    #   traverse_balanced(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new)
    #
    # #sdiff is implemented with #traverse_balanced.
    #
    # == Callback Methods
    #
    # Optional callback methods are <em>emphasized</em>.
    #
    # callbacks#match::               Called when +a+ and +b+ are pointing to
    #                                 common elements in +A+ and +B+.
    # callbacks#discard_a::           Called when +a+ is pointing to an
    #                                 element not in +B+.
    # callbacks#discard_b::           Called when +b+ is pointing to an
    #                                 element not in +A+.
    # <em>callbacks#change</em>::     Called when +a+ and +b+ are pointing to
    #                                 the same relative position, but
    #                                 <tt>A[a]</tt> and <tt>B[b]</tt> are not
    #                                 the same; a <em>change</em> has
    #                                 occurred.
    #
    # #traverse_balanced might be a bit slower than #traverse_sequences,
    # noticable only while processing huge amounts of data.
    #
    # == Algorithm
    #
    #       a---+
    #           v
    #       A = a b c e h j l m n p
    #       B = b c d e f j k l m r s t
    #           ^
    #       b---+
    #
    # === Matches
    #
    # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+
    # and +B+, the arrows will initially point to the first elements of their
    # respective sequences. #traverse_sequences will advance the arrows through
    # the sequences one element at a time, calling a method on the user-specified
    # callback object before each advance. It will advance the arrows in such a
    # way that if there are elements <tt>A[i]</tt> and <tt>B[j]</tt> which are
    # both equal and part of the longest common subsequence, there will be some
    # moment during the execution of #traverse_sequences when arrow +a+ is
    # pointing to <tt>A[i]</tt> and arrow +b+ is pointing to <tt>B[j]</tt>. When
    # this happens, #traverse_sequences will call <tt>callbacks#match</tt> and
    # then it will advance both arrows.
    #
    # === Discards
    #
    # Otherwise, one of the arrows is pointing to an element of its sequence that
    # is not part of the longest common subsequence. #traverse_sequences will
    # advance that arrow and will call <tt>callbacks#discard_a</tt> or
    # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced.
    #
    # === Changes
    #
    # If both +a+ and +b+ point to elements that are not part of the longest
    # common subsequence, then #traverse_sequences will try to call
    # <tt>callbacks#change</tt> and advance both arrows. If
    # <tt>callbacks#change</tt> is not implemented, then
    # <tt>callbacks#discard_a</tt> and <tt>callbacks#discard_b</tt> will be
    # called in turn.
    #
    # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>,
    # <tt>callbacks#discard_b</tt>, and <tt>callbacks#change</tt> are invoked
    # with an event comprising the action ("=", "+", "-", or "!", respectively),
    # the indicies +i+ and +j+, and the elements <tt>A[i]</tt> and <tt>B[j]</tt>.
    # Return values are discarded by #traverse_balanced.
    #
    # === Context
    #
    # Note that +i+ and +j+ may not be the same index position, even if +a+ and
    # +b+ are considered to be pointing to matching or changed elements.
    def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end

    # #traverse_sequences is the most general facility provided by this module;
    # #diff and #lcs are implemented as calls to it.
    #
    # The arguments to #traverse_sequences are the two sequences to traverse, and
    # a callback object, like this:
    #
    #   traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new)
    #
    # == Callback Methods
    #
    # Optional callback methods are <em>emphasized</em>.
    #
    # callbacks#match::               Called when +a+ and +b+ are pointing to
    #                                 common elements in +A+ and +B+.
    # callbacks#discard_a::           Called when +a+ is pointing to an
    #                                 element not in +B+.
    # callbacks#discard_b::           Called when +b+ is pointing to an
    #                                 element not in +A+.
    # <em>callbacks#finished_a</em>:: Called when +a+ has reached the end of
    #                                 sequence +A+.
    # <em>callbacks#finished_b</em>:: Called when +b+ has reached the end of
    #                                 sequence +B+.
    #
    # == Algorithm
    #
    #       a---+
    #           v
    #       A = a b c e h j l m n p
    #       B = b c d e f j k l m r s t
    #           ^
    #       b---+
    #
    # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+
    # and +B+, the arrows will initially point to the first elements of their
    # respective sequences. #traverse_sequences will advance the arrows through
    # the sequences one element at a time, calling a method on the user-specified
    # callback object before each advance. It will advance the arrows in such a
    # way that if there are elements <tt>A[i]</tt> and <tt>B[j]</tt> which are
    # both equal and part of the longest common subsequence, there will be some
    # moment during the execution of #traverse_sequences when arrow +a+ is
    # pointing to <tt>A[i]</tt> and arrow +b+ is pointing to <tt>B[j]</tt>. When
    # this happens, #traverse_sequences will call <tt>callbacks#match</tt> and
    # then it will advance both arrows.
    #
    # Otherwise, one of the arrows is pointing to an element of its sequence that
    # is not part of the longest common subsequence. #traverse_sequences will
    # advance that arrow and will call <tt>callbacks#discard_a</tt> or
    # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced. If both
    # arrows point to elements that are not part of the longest common
    # subsequence, then #traverse_sequences will advance arrow +a+ and call the
    # appropriate callback, then it will advance arrow +b+ and call the appropriate
    # callback.
    #
    # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>, and
    # <tt>callbacks#discard_b</tt> are invoked with an event comprising the
    # action ("=", "+", or "-", respectively), the indicies +i+ and +j+, and the
    # elements <tt>A[i]</tt> and <tt>B[j]</tt>. Return values are discarded by
    # #traverse_sequences.
    #
    # === End of Sequences
    #
    # If arrow +a+ reaches the end of its sequence before arrow +b+ does,
    # #traverse_sequence will try to call <tt>callbacks#finished_a</tt> with the
    # last index and element of +A+ (<tt>A[-1]</tt>) and the current index and
    # element of +B+ (<tt>B[j]</tt>). If <tt>callbacks#finished_a</tt> does not
    # exist, then <tt>callbacks#discard_b</tt> will be called on each element of
    # +B+ until the end of the sequence is reached (the call will be done with
    # <tt>A[-1]</tt> and <tt>B[j]</tt> for each element).
    #
    # If +b+ reaches the end of +B+ before +a+ reaches the end of +A+,
    # <tt>callbacks#finished_b</tt> will be called with the current index and
    # element of +A+ (<tt>A[i]</tt>) and the last index and element of +B+
    # (<tt>A[-1]</tt>). Again, if <tt>callbacks#finished_b</tt> does not exist on
    # the callback object, then <tt>callbacks#discard_a</tt> will be called on
    # each element of +A+ until the end of the sequence is reached (<tt>A[i]</tt>
    # and <tt>B[-1]</tt>).
    #
    # There is a chance that one additional <tt>callbacks#discard_a</tt> or
    # <tt>callbacks#discard_b</tt> will be called after the end of the sequence
    # is reached, if +a+ has not yet reached the end of +A+ or +b+ has not yet
    # reached the end of +B+.
    def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end

    # Given a set of patchset, convert the current version to the prior version.
    # Does no auto-discovery.
    def unpatch!(src, patchset); end

    private

    def diff_traversal(method, seq1, seq2, callbacks, &block); end
  end
end

# An alias for DefaultCallbacks that is used in
# Diff::LCS#traverse_balanced.
#
#     Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks)
Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks

# A block is an operation removing, adding, or changing a group of items.
# Basically, this is just a list of changes, where each change adds or
# deletes a single item. Used by bin/ldiff.
class Diff::LCS::Block
  # @return [Block] a new instance of Block
  def initialize(chunk); end

  # Returns the value of attribute changes.
  def changes; end

  def diff_size; end

  # Returns the value of attribute insert.
  def insert; end

  def op; end

  # Returns the value of attribute remove.
  def remove; end
end

# Represents a simplistic (non-contextual) change. Represents the removal or
# addition of an element from either the old or the new sequenced
# enumerable.
class Diff::LCS::Change
  include ::Comparable

  # @return [Change] a new instance of Change
  def initialize(*args); end

  def <=>(other); end
  def ==(other); end

  # Returns the action this Change represents.
  def action; end

  # @return [Boolean]
  def adding?; end

  # @return [Boolean]
  def changed?; end

  # @return [Boolean]
  def deleting?; end

  # Returns the sequence element of the Change.
  def element; end

  # @return [Boolean]
  def finished_a?; end

  # @return [Boolean]
  def finished_b?; end

  def inspect(*_args); end

  # Returns the position of the Change.
  def position; end

  def to_a; end
  def to_ary; end

  # @return [Boolean]
  def unchanged?; end

  class << self
    def from_a(arr); end

    # @return [Boolean]
    def valid_action?(action); end
  end
end

Diff::LCS::Change::IntClass = Integer

# The only actions valid for changes are '+' (add), '-' (delete), '='
# (no change), '!' (changed), '<' (tail changes from first sequence), or
# '>' (tail changes from second sequence). The last two ('<>') are only
# found with Diff::LCS::diff and Diff::LCS::sdiff.
Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array)

# Represents a contextual change. Contains the position and values of the
# elements in the old and the new sequenced enumerables as well as the action
# taken.
class Diff::LCS::ContextChange < ::Diff::LCS::Change
  # @return [ContextChange] a new instance of ContextChange
  def initialize(*args); end

  def <=>(other); end
  def ==(other); end

  # Returns the new element being changed.
  def new_element; end

  # Returns the new position being changed.
  def new_position; end

  # Returns the old element being changed.
  def old_element; end

  # Returns the old position being changed.
  def old_position; end

  def to_a; end
  def to_ary; end

  class << self
    def from_a(arr); end

    # Simplifies a context change for use in some diff callbacks. '<' actions
    # are converted to '-' and '>' actions are converted to '+'.
    def simplify(event); end
  end
end

# This will produce a compound array of contextual diff change objects. Each
# element in the #diffs array is a "hunk" array, where each element in each
# "hunk" array is a single change. Each change is a Diff::LCS::ContextChange
# that contains both the old index and new index values for the change. The
# "hunk" provides the full context for the changes. Both old and new objects
# will be presented for changed objects. +nil+ will be substituted for a
# discarded object.
#
#     seq1 = %w(a b c e h j l m n p)
#     seq2 = %w(b c d e f j k l m r s t)
#
#     diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks)
#       # This example shows a simplified array format.
#       # [ [ [ '-', [  0, 'a' ], [  0, nil ] ] ],   # 1
#       #   [ [ '+', [  3, nil ], [  2, 'd' ] ] ],   # 2
#       #   [ [ '-', [  4, 'h' ], [  4, nil ] ],     # 3
#       #     [ '+', [  5, nil ], [  4, 'f' ] ] ],
#       #   [ [ '+', [  6, nil ], [  6, 'k' ] ] ],   # 4
#       #   [ [ '-', [  8, 'n' ], [  9, nil ] ],     # 5
#       #     [ '+', [  9, nil ], [  9, 'r' ] ],
#       #     [ '-', [  9, 'p' ], [ 10, nil ] ],
#       #     [ '+', [ 10, nil ], [ 10, 's' ] ],
#       #     [ '+', [ 10, nil ], [ 11, 't' ] ] ] ]
#
# The five hunks shown are comprised of individual changes; if there is a
# related set of changes, they are still shown individually.
#
# This callback can also be used with Diff::LCS#sdiff, which will produce
# results like:
#
#     diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks)
#       # This example shows a simplified array format.
#       # [ [ [ "-", [  0, "a" ], [  0, nil ] ] ],  # 1
#       #   [ [ "+", [  3, nil ], [  2, "d" ] ] ],  # 2
#       #   [ [ "!", [  4, "h" ], [  4, "f" ] ] ],  # 3
#       #   [ [ "+", [  6, nil ], [  6, "k" ] ] ],  # 4
#       #   [ [ "!", [  8, "n" ], [  9, "r" ] ],    # 5
#       #     [ "!", [  9, "p" ], [ 10, "s" ] ],
#       #     [ "+", [ 10, nil ], [ 11, "t" ] ] ] ]
#
# The five hunks are still present, but are significantly shorter in total
# presentation, because changed items are shown as changes ("!") instead of
# potentially "mismatched" pairs of additions and deletions.
#
# The result of this operation is similar to that of
# Diff::LCS::SDiffCallbacks. They may be compared as:
#
#     s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
#     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1)
#
#     s == c # -> true
#
# === Use
#
# This callback object must be initialised and can be used by the
# Diff::LCS#diff or Diff::LCS#sdiff methods.
#
#     cbo = Diff::LCS::ContextDiffCallbacks.new
#     Diff::LCS.LCS(seq1, seq2, cbo)
#     cbo.finish
#
# Note that the call to #finish is absolutely necessary, or the last set of
# changes will not be visible. Alternatively, can be used as:
#
#     cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
#
# The necessary #finish call will be made.
#
# === Simplified Array Format
#
# The simplified array format used in the example above can be obtained
# with:
#
#     require 'pp'
#     pp diffs.map { |e| e.map { |f| f.to_a } }
class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks
  def change(event); end
  def discard_a(event); end
  def discard_b(event); end
end

# This callback object implements the default set of callback events,
# which only returns the event itself. Note that #finished_a and
# #finished_b are not implemented -- I haven't yet figured out where they
# would be useful.
#
# Note that this is intended to be called as is, e.g.,
#
#     Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks)
class Diff::LCS::DefaultCallbacks
  class << self
    # Called when both the old and new values have changed.
    def change(event); end

    # Called when the old value is discarded in favour of the new value.
    def discard_a(event); end

    # Called when the new value is discarded in favour of the old value.
    def discard_b(event); end

    # Called when two items match.
    def match(event); end
  end
end

# This will produce a compound array of simple diff change objects. Each
# element in the #diffs array is a +hunk+ or +hunk+ array, where each
# element in each +hunk+ array is a single Change object representing the
# addition or removal of a single element from one of the two tested
# sequences. The +hunk+ provides the full context for the changes.
#
#     diffs = Diff::LCS.diff(seq1, seq2)
#       # This example shows a simplified array format.
#       # [ [ [ '-',  0, 'a' ] ],   # 1
#       #   [ [ '+',  2, 'd' ] ],   # 2
#       #   [ [ '-',  4, 'h' ],     # 3
#       #     [ '+',  4, 'f' ] ],
#       #   [ [ '+',  6, 'k' ] ],   # 4
#       #   [ [ '-',  8, 'n' ],     # 5
#       #     [ '-',  9, 'p' ],
#       #     [ '+',  9, 'r' ],
#       #     [ '+', 10, 's' ],
#       #     [ '+', 11, 't' ] ] ]
#
# There are five hunks here. The first hunk says that the +a+ at position 0
# of the first sequence should be deleted (<tt>'-'</tt>). The second hunk
# says that the +d+ at position 2 of the second sequence should be inserted
# (<tt>'+'</tt>). The third hunk says that the +h+ at position 4 of the
# first sequence should be removed and replaced with the +f+ from position 4
# of the second sequence. The other two hunks are described similarly.
#
# === Use
#
# This callback object must be initialised and is used by the Diff::LCS#diff
# method.
#
#     cbo = Diff::LCS::DiffCallbacks.new
#     Diff::LCS.LCS(seq1, seq2, cbo)
#     cbo.finish
#
# Note that the call to #finish is absolutely necessary, or the last set of
# changes will not be visible. Alternatively, can be used as:
#
#     cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
#
# The necessary #finish call will be made.
#
# === Simplified Array Format
#
# The simplified array format used in the example above can be obtained
# with:
#
#     require 'pp'
#     pp diffs.map { |e| e.map { |f| f.to_a } }
class Diff::LCS::DiffCallbacks
  # :yields self:
  #
  # @return [DiffCallbacks] a new instance of DiffCallbacks
  def initialize; end

  # Returns the difference set collected during the diff process.
  def diffs; end

  def discard_a(event); end
  def discard_b(event); end

  # Finalizes the diff process. If an unprocessed hunk still exists, then it
  # is appended to the diff list.
  def finish; end

  def match(_event); end

  private

  def finish_hunk; end
end

# A Hunk is a group of Blocks which overlap because of the context surrounding
# each block. (So if we're not using context, every hunk will contain one
# block.) Used in the diff program (bin/ldiff).
class Diff::LCS::Hunk
  # Create a hunk using references to both the old and new data, as well as the
  # piece of data.
  #
  # @return [Hunk] a new instance of Hunk
  def initialize(data_old, data_new, piece, flag_context, file_length_difference); end

  # Returns the value of attribute blocks.
  def blocks; end

  # Returns a diff string based on a format.
  def diff(format, last = T.unsafe(nil)); end

  # Returns the value of attribute end_new.
  def end_new; end

  # Returns the value of attribute end_old.
  def end_old; end

  # Returns the value of attribute file_length_difference.
  def file_length_difference; end

  # Change the "start" and "end" fields to note that context should be added
  # to this hunk.
  def flag_context; end

  def flag_context=(context); end

  # Merges this hunk and the provided hunk together if they overlap. Returns
  # a truthy value so that if there is no overlap, you can know the merge
  # was skipped.
  def merge(hunk); end

  # @return [Boolean]
  def missing_last_newline?(data); end

  # Determines whether there is an overlap between this hunk and the
  # provided hunk. This will be true if the difference between the two hunks
  # start or end positions is within one position of each other.
  #
  # @return [Boolean]
  def overlaps?(hunk); end

  # Returns the value of attribute start_new.
  def start_new; end

  # Returns the value of attribute start_old.
  def start_old; end

  # Merges this hunk and the provided hunk together if they overlap. Returns
  # a truthy value so that if there is no overlap, you can know the merge
  # was skipped.
  def unshift(hunk); end

  private

  def context_diff(last = T.unsafe(nil)); end

  # Generate a range of item numbers to print. Only print 1 number if the
  # range has only one item in it. Otherwise, it's 'start,end'
  def context_range(mode, op, last = T.unsafe(nil)); end

  def ed_diff(format, _last = T.unsafe(nil)); end
  def encode(literal, target_encoding = T.unsafe(nil)); end
  def encode_as(string, *args); end

  # Note that an old diff can't have any context. Therefore, we know that
  # there's only one block in the hunk.
  def old_diff(_last = T.unsafe(nil)); end

  def unified_diff(last = T.unsafe(nil)); end

  # Generate a range of item numbers to print for unified diff. Print number
  # where block starts, followed by number of lines in the block
  # (don't print number of lines if it's 1)
  def unified_range(mode, last); end
end

Diff::LCS::Hunk::ED_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash)
Diff::LCS::Hunk::OLD_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash)

module Diff::LCS::Internals
  class << self
    # This method will analyze the provided patchset to provide a single-pass
    # normalization (conversion of the array form of Diff::LCS::Change objects to
    # the object form of same) and detection of whether the patchset represents
    # changes to be made.
    def analyze_patchset(patchset, depth = T.unsafe(nil)); end

    # Examine the patchset and the source to see in which direction the
    # patch should be applied.
    #
    # WARNING: By default, this examines the whole patch, so this could take
    # some time. This also works better with Diff::LCS::ContextChange or
    # Diff::LCS::Change as its source, as an array will cause the creation
    # of one of the above.
    def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end

    # Compute the longest common subsequence between the sequenced
    # Enumerables +a+ and +b+. The result is an array whose contents is such
    # that
    #
    #     result = Diff::LCS::Internals.lcs(a, b)
    #     result.each_with_index do |e, i|
    #       assert_equal(a[i], b[e]) unless e.nil?
    #     end
    def lcs(a, b); end

    private

    # If +vector+ maps the matching elements of another collection onto this
    # Enumerable, compute the inverse of +vector+ that maps this Enumerable
    # onto the collection. (Currently unused.)
    def inverse_vector(a, vector); end

    # Returns a hash mapping each element of an Enumerable to the set of
    # positions it occupies in the Enumerable, optionally restricted to the
    # elements specified in the range of indexes specified by +interval+.
    def position_hash(enum, interval); end

    # Find the place at which +value+ would normally be inserted into the
    # Enumerable. If that place is already occupied by +value+, do nothing
    # and return +nil+. If the place does not exist (i.e., it is off the end
    # of the Enumerable), add it to the end. Otherwise, replace the element
    # at that point with +value+. It is assumed that the Enumerable's values
    # are numeric.
    #
    # This operation preserves the sort order.
    def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end
  end
end

# This will produce a simple array of diff change objects. Each element in
# the #diffs array is a single ContextChange. In the set of #diffs provided
# by SDiffCallbacks, both old and new objects will be presented for both
# changed <strong>and unchanged</strong> objects. +nil+ will be substituted
# for a discarded object.
#
# The diffset produced by this callback, when provided to Diff::LCS#sdiff,
# will compute and display the necessary components to show two sequences
# and their minimized differences side by side, just like the Unix utility
# +sdiff+.
#
#     same             same
#     before     |     after
#     old        <     -
#     -          >     new
#
#     seq1 = %w(a b c e h j l m n p)
#     seq2 = %w(b c d e f j k l m r s t)
#
#     diffs = Diff::LCS.sdiff(seq1, seq2)
#       # This example shows a simplified array format.
#       # [ [ "-", [  0, "a"], [  0, nil ] ],
#       #   [ "=", [  1, "b"], [  0, "b" ] ],
#       #   [ "=", [  2, "c"], [  1, "c" ] ],
#       #   [ "+", [  3, nil], [  2, "d" ] ],
#       #   [ "=", [  3, "e"], [  3, "e" ] ],
#       #   [ "!", [  4, "h"], [  4, "f" ] ],
#       #   [ "=", [  5, "j"], [  5, "j" ] ],
#       #   [ "+", [  6, nil], [  6, "k" ] ],
#       #   [ "=", [  6, "l"], [  7, "l" ] ],
#       #   [ "=", [  7, "m"], [  8, "m" ] ],
#       #   [ "!", [  8, "n"], [  9, "r" ] ],
#       #   [ "!", [  9, "p"], [ 10, "s" ] ],
#       #   [ "+", [ 10, nil], [ 11, "t" ] ] ]
#
# The result of this operation is similar to that of
# Diff::LCS::ContextDiffCallbacks. They may be compared as:
#
#     s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
#     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1)
#
#     s == c # -> true
#
# === Use
#
# This callback object must be initialised and is used by the Diff::LCS#sdiff
# method.
#
#     cbo = Diff::LCS::SDiffCallbacks.new
#     Diff::LCS.LCS(seq1, seq2, cbo)
#
# As with the other initialisable callback objects,
# Diff::LCS::SDiffCallbacks can be initialised with a block. As there is no
# "fininishing" to be done, this has no effect on the state of the object.
#
#     cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
#
# === Simplified Array Format
#
# The simplified array format used in the example above can be obtained
# with:
#
#     require 'pp'
#     pp diffs.map { |e| e.to_a }
class Diff::LCS::SDiffCallbacks
  # :yields self:
  #
  # @return [SDiffCallbacks] a new instance of SDiffCallbacks
  # @yield [_self]
  # @yieldparam _self [Diff::LCS::SDiffCallbacks] the object that the method was called on
  def initialize; end

  def change(event); end

  # Returns the difference set collected during the diff process.
  def diffs; end

  def discard_a(event); end
  def discard_b(event); end
  def match(event); end
end

# An alias for DefaultCallbacks that is used in
# Diff::LCS#traverse_sequences.
#
#     Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks)
Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks

Diff::LCS::VERSION = T.let(T.unsafe(nil), String)