workos 4.1.0 → 4.2.1

data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi

@@ -1,185 +0,0 @@
-# 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
-  def diff(other, callbacks = T.unsafe(nil), &block); end
-  def lcs(other, &block); end
-  def patch(patchset); end
-  def patch!(patchset); end
-  def patch_me(patchset); end
-  def sdiff(other, callbacks = T.unsafe(nil), &block); end
-  def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end
-  def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end
-  def unpatch(patchset); end
-  def unpatch!(patchset); end
-  def unpatch_me(patchset); end
-
-  class << self
-    def LCS(seq1, seq2, &block); end
-    def callbacks_for(callbacks); end
-    def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
-    def lcs(seq1, seq2, &block); end
-    def patch(src, patchset, direction = T.unsafe(nil)); end
-    def patch!(src, patchset); end
-    def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
-    def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end
-    def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end
-    def unpatch!(src, patchset); end
-
-    private
-
-    def diff_traversal(method, seq1, seq2, callbacks, &block); end
-  end
-end
-
-Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks
-
-class Diff::LCS::Block
-  def initialize(chunk); end
-
-  def changes; end
-  def diff_size; end
-  def insert; end
-  def op; end
-  def remove; end
-end
-
-class Diff::LCS::Change
-  include ::Comparable
-
-  def initialize(*args); end
-
-  def <=>(other); end
-  def ==(other); end
-  def action; end
-  def adding?; end
-  def changed?; end
-  def deleting?; end
-  def element; end
-  def finished_a?; end
-  def finished_b?; end
-  def inspect(*_args); end
-  def position; end
-  def to_a; end
-  def to_ary; end
-  def unchanged?; end
-
-  class << self
-    def from_a(arr); end
-    def valid_action?(action); end
-  end
-end
-
-Diff::LCS::Change::IntClass = Integer
-Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array)
-
-class Diff::LCS::ContextChange < ::Diff::LCS::Change
-  def initialize(*args); end
-
-  def <=>(other); end
-  def ==(other); end
-  def new_element; end
-  def new_position; end
-  def old_element; end
-  def old_position; end
-  def to_a; end
-  def to_ary; end
-
-  class << self
-    def from_a(arr); end
-    def simplify(event); end
-  end
-end
-
-class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks
-  def change(event); end
-  def discard_a(event); end
-  def discard_b(event); end
-end
-
-class Diff::LCS::DefaultCallbacks
-  class << self
-    def change(event); end
-    def discard_a(event); end
-    def discard_b(event); end
-    def match(event); end
-  end
-end
-
-class Diff::LCS::DiffCallbacks
-  def initialize; end
-
-  def diffs; end
-  def discard_a(event); end
-  def discard_b(event); end
-  def finish; end
-  def match(_event); end
-
-  private
-
-  def finish_hunk; end
-end
-
-class Diff::LCS::Hunk
-  def initialize(data_old, data_new, piece, flag_context, file_length_difference); end
-
-  def blocks; end
-  def diff(format, last = T.unsafe(nil)); end
-  def end_new; end
-  def end_old; end
-  def file_length_difference; end
-  def flag_context; end
-  def flag_context=(context); end
-  def merge(hunk); end
-  def missing_last_newline?(data); end
-  def overlaps?(hunk); end
-  def start_new; end
-  def start_old; end
-  def unshift(hunk); end
-
-  private
-
-  def context_diff(last = T.unsafe(nil)); 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
-  def old_diff(_last = T.unsafe(nil)); end
-  def unified_diff(last = T.unsafe(nil)); end
-  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
-    def analyze_patchset(patchset, depth = T.unsafe(nil)); end
-    def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end
-    def lcs(a, b); end
-
-    private
-
-    def inverse_vector(a, vector); end
-    def position_hash(enum, interval); end
-    def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end
-  end
-end
-
-class Diff::LCS::SDiffCallbacks
-  def initialize; end
-
-  def change(event); end
-  def diffs; end
-  def discard_a(event); end
-  def discard_b(event); end
-  def match(event); end
-end
-
-Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks
-Diff::LCS::VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/docile@1.3.5.rbi

@@ -1,54 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `docile` gem.
-# Please instead update this file by running `bin/tapioca gem docile`.
-
-module Docile
-  extend ::Docile::Execution
-
-  private
-
-  def dsl_eval(dsl, *args, **_arg2, &block); end
-  def dsl_eval_immutable(dsl, *args, **_arg2, &block); end
-  def dsl_eval_with_block_return(dsl, *args, **_arg2, &block); end
-
-  class << self
-    def dsl_eval(dsl, *args, **_arg2, &block); end
-    def dsl_eval_immutable(dsl, *args, **_arg2, &block); end
-    def dsl_eval_with_block_return(dsl, *args, **_arg2, &block); end
-  end
-end
-
-module Docile::BacktraceFilter
-  def backtrace; end
-  def backtrace_locations; end
-end
-
-Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy
-  def method_missing(method, *args, **_arg2, &block); end
-end
-
-module Docile::Execution
-  private
-
-  def exec_in_proxy_context(dsl, proxy_type, *args, **_arg3, &block); end
-
-  class << self
-    def exec_in_proxy_context(dsl, proxy_type, *args, **_arg3, &block); end
-  end
-end
-
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-
-  def instance_variables; end
-  def method_missing(method, *args, **_arg2, &block); end
-end
-
-Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set)
-Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set)
-Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set)
-Docile::VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/hashdiff@1.0.1.rbi

