workos 2.10.0 → 2.11.0

data/sorbet/tapioca/config.yml

@@ -0,0 +1,13 @@
+gem:
+  # Add your `gem` command parameters here:
+  #
+  # exclude:
+  # - gem_name
+  # doc: true
+  # workers: 5
+dsl:
+  # Add your `dsl` command parameters here:
+  #
+  # exclude:
+  # - SomeGeneratorName
+  # workers: 5

data/sorbet/tapioca/require.rb

@@ -0,0 +1,4 @@
+# typed: true
+# frozen_string_literal: true
+
+# Add your extra requires here (`bin/tapioca require` can be used to boostrap this list)

data/workos.gemspec

@@ -26,10 +26,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '>= 2.0.1'
   spec.add_development_dependency 'codecov', '~> 0.2.8'
-  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3.9.0'
   spec.add_development_dependency 'rubocop', '~> 0.77'
   spec.add_development_dependency 'sorbet', '~> 0.5'
+  spec.add_development_dependency 'tapioca'
   spec.add_development_dependency 'vcr', '~> 5.0.0'
   spec.add_development_dependency 'webmock'
   spec.add_development_dependency 'yard'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: workos
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.11.0
 platform: ruby
 authors:
 - WorkOS
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-08 00:00:00.000000000 Z
+date: 2023-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.8
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: vcr
   requirement: !ruby/object:Gem::Requirement
@@ -158,6 +158,7 @@ executables:
 - console
 - docs
 - publish
+- tapioca
 extensions: []
 extra_rdoc_files: []
 files:
@@ -178,6 +179,7 @@ files:
 - bin/console
 - bin/docs
 - bin/publish
+- bin/tapioca
 - codecov.yml
 - docs/WorkOS.html
 - docs/WorkOS/APIError.html
@@ -252,39 +254,47 @@ files:
 - lib/workos/webhook.rb
 - lib/workos/webhooks.rb
 - sorbet/config
