toy_adt 0.1.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,905 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi sorbet-typed
3
+ #
4
+ # If you would like to make changes to this file, great! Please upstream any changes you make here:
5
+ #
6
+ # https://github.com/sorbet/sorbet-typed/edit/master/lib/thor/all/thor.rbi
7
+ #
8
+ # typed: strong
9
+
10
+ class Thor
11
+ include(::Thor::Base)
12
+ include(::Thor::Invocation)
13
+ include(::Thor::Shell)
14
+ extend(::Thor::Base::ClassMethods)
15
+ extend(::Thor::Invocation::ClassMethods)
16
+
17
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
18
+
19
+ class << self
20
+ def check_unknown_options!(options = T.unsafe(nil)); end
21
+ def check_unknown_options?(config); end
22
+ def command_help(shell, command_name); end
23
+ def default_command(meth = T.unsafe(nil)); end
24
+ def default_task(meth = T.unsafe(nil)); end
25
+ def deprecation_warning(message); end
26
+ def desc(usage, description, options = T.unsafe(nil)); end
27
+ def disable_required_check!(*command_names); end
28
+ def disable_required_check?(command); end
29
+ def help(shell, subcommand = T.unsafe(nil)); end
30
+ def long_desc(long_description, options = T.unsafe(nil)); end
31
+ def map(mappings = T.unsafe(nil), **kw); end
32
+ def method_option(name, options = T.unsafe(nil)); end
33
+ def method_options(options = T.unsafe(nil)); end
34
+ def option(name, options = T.unsafe(nil)); end
35
+ def options(options = T.unsafe(nil)); end
36
+ def package_name(name, _ = T.unsafe(nil)); end
37
+ def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
38
+ def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
39
+ def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
40
+ def stop_on_unknown_option!(*command_names); end
41
+ def stop_on_unknown_option?(command); end
42
+ def subcommand(subcommand, subcommand_class); end
43
+ def subcommand_classes; end
44
+ def subcommands; end
45
+ def subtask(subcommand, subcommand_class); end
46
+ def subtasks; end
47
+ def task_help(shell, command_name); end
48
+
49
+ protected
50
+
51
+ def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
52
+ def baseclass; end
53
+ def create_command(meth); end
54
+ def create_task(meth); end
55
+ def disable_required_check; end
56
+ def dispatch(meth, given_args, given_opts, config); end
57
+ def dynamic_command_class; end
58
+ def find_command_possibilities(meth); end
59
+ def find_task_possibilities(meth); end
60
+ def initialize_added; end
61
+ def normalize_command_name(meth); end
62
+ def normalize_task_name(meth); end
63
+ def retrieve_command_name(args); end
64
+ def retrieve_task_name(args); end
65
+ def stop_on_unknown_option; end
66
+ def subcommand_help(cmd); end
67
+ def subtask_help(cmd); end
68
+ end
69
+ end
70
+
71
+ module Thor::Actions
72
+ mixes_in_class_methods(::Thor::Actions::ClassMethods)
73
+
74
+ def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
75
+
76
+ def action(instance); end
77
+ def add_file(destination, *args, &block); end
78
+ def add_link(destination, *args); end
79
+ def append_file(path, *args, &block); end
80
+ def append_to_file(path, *args, &block); end
81
+ def apply(path, config = T.unsafe(nil)); end
82
+ def behavior; end
83
+ def behavior=(_arg0); end
84
+ def chmod(path, mode, config = T.unsafe(nil)); end
85
+ def comment_lines(path, flag, *args); end
86
+ def copy_file(source, *args, &block); end
87
+ def create_file(destination, *args, &block); end
88
+ def create_link(destination, *args); end
89
+ def destination_root; end
90
+ def destination_root=(root); end
91
+ def directory(source, *args, &block); end
92
+ def empty_directory(destination, config = T.unsafe(nil)); end
93
+ def find_in_source_paths(file); end
94
+ def get(source, *args, &block); end
95
+ def gsub_file(path, flag, *args, &block); end
96
+ def in_root; end
97
+ def inject_into_class(path, klass, *args, &block); end
98
+ def inject_into_file(destination, *args, &block); end
99
+ def inject_into_module(path, module_name, *args, &block); end
100
+ def insert_into_file(destination, *args, &block); end
101
+ def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
102
+ def link_file(source, *args); end
103
+ def prepend_file(path, *args, &block); end
104
+ def prepend_to_file(path, *args, &block); end
105
+ def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
106
+ def remove_dir(path, config = T.unsafe(nil)); end
107
+ def remove_file(path, config = T.unsafe(nil)); end
108
+ def run(command, config = T.unsafe(nil)); end
109
+ def run_ruby_script(command, config = T.unsafe(nil)); end
110
+ def source_paths; end
111
+ def template(source, *args, &block); end
112
+ def thor(command, *args); end
113
+ def uncomment_lines(path, flag, *args); end
114
+
115
+ protected
116
+
117
+ def _cleanup_options_and_set(options, key); end
118
+ def _shared_configuration; end
119
+
120
+ private
121
+
122
+ def capture(*args); end
123
+ def concat(string); end
124
+ def output_buffer; end
125
+ def output_buffer=(_arg0); end
126
+ def with_output_buffer(buf = T.unsafe(nil)); end
127
+
128
+ class << self
129
+ def included(base); end
130
+ end
131
+ end
132
+
133
+ class Thor::Actions::CapturableERB < ::ERB
134
+ def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
135
+ end
136
+
137
+ module Thor::Actions::ClassMethods
138
+ def add_runtime_options!; end
139
+ def source_paths; end
140
+ def source_paths_for_search; end
141
+ def source_root(path = T.unsafe(nil)); end
142
+ end
143
+
144
+ class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
145
+ def initialize(base, destination, data, config = T.unsafe(nil)); end
146
+
147
+ def data; end
148
+ def identical?; end
149
+ def invoke!; end
150
+ def render; end
151
+
152
+ protected
153
+
154
+ def force_on_collision?; end
155
+ def force_or_skip_or_conflict(force, skip, &block); end
156
+ def on_conflict_behavior(&block); end
157
+ end
158
+
159
+ class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
160
+ def data; end
161
+ def exists?; end
162
+ def identical?; end
163
+ def invoke!; end
164
+ end
165
+
166
+ class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
167
+ def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
168
+
169
+ def invoke!; end
170
+ def revoke!; end
171
+ def source; end
172
+
173
+ protected
174
+
175
+ def execute!; end
176
+ def file_level_lookup(previous_lookup); end
177
+ def files(lookup); end
178
+ end
179
+
180
+ class Thor::Actions::EmptyDirectory
181
+ def initialize(base, destination, config = T.unsafe(nil)); end
182
+
183
+ def base; end
184
+ def config; end
185
+ def destination; end
186
+ def exists?; end
187
+ def given_destination; end
188
+ def invoke!; end
189
+ def relative_destination; end
190
+ def revoke!; end
191
+
192
+ protected
193
+
194
+ def convert_encoded_instructions(filename); end
195
+ def destination=(destination); end
196
+ def invoke_with_conflict_check(&block); end
197
+ def on_conflict_behavior; end
198
+ def on_file_clash_behavior; end
199
+ def pretend?; end
200
+ def say_status(status, color); end
201
+ end
202
+
203
+ class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
204
+ def initialize(base, destination, data, config); end
205
+
206
+ def behavior; end
207
+ def flag; end
208
+ def invoke!; end
209
+ def replacement; end
210
+ def revoke!; end
211
+
212
+ protected
213
+
214
+ def replace!(regexp, string, force); end
215
+ def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
216
+ end
217
+
218
+ Thor::Actions::WARNINGS = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
219
+
220
+ class Thor::AmbiguousCommandError < ::Thor::Error
221
+ end
222
+
223
+ Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
224
+
225
+ class Thor::Argument
226
+ def initialize(name, options = T.unsafe(nil)); end
227
+
228
+ def banner; end
229
+ def default; end
230
+ def description; end
231
+ def enum; end
232
+ def human_name; end
233
+ def name; end
234
+ def required; end
235
+ def required?; end
236
+ def show_default?; end
237
+ def type; end
238
+ def usage; end
239
+
240
+ protected
241
+
242
+ def default_banner; end
243
+ def valid_type?(type); end
244
+ def validate!; end
245
+ end
246
+
247
+ Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), T::Array[T.untyped])
248
+
249
+ class Thor::Arguments
250
+ def initialize(arguments = T.unsafe(nil)); end
251
+
252
+ def parse(args); end
253
+ def remaining; end
254
+
255
+ private
256
+
257
+ def check_requirement!; end
258
+ def current_is_value?; end
259
+ def last?; end
260
+ def no_or_skip?(arg); end
261
+ def parse_array(name); end
262
+ def parse_hash(name); end
263
+ def parse_numeric(name); end
264
+ def parse_string(name); end
265
+ def peek; end
266
+ def shift; end
267
+ def unshift(arg); end
268
+
269
+ class << self
270
+ def parse(*args); end
271
+ def split(args); end
272
+ end
273
+ end
274
+
275
+ Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
276
+
277
+ module Thor::Base
278
+ include(::Thor::Invocation)
279
+ include(::Thor::Shell)
280
+
281
+ mixes_in_class_methods(::Thor::Base::ClassMethods)
282
+
283
+ def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
284
+
285
+ def args; end
286
+ def args=(_arg0); end
287
+ def options; end
288
+ def options=(_arg0); end
289
+ def parent_options; end
290
+ def parent_options=(_arg0); end
291
+
292
+ class << self
293
+ def included(base); end
294
+ def register_klass_file(klass); end
295
+ def shell; end
296
+ def shell=(_arg0); end
297
+ def subclass_files; end
298
+ def subclasses; end
299
+ end
300
+ end
301
+
302
+ module Thor::Base::ClassMethods
303
+ def all_commands; end
304
+ def all_tasks; end
305
+ def allow_incompatible_default_type!; end
306
+ def argument(name, options = T.unsafe(nil)); end
307
+ def arguments; end
308
+ def attr_accessor(*_arg0); end
309
+ def attr_reader(*_arg0); end
310
+ def attr_writer(*_arg0); end
311
+ def check_default_type; end
312
+ def check_default_type!; end
313
+ def check_unknown_options; end
314
+ def check_unknown_options!; end
315
+ def check_unknown_options?(config); end
316
+ def class_option(name, options = T.unsafe(nil)); end
317
+ def class_options(options = T.unsafe(nil)); end
318
+ def commands; end
319
+ def disable_required_check?(command_name); end
320
+ def exit_on_failure?; end
321
+ def group(name = T.unsafe(nil)); end
322
+ def handle_argument_error(command, error, args, arity); end
323
+ def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
324
+ def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
325
+ def namespace(name = T.unsafe(nil)); end
326
+ def no_commands(&block); end
327
+ def no_commands?; end
328
+ def no_commands_context; end
329
+ def no_tasks(&block); end
330
+ def public_command(*names); end
331
+ def public_task(*names); end
332
+ def remove_argument(*names); end
333
+ def remove_class_option(*names); end
334
+ def remove_command(*names); end
335
+ def remove_task(*names); end
336
+ def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
337
+ def stop_on_unknown_option?(command_name); end
338
+ def strict_args_position; end
339
+ def strict_args_position!; end
340
+ def strict_args_position?(config); end
341
+ def tasks; end
342
+
343
+ protected
344
+
345
+ def baseclass; end
346
+ def basename; end
347
+ def build_option(name, options, scope); end
348
+ def build_options(options, scope); end
349
+ def class_options_help(shell, groups = T.unsafe(nil)); end
350
+ def create_command(meth); end
351
+ def create_task(meth); end
352
+ def dispatch(command, given_args, given_opts, config); end
353
+ def find_and_refresh_command(name); end
354
+ def find_and_refresh_task(name); end
355
+ def from_superclass(method, default = T.unsafe(nil)); end
356
+ def inherited(klass); end
357
+ def initialize_added; end
358
+ def is_thor_reserved_word?(word, type); end
359
+ def method_added(meth); end
360
+ def print_options(shell, options, group_name = T.unsafe(nil)); end
361
+ end
362
+
363
+ class Thor::Command < ::Struct
364
+ Elem = type_member {{fixed: T.untyped}}
365
+
366
+ def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end
367
+
368
+ def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
369
+ def hidden?; end
370
+ def run(instance, args = T.unsafe(nil)); end
371
+
372
+ protected
373
+
374
+ def handle_argument_error?(instance, error, caller); end
375
+ def handle_no_method_error?(instance, error, caller); end
376
+ def local_method?(instance, name); end
377
+ def not_debugging?(instance); end
378
+ def private_method?(instance); end
379
+ def public_method?(instance); end
380
+ def required_arguments_for(klass, usage); end
381
+ def required_options; end
382
+ def sans_backtrace(backtrace, caller); end
383
+
384
+ private
385
+
386
+ def initialize_copy(other); end
387
+ end
388
+
389
+ Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
390
+
391
+ module Thor::CoreExt
392
+ end
393
+
394
+ class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
395
+ K = type_member {{fixed: T.untyped}}
396
+ V = type_member {{fixed: T.untyped}}
397
+ Elem = type_member {{fixed: T.untyped}}
398
+
399
+ def initialize(hash = T.unsafe(nil)); end
400
+
401
+ def [](key); end
402
+ def []=(key, value); end
403
+ def delete(key); end
404
+ def fetch(key, *args); end
405
+ def key?(key); end
406
+ def merge(other); end
407
+ def merge!(other); end
408
+ def replace(other_hash); end
409
+ def reverse_merge(other); end
410
+ def reverse_merge!(other_hash); end
411
+ def to_hash; end
412
+ def values_at(*indices); end
413
+
414
+ protected
415
+
416
+ def convert_key(key); end
417
+ def method_missing(method, *args); end
418
+ end
419
+
420
+ Thor::Correctable = DidYouMean::Correctable
421
+
422
+ class Thor::DynamicCommand < ::Thor::Command
423
+ Elem = type_member {{fixed: T.untyped}}
424
+
425
+ def initialize(name, options = T.unsafe(nil)); end
426
+
427
+ def run(instance, args = T.unsafe(nil)); end
428
+ end
429
+
430
+ Thor::DynamicTask = Thor::DynamicCommand
431
+
432
+ class Thor::Error < ::StandardError
433
+ end
434
+
435
+ class Thor::Group
436
+ include(::Thor::Base)
437
+ include(::Thor::Invocation)
438
+ include(::Thor::Shell)
439
+ extend(::Thor::Base::ClassMethods)
440
+ extend(::Thor::Invocation::ClassMethods)
441
+
442
+
443
+ protected
444
+
445
+ def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
446
+
447
+ class << self
448
+ def class_options_help(shell, groups = T.unsafe(nil)); end
449
+ def desc(description = T.unsafe(nil)); end
450
+ def get_options_from_invocations(group_options, base_options); end
451
+ def handle_argument_error(command, error, _args, arity); end
452
+ def help(shell); end
453
+ def invocation_blocks; end
454
+ def invocations; end
455
+ def invoke(*names, &block); end
456
+ def invoke_from_option(*names, &block); end
457
+ def printable_commands(*_arg0); end
458
+ def printable_tasks(*_arg0); end
459
+ def remove_invocation(*names); end
460
+
461
+ protected
462
+
463
+ def banner; end
464
+ def baseclass; end
465
+ def create_command(meth); end
466
+ def create_task(meth); end
467
+ def dispatch(command, given_args, given_opts, config); end
468
+ def self_command; end
469
+ def self_task; end
470
+ end
471
+ end
472
+
473
+ Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), T::Array[T.untyped])
474
+
475
+ class Thor::HiddenCommand < ::Thor::Command
476
+ Elem = type_member {{fixed: T.untyped}}
477
+
478
+ def hidden?; end
479
+ end
480
+
481
+ Thor::HiddenTask = Thor::HiddenCommand
482
+
483
+ module Thor::Invocation
484
+ mixes_in_class_methods(::Thor::Invocation::ClassMethods)
485
+
486
+ def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
487
+
488
+ def current_command_chain; end
489
+ def invoke(name = T.unsafe(nil), *args); end
490
+ def invoke_all; end
491
+ def invoke_command(command, *args); end
492
+ def invoke_task(command, *args); end
493
+ def invoke_with_padding(*args); end
494
+
495
+ protected
496
+
497
+ def _parse_initialization_options(args, opts, config); end
498
+ def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
499
+ def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
500
+ def _shared_configuration; end
501
+
502
+ class << self
503
+ def included(base); end
504
+ end
505
+ end
506
+
507
+ module Thor::Invocation::ClassMethods
508
+ def prepare_for_invocation(key, name); end
509
+ end
510
+
511
+ class Thor::InvocationError < ::Thor::Error
512
+ end
513
+
514
+ module Thor::LineEditor
515
+ class << self
516
+ def best_available; end
517
+ def readline(prompt, options = T.unsafe(nil)); end
518
+ end
519
+ end
520
+
521
+ class Thor::LineEditor::Basic
522
+ def initialize(prompt, options); end
523
+
524
+ def options; end
525
+ def prompt; end
526
+ def readline; end
527
+
528
+ private
529
+
530
+ def echo?; end
531
+ def get_input; end
532
+
533
+ class << self
534
+ def available?; end
535
+ end
536
+ end
537
+
538
+ class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
539
+ def readline; end
540
+
541
+ private
542
+
543
+ def add_to_history?; end
544
+ def completion_options; end
545
+ def completion_proc; end
546
+ def use_path_completion?; end
547
+
548
+ class << self
549
+ def available?; end
550
+ end
551
+ end
552
+
553
+ class Thor::LineEditor::Readline::PathCompletion
554
+ def initialize(text); end
555
+
556
+ def matches; end
557
+
558
+ private
559
+
560
+ def absolute_matches; end
561
+ def base_path; end
562
+ def glob_pattern; end
563
+ def relative_matches; end
564
+ def text; end
565
+ end
566
+
567
+ class Thor::MalformattedArgumentError < ::Thor::InvocationError
568
+ end
569
+
570
+ class Thor::NestedContext
571
+ def initialize; end
572
+
573
+ def enter; end
574
+ def entered?; end
575
+
576
+ private
577
+
578
+ def pop; end
579
+ def push; end
580
+ end
581
+
582
+ class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
583
+ def initialize(dictionary); end
584
+ end
585
+
586
+ class Thor::Option < ::Thor::Argument
587
+ def initialize(name, options = T.unsafe(nil)); end
588
+
589
+ def aliases; end
590
+ def array?; end
591
+ def boolean?; end
592
+ def group; end
593
+ def hash?; end
594
+ def hide; end
595
+ def human_name; end
596
+ def lazy_default; end
597
+ def numeric?; end
598
+ def repeatable; end
599
+ def string?; end
600
+ def switch_name; end
601
+ def usage(padding = T.unsafe(nil)); end
602
+
603
+ protected
604
+
605
+ def dasherize(str); end
606
+ def dasherized?; end
607
+ def undasherize(str); end
608
+ def validate!; end
609
+ def validate_default_type!; end
610
+
611
+ class << self
612
+ def parse(key, value); end
613
+ end
614
+ end
615
+
616
+ Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), T::Array[T.untyped])
617
+
618
+ class Thor::Options < ::Thor::Arguments
619
+ def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end
620
+
621
+ def check_unknown!; end
622
+ def parse(args); end
623
+ def peek; end
624
+ def remaining; end
625
+
626
+ protected
627
+
628
+ def assign_result!(option, result); end
629
+ def current_is_switch?; end
630
+ def current_is_switch_formatted?; end
631
+ def current_is_value?; end
632
+ def normalize_switch(arg); end
633
+ def parse_boolean(switch); end
634
+ def parse_peek(switch, option); end
635
+ def parsing_options?; end
636
+ def switch?(arg); end
637
+ def switch_option(arg); end
638
+
639
+ class << self
640
+ def to_switches(options); end
641
+ end
642
+ end
643
+
644
+ Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
645
+
646
+ Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
647
+
648
+ Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
649
+
650
+ Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
651
+
652
+ Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
653
+
654
+ Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
655
+
656
+ module Thor::RakeCompat
657
+ include(::FileUtils::StreamUtils_)
658
+ include(::FileUtils)
659
+ # include(::Rake::FileUtilsExt)
660
+ # include(::Rake::DSL)
661
+
662
+ class << self
663
+ def included(base); end
664
+ def rake_classes; end
665
+ end
666
+ end
667
+
668
+ class Thor::RequiredArgumentMissingError < ::Thor::InvocationError
669
+ end
670
+
671
+ module Thor::Sandbox
672
+ end
673
+
674
+ module Thor::Shell
675
+ def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
676
+
677
+ def ask(*args, &block); end
678
+ def error(*args, &block); end
679
+ def file_collision(*args, &block); end
680
+ def no?(*args, &block); end
681
+ def print_in_columns(*args, &block); end
682
+ def print_table(*args, &block); end
683
+ def print_wrapped(*args, &block); end
684
+ def say(*args, &block); end
685
+ def say_status(*args, &block); end
686
+ def set_color(*args, &block); end
687
+ def shell; end
688
+ def shell=(_arg0); end
689
+ def terminal_width(*args, &block); end
690
+ def with_padding; end
691
+ def yes?(*args, &block); end
692
+
693
+ protected
694
+
695
+ def _shared_configuration; end
696
+ end
697
+
698
+ class Thor::Shell::Basic
699
+ def initialize; end
700
+
701
+ def ask(statement, *args); end
702
+ def base; end
703
+ def base=(_arg0); end
704
+ def error(statement); end
705
+ def file_collision(destination); end
706
+ def indent(count = T.unsafe(nil)); end
707
+ def mute; end
708
+ def mute?; end
709
+ def no?(statement, color = T.unsafe(nil)); end
710
+ def padding; end
711
+ def padding=(value); end
712
+ def print_in_columns(array); end
713
+ def print_table(array, options = T.unsafe(nil)); end
714
+ def print_wrapped(message, options = T.unsafe(nil)); end
715
+ def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
716
+ def say_status(status, message, log_status = T.unsafe(nil)); end
717
+ def set_color(string, *_arg1); end
718
+ def terminal_width; end
719
+ def yes?(statement, color = T.unsafe(nil)); end
720
+
721
+ protected
722
+
723
+ def answer_match(possibilities, answer, case_insensitive); end
724
+ def as_unicode; end
725
+ def ask_filtered(statement, color, options); end
726
+ def ask_simply(statement, color, options); end
727
+ def can_display_colors?; end
728
+ def dynamic_width; end
729
+ def dynamic_width_stty; end
730
+ def dynamic_width_tput; end
731
+ def file_collision_help; end
732
+ def git_merge_tool; end
733
+ def is?(value); end
734
+ def lookup_color(color); end
735
+ def merge(destination, content); end
736
+ def merge_tool; end
737
+ def prepare_message(message, *color); end
738
+ def quiet?; end
739
+ def show_diff(destination, content); end
740
+ def stderr; end
741
+ def stdout; end
742
+ def truncate(string, width); end
743
+ def unix?; end
744
+ end
745
+
746
+ Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
747
+
748
+ class Thor::Shell::Color < ::Thor::Shell::Basic
749
+ def set_color(string, *colors); end
750
+
751
+ protected
752
+
753
+ def are_colors_disabled?; end
754
+ def can_display_colors?; end
755
+ def diff_lcs_loaded?; end
756
+ def output_diff_line(diff); end
757
+ def show_diff(destination, content); end
758
+ end
759
+
760
+ Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
761
+
762
+ Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
763
+
764
+ Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
765
+
766
+ Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
767
+
768
+ Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
769
+
770
+ Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
771
+
772
+ Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
773
+
774
+ Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
775
+
776
+ Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
777
+
778
+ Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
779
+
780
+ Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
781
+
782
+ Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
783
+
784
+ Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
785
+
786
+ Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
787
+
788
+ Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
789
+
790
+ Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
791
+
792
+ Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
793
+
794
+ Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
795
+
796
+ class Thor::Shell::HTML < ::Thor::Shell::Basic
797
+ def ask(statement, color = T.unsafe(nil)); end
798
+ def set_color(string, *colors); end
799
+
800
+ protected
801
+
802
+ def can_display_colors?; end
803
+ def diff_lcs_loaded?; end
804
+ def output_diff_line(diff); end
805
+ def show_diff(destination, content); end
806
+ end
807
+
808
+ Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
809
+
810
+ Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
811
+
812
+ Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
813
+
814
+ Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
815
+
816
+ Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
817
+
818
+ Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
819
+
820
+ Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
821
+
822
+ Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
823
+
824
+ Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
825
+
826
+ Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
827
+
828
+ Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
829
+
830
+ Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
831
+
832
+ Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
833
+
834
+ Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
835
+
836
+ Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
837
+
838
+ Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
839
+
840
+ Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
841
+
842
+ Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), T::Array[T.untyped])
843
+
844
+ Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
845
+
846
+ Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), T::Array[T.untyped])
847
+
848
+ Thor::Task = Thor::Command
849
+
850
+ class Thor::UndefinedCommandError < ::Thor::Error
851
+ include(::DidYouMean::Correctable)
852
+
853
+ def initialize(command, all_commands, namespace); end
854
+
855
+ def all_commands; end
856
+ def command; end
857
+ end
858
+
859
+ class Thor::UndefinedCommandError::SpellChecker
860
+ def initialize(error); end
861
+
862
+ def corrections; end
863
+ def error; end
864
+ def spell_checker; end
865
+ end
866
+
867
+ Thor::UndefinedTaskError = Thor::UndefinedCommandError
868
+
869
+ class Thor::UnknownArgumentError < ::Thor::Error
870
+ include(::DidYouMean::Correctable)
871
+
872
+ def initialize(switches, unknown); end
873
+
874
+ def switches; end
875
+ def unknown; end
876
+ end
877
+
878
+ class Thor::UnknownArgumentError::SpellChecker
879
+ def initialize(error); end
880
+
881
+ def corrections; end
882
+ def error; end
883
+ def spell_checker; end
884
+ end
885
+
886
+ module Thor::Util
887
+ class << self
888
+ def camel_case(str); end
889
+ def escape_globs(path); end
890
+ def escape_html(string); end
891
+ def find_by_namespace(namespace); end
892
+ def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
893
+ def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
894
+ def globs_for(path); end
895
+ def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
896
+ def namespace_from_thor_class(constant); end
897
+ def namespaces_in_content(contents, file = T.unsafe(nil)); end
898
+ def ruby_command; end
899
+ def snake_case(str); end
900
+ def thor_classes_in(klass); end
901
+ def thor_root; end
902
+ def thor_root_glob; end
903
+ def user_home; end
904
+ end
905
+ end