workos 2.9.0 → 2.11.0

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

@@ -0,0 +1,185 @@
+# 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

@@ -0,0 +1,54 @@
+# 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

@@ -0,0 +1,82 @@
+# 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

@@ -0,0 +1,109 @@
+# 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

@@ -0,0 +1,8 @@
+# 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

@@ -0,0 +1,113 @@
+# 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