-- sorbet/rbi/gems/addressable.rbi
-- sorbet/rbi/gems/ast.rbi
-- sorbet/rbi/gems/codecov.rbi
-- sorbet/rbi/gems/crack.rbi
-- sorbet/rbi/gems/docile.rbi
-- sorbet/rbi/gems/hashdiff.rbi
-- sorbet/rbi/gems/parallel.rbi
-- sorbet/rbi/gems/parser.rbi
-- sorbet/rbi/gems/public_suffix.rbi
-- sorbet/rbi/gems/rainbow.rbi
-- sorbet/rbi/gems/rake.rbi
-- sorbet/rbi/gems/regexp_parser.rbi
-- sorbet/rbi/gems/rexml.rbi
-- sorbet/rbi/gems/rspec-core.rbi
-- sorbet/rbi/gems/rspec-expectations.rbi
-- sorbet/rbi/gems/rspec-mocks.rbi
-- sorbet/rbi/gems/rspec-support.rbi
-- sorbet/rbi/gems/rspec.rbi
-- sorbet/rbi/gems/rubocop-ast.rbi
-- sorbet/rbi/gems/rubocop.rbi
-- sorbet/rbi/gems/ruby-progressbar.rbi
-- sorbet/rbi/gems/simplecov-html.rbi
-- sorbet/rbi/gems/simplecov.rbi
-- sorbet/rbi/gems/unicode-display_width.rbi
-- sorbet/rbi/gems/vcr.rbi
-- sorbet/rbi/gems/webmock.rbi
-- sorbet/rbi/gems/yard.rbi
-- sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi
-- sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi
-- sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi
-- sorbet/rbi/sorbet-typed/lib/rubocop/~>0.85/rubocop.rbi
-- sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi
-- sorbet/rbi/todo.rbi
+- sorbet/rbi/gems/addressable@2.8.0.rbi
+- sorbet/rbi/gems/ast@2.4.2.rbi
+- sorbet/rbi/gems/codecov@0.2.12.rbi
+- sorbet/rbi/gems/coderay@1.1.3.rbi
+- sorbet/rbi/gems/crack@0.4.5.rbi
+- sorbet/rbi/gems/diff-lcs@1.4.4.rbi
+- sorbet/rbi/gems/docile@1.3.5.rbi
+- sorbet/rbi/gems/hashdiff@1.0.1.rbi
+- sorbet/rbi/gems/json@2.5.1.rbi
+- sorbet/rbi/gems/method_source@1.0.0.rbi
+- sorbet/rbi/gems/parallel@1.20.1.rbi
+- sorbet/rbi/gems/parser@3.0.1.0.rbi
+- sorbet/rbi/gems/pry@0.14.2.rbi
+- sorbet/rbi/gems/public_suffix@4.0.6.rbi
+- sorbet/rbi/gems/rainbow@3.0.0.rbi
+- sorbet/rbi/gems/rake@13.0.3.rbi
+- sorbet/rbi/gems/rbi@0.0.16.rbi
+- sorbet/rbi/gems/regexp_parser@2.1.1.rbi
+- sorbet/rbi/gems/rexml@3.2.5.rbi
+- sorbet/rbi/gems/rspec-core@3.9.3.rbi
+- sorbet/rbi/gems/rspec-expectations@3.9.4.rbi
+- sorbet/rbi/gems/rspec-mocks@3.9.1.rbi
+- sorbet/rbi/gems/rspec-support@3.9.4.rbi
+- sorbet/rbi/gems/rspec@3.9.0.rbi
+- sorbet/rbi/gems/rubocop-ast@1.4.1.rbi
+- sorbet/rbi/gems/rubocop@0.93.1.rbi
+- sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi
+- sorbet/rbi/gems/simplecov-html@0.12.3.rbi
+- sorbet/rbi/gems/simplecov@0.21.2.rbi
+- sorbet/rbi/gems/simplecov_json_formatter@0.1.2.rbi
+- sorbet/rbi/gems/spoom@1.1.15.rbi
+- sorbet/rbi/gems/tapioca@0.7.3.rbi
+- sorbet/rbi/gems/thor@1.2.1.rbi
+- sorbet/rbi/gems/unicode-display_width@1.7.0.rbi
+- sorbet/rbi/gems/unparser@0.6.2.rbi
+- sorbet/rbi/gems/vcr@5.0.0.rbi
+- sorbet/rbi/gems/webmock@3.12.2.rbi
+- sorbet/rbi/gems/yard-sorbet@0.8.0.rbi
+- sorbet/rbi/gems/yard@0.9.26.rbi
+- sorbet/tapioca/config.yml
+- sorbet/tapioca/require.rb
 - spec/lib/workos/audit_logs_spec.rb
 - spec/lib/workos/audit_trail_spec.rb
 - spec/lib/workos/configuration_spec.rb
@@ -403,7 +413,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: API client for WorkOS

data/sorbet/rbi/gems/addressable.rbi