@@ -1,82 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `hashdiff` gem.
-# Please instead update this file by running `bin/tapioca gem hashdiff`.
-
-module Hashdiff
-  class << self
-    def best_diff(obj1, obj2, options = T.unsafe(nil), &block); end
-    def comparable?(obj1, obj2, strict = T.unsafe(nil)); end
-    def compare_values(obj1, obj2, options = T.unsafe(nil)); end
-    def count_diff(diffs); end
-    def count_nodes(obj); end
-    def custom_compare(method, key, obj1, obj2); end
-    def decode_property_path(path, delimiter = T.unsafe(nil)); end
-    def diff(obj1, obj2, options = T.unsafe(nil), &block); end
-    def diff_array_lcs(arraya, arrayb, options = T.unsafe(nil)); end
-    def lcs(arraya, arrayb, options = T.unsafe(nil)); end
-    def node(hash, parts); end
-    def patch!(obj, changes, options = T.unsafe(nil)); end
-    def prefix_append_array_index(prefix, array_index, opts); end
-    def prefix_append_key(prefix, key, opts); end
-    def similar?(obja, objb, options = T.unsafe(nil)); end
-    def unpatch!(obj, changes, options = T.unsafe(nil)); end
-
-    private
-
-    def any_hash_or_array?(obja, objb); end
-  end
-end
-
-class Hashdiff::CompareHashes
-  class << self
-    def call(obj1, obj2, opts = T.unsafe(nil)); end
-  end
-end
-
-class Hashdiff::LcsCompareArrays
-  class << self
-    def call(obj1, obj2, opts = T.unsafe(nil)); end
-  end
-end
-
-class Hashdiff::LinearCompareArray
-  def initialize(old_array, new_array, options); end
-
-  def call; end
-
-  private
-
-  def additions; end
-  def append_addition(item, index); end
-  def append_addititions_before_match(match_index); end
-  def append_deletion(item, index); end
-  def append_deletions_before_match(match_index); end
-  def append_differences(difference); end
-  def changes; end
-  def compare_at_index; end
-  def deletions; end
-  def differences; end
-  def expected_additions; end
-  def expected_additions=(_arg0); end
-  def extra_items_in_new_array?; end
-  def extra_items_in_old_array?; end
-  def index_of_match_after_additions; end
-  def index_of_match_after_deletions; end
-  def item_difference(old_item, new_item, item_index); end
-  def iterated_through_both_arrays?; end
-  def new_array; end
-  def new_index; end
-  def new_index=(_arg0); end
-  def old_array; end
-  def old_index; end
-  def old_index=(_arg0); end
-  def options; end
-
-  class << self
-    def call(old_array, new_array, options = T.unsafe(nil)); end
-  end
-end
-
-Hashdiff::VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/json@2.5.1.rbi

@@ -1,109 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `json` gem.
-# Please instead update this file by running `bin/tapioca gem json`.
-
-class Class < ::Module
-  def json_creatable?; end
-end
-
-module JSON
-  private
-
-  def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end
-  def fast_generate(obj, opts = T.unsafe(nil)); end
-  def fast_unparse(obj, opts = T.unsafe(nil)); end
-  def generate(obj, opts = T.unsafe(nil)); end
-  def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-  def load_file(filespec, opts = T.unsafe(nil)); end
-  def load_file!(filespec, opts = T.unsafe(nil)); end
-  def parse(source, opts = T.unsafe(nil)); end
-  def parse!(source, opts = T.unsafe(nil)); end
-  def pretty_generate(obj, opts = T.unsafe(nil)); end
-  def pretty_unparse(obj, opts = T.unsafe(nil)); end
-  def recurse_proc(result, &proc); end
-  def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-  def unparse(obj, opts = T.unsafe(nil)); end
-
-  class << self
-    def [](object, opts = T.unsafe(nil)); end
-    def create_fast_state; end
-    def create_id; end
-    def create_id=(new_value); end
-    def create_pretty_state; end
-    def deep_const_get(path); end
-    def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end
-    def dump_default_options; end
-    def dump_default_options=(_arg0); end
-    def fast_generate(obj, opts = T.unsafe(nil)); end
-    def fast_unparse(obj, opts = T.unsafe(nil)); end
-    def generate(obj, opts = T.unsafe(nil)); end
-    def generator; end
-    def generator=(generator); end
-    def iconv(to, from, string); end
-    def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-    def load_default_options; end
-    def load_default_options=(_arg0); end
-    def load_file(filespec, opts = T.unsafe(nil)); end
-    def load_file!(filespec, opts = T.unsafe(nil)); end
-    def parse(source, opts = T.unsafe(nil)); end
-    def parse!(source, opts = T.unsafe(nil)); end
-    def parser; end
-    def parser=(parser); end
-    def pretty_generate(obj, opts = T.unsafe(nil)); end
-    def pretty_unparse(obj, opts = T.unsafe(nil)); end
-    def recurse_proc(result, &proc); end
-    def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-    def state; end
-    def state=(_arg0); end
-    def unparse(obj, opts = T.unsafe(nil)); end
-  end
-end
-
-JSON::CREATE_ID_TLS_KEY = T.let(T.unsafe(nil), String)
-JSON::DEFAULT_CREATE_ID = T.let(T.unsafe(nil), String)
-
-class JSON::GenericObject < ::OpenStruct
-  def as_json(*_arg0); end
-  def to_hash; end
-  def to_json(*a); end
-  def |(other); end
-
-  class << self
-    def dump(obj, *args); end
-    def from_hash(object); end
-    def json_creatable=(_arg0); end
-    def json_creatable?; end
-    def json_create(data); end
-    def load(source, proc = T.unsafe(nil), opts = T.unsafe(nil)); end
-  end
-end
-
-class JSON::JSONError < ::StandardError
-  class << self
-    def wrap(exception); end
-  end
-end
-
-JSON::Parser = JSON::Ext::Parser
-JSON::State = JSON::Ext::Generator::State
-JSON::UnparserError = JSON::GeneratorError
-
-module Kernel
-  private
-
-  def JSON(object, *args); end
-  def j(*objs); end
-  def jj(*objs); end
-end
-
-class Set
-  include ::Enumerable
-end
-
-Set::InspectKey = T.let(T.unsafe(nil), Symbol)
-
-class Symbol
-  include ::Comparable
-end