@@ -1,199 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/addressable/all/addressable.rbi
-#
-# addressable-2.7.0
-
-module Addressable
-end
-module Addressable::VERSION
-end
-module Addressable::IDNA
-  def self.lookup_unicode_combining_class(codepoint); end
-  def self.lookup_unicode_compatibility(codepoint); end
-  def self.lookup_unicode_composition(unpacked); end
-  def self.lookup_unicode_lowercase(codepoint); end
-  def self.punycode_adapt(delta, numpoints, firsttime); end
-  def self.punycode_basic?(codepoint); end
-  def self.punycode_decode(punycode); end
-  def self.punycode_decode_digit(codepoint); end
-  def self.punycode_delimiter?(codepoint); end
-  def self.punycode_encode(unicode); end
-  def self.punycode_encode_digit(d); end
-  def self.to_ascii(input); end
-  def self.to_unicode(input); end
-  def self.unicode_compose(unpacked); end
-  def self.unicode_compose_pair(ch_one, ch_two); end
-  def self.unicode_decompose(unpacked); end
-  def self.unicode_decompose_hangul(codepoint); end
-  def self.unicode_downcase(input); end
-  def self.unicode_normalize_kc(input); end
-  def self.unicode_sort_canonical(unpacked); end
-end
-class Addressable::IDNA::PunycodeBadInput < StandardError
-end
-class Addressable::IDNA::PunycodeBigOutput < StandardError
-end
-class Addressable::IDNA::PunycodeOverflow < StandardError
-end
-class Addressable::URI
-  def +(uri); end
-  def ==(uri); end
-  def ===(uri); end
-  def absolute?; end
-  def authority; end
-  def authority=(new_authority); end
-  def basename; end
-  def default_port; end
-  def defer_validation; end
-  def display_uri; end
-  def domain; end
-  def dup; end
-  def empty?; end
-  def eql?(uri); end
-  def extname; end
-  def fragment; end
-  def fragment=(new_fragment); end
-  def freeze; end
-  def hash; end
-  def host; end
-  def host=(new_host); end
-  def hostname; end
-  def hostname=(new_hostname); end
-  def inferred_port; end
-  def initialize(options = nil); end
-  def inspect; end
-  def ip_based?; end
-  def join!(uri); end
-  def join(uri); end
-  def merge!(uri); end
-  def merge(hash); end
-  def normalize!; end
-  def normalize; end
-  def normalized_authority; end
-  def normalized_fragment; end
-  def normalized_host; end
-  def normalized_password; end
-  def normalized_path; end
-  def normalized_port; end
-  def normalized_query(*flags); end
-  def normalized_scheme; end
-  def normalized_site; end
-  def normalized_user; end
-  def normalized_userinfo; end
-  def omit!(*components); end
-  def omit(*components); end
-  def origin; end
-  def origin=(new_origin); end
-  def password; end
-  def password=(new_password); end
-  def path; end
-  def path=(new_path); end
-  def port; end
-  def port=(new_port); end
-  def query; end
-  def query=(new_query); end
-  def query_values(return_type = nil); end
-  def query_values=(new_query_values); end
-  def relative?; end
-  def remove_composite_values; end
-  def replace_self(uri); end
-  def request_uri; end
-  def request_uri=(new_request_uri); end
-  def route_from(uri); end
-  def route_to(uri); end
-  def scheme; end
-  def scheme=(new_scheme); end
-  def self.convert_path(path); end
-  def self.encode(uri, return_type = nil); end
-  def self.encode_component(component, character_class = nil, upcase_encoded = nil); end
-  def self.escape(uri, return_type = nil); end
-  def self.form_encode(form_values, sort = nil); end
-  def self.form_unencode(encoded_value); end
-  def self.heuristic_parse(uri, hints = nil); end
-  def self.ip_based_schemes; end
-  def self.join(*uris); end
-  def self.normalize_component(component, character_class = nil, leave_encoded = nil); end
-  def self.normalize_path(path); end
-  def self.normalized_encode(uri, return_type = nil); end
-  def self.parse(uri); end
-  def self.port_mapping; end
-  def self.unencode(uri, return_type = nil, leave_encoded = nil); end
-  def self.unencode_component(uri, return_type = nil, leave_encoded = nil); end
-  def self.unescape(uri, return_type = nil, leave_encoded = nil); end
-  def self.unescape_component(uri, return_type = nil, leave_encoded = nil); end
-  def site; end
-  def site=(new_site); end
-  def split_path(path); end
-  def tld; end
-  def tld=(new_tld); end
-  def to_hash; end
-  def to_s; end
-  def to_str; end
-  def user; end
-  def user=(new_user); end
-  def userinfo; end
-  def userinfo=(new_userinfo); end
-  def validate; end
-end
-class Addressable::URI::InvalidURIError < StandardError
-end
-module Addressable::URI::CharacterClasses
-end
-class Addressable::Template
-  def ==(template); end
-  def eql?(template); end
-  def expand(mapping, processor = nil, normalize_values = nil); end
-  def extract(uri, processor = nil); end
-  def freeze; end
-  def generate(params = nil, recall = nil, options = nil); end
-  def initialize(pattern); end
-  def inspect; end
-  def join_values(operator, return_value); end
-  def keys; end
-  def match(uri, processor = nil); end
-  def named_captures; end
-  def names; end
-  def normalize_keys(mapping); end
-  def normalize_value(value); end
-  def ordered_variable_defaults; end
-  def parse_template_pattern(pattern, processor = nil); end
-  def partial_expand(mapping, processor = nil, normalize_values = nil); end
-  def pattern; end
-  def source; end
-  def to_regexp; end
-  def transform_capture(mapping, capture, processor = nil, normalize_values = nil); end
-  def transform_partial_capture(mapping, capture, processor = nil, normalize_values = nil); end
-  def variable_defaults; end
-  def variables; end
-end
-class Addressable::Template::InvalidTemplateValueError < StandardError
-end
-class Addressable::Template::InvalidTemplateOperatorError < StandardError
-end
-class Addressable::Template::TemplateOperatorAbortedError < StandardError
-end
-class Addressable::Template::MatchData
-  def [](key, len = nil); end
-  def captures; end
-  def initialize(uri, template, mapping); end
-  def inspect; end
-  def keys; end
-  def mapping; end
-  def names; end
-  def post_match; end
-  def pre_match; end
-  def string; end
-  def template; end
-  def to_a; end
-  def to_s; end
-  def uri; end
-  def values; end
-  def values_at(*indexes); end
-  def variables; end
-end

data/sorbet/rbi/gems/codecov.rbi

@@ -1,37 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/codecov/all/codecov.rbi
-#
-# codecov-0.2.15
-
-module Codecov
-end
-class SimpleCov::Formatter::Codecov
-  def black(str); end
-  def build_params(ci); end
-  def create_report(report); end
-  def detect_ci; end
-  def display_header; end
-  def file_network; end
-  def file_to_codecov(file); end
-  def format(result, disable_net_blockers = nil); end
-  def green(str); end
-  def gzip_report(report); end
-  def handle_report_response(report); end
-  def net_blockers(switch); end
-  def red(str); end
-  def result_to_codecov(result); end
-  def result_to_codecov_coverage(result); end
-  def result_to_codecov_messages(result); end
-  def result_to_codecov_report(result); end
-  def retry_request(req, https); end
-  def shortened_filename(file); end
-  def upload_to_codecov(ci, report); end
-  def upload_to_v2(url, report, query, query_without_token); end
-  def upload_to_v4(url, report, query, query_without_token); end
-end

data/sorbet/rbi/gems/crack.rbi

@@ -1,62 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/crack/all/crack.rbi
-#
-# crack-0.4.5
-
-module Crack
-end
-module Crack::Util
-  def snake_case(str); end
-  def to_xml_attributes(hash); end
-  extend Crack::Util
-end
-class Crack::JSON
-  def self.convert_json_to_yaml(json); end
-  def self.format_dates(output, date_starts, date_ends); end
-  def self.parse(json); end
-  def self.parser_exceptions; end
-  def self.unescape(str); end
-end
-class REXMLUtiliyNodeString < String
-  def attributes; end
-  def attributes=(arg0); end
-end
-class REXMLUtilityNode
-  def add_node(node); end
-  def attributes; end
-  def attributes=(arg0); end
-  def children; end
-  def children=(arg0); end
-  def initialize(name, normalized_attributes = nil); end
-  def inner_html; end
-  def name; end
-  def name=(arg0); end
-  def self.available_typecasts; end
-  def self.available_typecasts=(obj); end
-  def self.typecasts; end
-  def self.typecasts=(obj); end
-  def to_hash; end
-  def to_html; end
-  def to_s; end
-  def type; end
-  def type=(arg0); end
-  def typecast_value(value); end
-  def undasherize_keys(params); end
-  def unnormalize_xml_entities(value); end
-end
-class Crack::REXMLParser
-  def self.parse(xml); end
-end
-class Crack::XML
-  def self.parse(xml); end
-  def self.parser; end
-  def self.parser=(parser); end
-end
-class Crack::ParseError < StandardError
-end

data/sorbet/rbi/gems/docile.rbi

@@ -1,36 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/docile/all/docile.rbi
-#
-# docile-1.3.5
-
-module Docile
-  def dsl_eval(dsl, *args, &block); end
-  def dsl_eval_immutable(dsl, *args, &block); end
-  def dsl_eval_with_block_return(dsl, *args, &block); end
-  def self.dsl_eval(dsl, *args, &block); end
-  def self.dsl_eval_immutable(dsl, *args, &block); end
-  def self.dsl_eval_with_block_return(dsl, *args, &block); end
-  extend Docile::Execution
-end
-module Docile::Execution
-  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-end
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-  def instance_variables; end
-  def method_missing(method, *args, &block); end
-end
-class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy
-  def method_missing(method, *args, &block); end
-end
-module Docile::BacktraceFilter
-  def backtrace; end
-  def backtrace_locations; end
-end