data/sorbet/rbi/gems/method_source@1.0.0.rbi

@@ -1,8 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `method_source` gem.
-# Please instead update this file by running `bin/tapioca gem method_source`.
-
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires

data/sorbet/rbi/gems/parallel@1.20.1.rbi

@@ -1,113 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `parallel` gem.
-# Please instead update this file by running `bin/tapioca gem parallel`.
-
-module Parallel
-  extend ::Parallel::ProcessorCount
-
-  class << self
-    def all?(*args, &block); end
-    def any?(*args, &block); end
-    def each(array, options = T.unsafe(nil), &block); end
-    def each_with_index(array, options = T.unsafe(nil), &block); end
-    def flat_map(*args, &block); end
-    def in_processes(options = T.unsafe(nil), &block); end
-    def in_threads(options = T.unsafe(nil)); end
-    def map(source, options = T.unsafe(nil), &block); end
-    def map_with_index(array, options = T.unsafe(nil), &block); end
-    def worker_number; end
-    def worker_number=(worker_num); end
-
-    private
-
-    def add_progress_bar!(job_factory, options); end
-    def call_with_index(item, index, options, &block); end
-    def create_workers(job_factory, options, &block); end
-    def extract_count_from_options(options); end
-    def process_incoming_jobs(read, write, job_factory, options, &block); end
-    def replace_worker(job_factory, workers, i, options, blk); end
-    def with_instrumentation(item, index, options); end
-    def work_direct(job_factory, options, &block); end
-    def work_in_processes(job_factory, options, &blk); end
-    def work_in_threads(job_factory, options, &block); end
-    def worker(job_factory, options, &block); end
-  end
-end
-
-class Parallel::Break < ::StandardError
-  def initialize(value = T.unsafe(nil)); end
-
-  def value; end
-end
-
-class Parallel::DeadWorker < ::StandardError; end
-
-class Parallel::ExceptionWrapper
-  def initialize(exception); end
-
-  def exception; end
-end
-
-class Parallel::JobFactory
-  def initialize(source, mutex); end
-
-  def next; end
-  def pack(item, index); end
-  def size; end
-  def unpack(data); end
-
-  private
-
-  def producer?; end
-  def queue_wrapper(array); end
-end
-
-class Parallel::Kill < ::Parallel::Break; end
-
-module Parallel::ProcessorCount
-  def physical_processor_count; end
-  def processor_count; end
-end
-
-Parallel::Stop = T.let(T.unsafe(nil), Object)
-
-class Parallel::UndumpableException < ::StandardError
-  def initialize(original); end
-
-  def backtrace; end
-end
-
-class Parallel::UserInterruptHandler
-  class << self
-    def kill(thing); end
-    def kill_on_ctrl_c(pids, options); end
-
-    private
-
-    def restore_interrupt(old, signal); end
-    def trap_interrupt(signal); end
-  end
-end
-
-Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
-Parallel::VERSION = T.let(T.unsafe(nil), String)
-Parallel::Version = T.let(T.unsafe(nil), String)
-
-class Parallel::Worker
-  def initialize(read, write, pid); end
-
-  def close_pipes; end
-  def pid; end
-  def read; end
-  def stop; end
-  def thread; end
-  def thread=(_arg0); end
-  def work(data); end
-  def write; end
-
-  private
-
-  def wait; end
-end