data/sorbet/rbi/gems/hashdiff.rbi

@@ -1,66 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/hashdiff/all/hashdiff.rbi
-#
-# hashdiff-1.0.1
-
-module Hashdiff
-  def self.any_hash_or_array?(obja, objb); end
-  def self.best_diff(obj1, obj2, options = nil, &block); end
-  def self.comparable?(obj1, obj2, strict = nil); end
-  def self.compare_values(obj1, obj2, options = nil); end
-  def self.count_diff(diffs); end
-  def self.count_nodes(obj); end
-  def self.custom_compare(method, key, obj1, obj2); end
-  def self.decode_property_path(path, delimiter = nil); end
-  def self.diff(obj1, obj2, options = nil, &block); end
-  def self.diff_array_lcs(arraya, arrayb, options = nil); end
-  def self.lcs(arraya, arrayb, options = nil); end
-  def self.node(hash, parts); end
-  def self.patch!(obj, changes, options = nil); end
-  def self.prefix_append_array_index(prefix, array_index, opts); end
-  def self.prefix_append_key(prefix, key, opts); end
-  def self.similar?(obja, objb, options = nil); end
-  def self.unpatch!(obj, changes, options = nil); end
-end
-class Hashdiff::CompareHashes
-  def self.call(obj1, obj2, opts = nil); end
-end
-class Hashdiff::LcsCompareArrays
-  def self.call(obj1, obj2, opts = nil); end
-end
-class Hashdiff::LinearCompareArray
-  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 call; 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 initialize(old_array, new_array, options); 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
-  def self.call(old_array, new_array, options = nil); end
-end

data/sorbet/rbi/gems/parallel.rbi

@@ -1,83 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parallel/all/parallel.rbi
-#
-# parallel-1.20.1
-
-module Parallel
-  def self.add_progress_bar!(job_factory, options); end
-  def self.all?(*args, &block); end
-  def self.any?(*args, &block); end
-  def self.call_with_index(item, index, options, &block); end
-  def self.create_workers(job_factory, options, &block); end
-  def self.each(array, options = nil, &block); end
-  def self.each_with_index(array, options = nil, &block); end
-  def self.extract_count_from_options(options); end
-  def self.flat_map(*args, &block); end
-  def self.in_processes(options = nil, &block); end
-  def self.in_threads(options = nil); end
-  def self.map(source, options = nil, &block); end
-  def self.map_with_index(array, options = nil, &block); end
-  def self.process_incoming_jobs(read, write, job_factory, options, &block); end
-  def self.replace_worker(job_factory, workers, i, options, blk); end
-  def self.with_instrumentation(item, index, options); end
-  def self.work_direct(job_factory, options, &block); end
-  def self.work_in_processes(job_factory, options, &blk); end
-  def self.work_in_threads(job_factory, options, &block); end
-  def self.worker(job_factory, options, &block); end
-  def self.worker_number; end
-  def self.worker_number=(worker_num); end
-  extend Parallel::ProcessorCount
-end
-module Parallel::ProcessorCount
-  def physical_processor_count; end
-  def processor_count; end
-end
-class Parallel::DeadWorker < StandardError
-end
-class Parallel::Break < StandardError
-  def initialize(value = nil); end
-  def value; end
-end
-class Parallel::Kill < Parallel::Break
-end
-class Parallel::UndumpableException < StandardError
-  def backtrace; end
-  def initialize(original); end
-end
-class Parallel::ExceptionWrapper
-  def exception; end
-  def initialize(exception); end
-end
-class Parallel::Worker
-  def close_pipes; end
-  def initialize(read, write, pid); end
-  def pid; end
-  def read; end
-  def stop; end
-  def thread; end
-  def thread=(arg0); end
-  def wait; end
-  def work(data); end
-  def write; end
-end
-class Parallel::JobFactory
-  def initialize(source, mutex); end
-  def next; end
-  def pack(item, index); end
-  def producer?; end
-  def queue_wrapper(array); end
-  def size; end
-  def unpack(data); end
-end
-class Parallel::UserInterruptHandler
-  def self.kill(thing); end
-  def self.kill_on_ctrl_c(pids, options); end
-  def self.restore_interrupt(old, signal); end
-  def self.trap_interrupt(signal); end
-end