gum 0.3.0-arm64-linux

data/sig/gum/commands/choose.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/gum/commands/choose.rb with RBS::Inline
+
+module Gum
+  # Choose an option from a list of choices
+  #
+  # @example Single selection with array
+  #   color = Gum.choose(%w[red green blue])
+  #
+  # @example Single selection with splat
+  #   color = Gum.choose("red", "green", "blue")
+  #
+  # @example Multiple selection
+  #   colors = Gum.choose(%w[red green blue], limit: 2)
+  #
+  # @example Unlimited selection
+  #   colors = Gum.choose(%w[red green blue], no_limit: true)
+  #
+  # @example With header and custom height
+  #   choice = Gum.choose(options, header: "Pick one:", height: 10)
+  class Choose
+    # Choose from a list of options
+    #
+    # @rbs *items: Array[String] | String -- list of choices to display (array or splat)
+    # @rbs limit: Integer? -- maximum number of items that can be selected (1 = single select)
+    # @rbs no_limit: bool -- allow unlimited selections (use tab/ctrl+space to select)
+    # @rbs ordered: bool? -- maintain selection order
+    # @rbs height: Integer? -- height of the list
+    # @rbs cursor: String? -- cursor character (default: ">")
+    # @rbs header: String? -- header text displayed above choices
+    # @rbs cursor_prefix: String? -- prefix for the cursor line
+    # @rbs selected_prefix: String? -- prefix for selected items (default: "✓")
+    # @rbs unselected_prefix: String? -- prefix for unselected items (default: "○")
+    # @rbs selected: Array[String]? -- items to pre-select
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor_style: Hash[Symbol, untyped]? -- cursor style options
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style
+    # @rbs item_style: Hash[Symbol, untyped]? -- item text style
+    # @rbs selected_style: Hash[Symbol, untyped]? -- selected item style
+    # @rbs return: String | Array[String] | nil -- selected item(s), or nil if cancelled
+    def self.call: (*Array[String] | String items, ?limit: Integer?, ?no_limit: bool, ?ordered: bool?, ?height: Integer?, ?cursor: String?, ?header: String?, ?cursor_prefix: String?, ?selected_prefix: String?, ?unselected_prefix: String?, ?selected: Array[String]?, ?timeout: Integer?, ?cursor_style: Hash[Symbol, untyped]?, ?header_style: Hash[Symbol, untyped]?, ?item_style: Hash[Symbol, untyped]?, ?selected_style: Hash[Symbol, untyped]?) -> (String | Array[String] | nil)
+  end
+end

data/sig/gum/commands/confirm.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/gum/commands/confirm.rb with RBS::Inline
+
+module Gum
+  # Ask for user confirmation
+  #
+  # @example Basic confirmation
+  #   if Gum.confirm("Delete file?")
+  #     File.delete(path)
+  #   end
+  #
+  # @example With default value
+  #   proceed = Gum.confirm("Continue?", default: true)
+  #
+  # @example With custom button labels
+  #   Gum.confirm("Save changes?", affirmative: "Save", negative: "Discard")
+  class Confirm
+    # Prompt for yes/no confirmation
+    #
+    # @rbs prompt: String -- the confirmation prompt
+    # @rbs default: bool? -- default value (true = yes, false = no)
+    # @rbs affirmative: String? -- text for affirmative button (default: "Yes")
+    # @rbs negative: String? -- text for negative button (default: "No")
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style options
+    # @rbs selected_style: Hash[Symbol, untyped]? -- selected button style options
+    # @rbs unselected_style: Hash[Symbol, untyped]? -- unselected button style options
+    # @rbs return: bool -- true if confirmed, false if rejected
+    def self.call: (?String prompt, ?default: bool?, ?affirmative: String?, ?negative: String?, ?timeout: Integer?, ?prompt_style: Hash[Symbol, untyped]?, ?selected_style: Hash[Symbol, untyped]?, ?unselected_style: Hash[Symbol, untyped]?) -> bool
+  end
+end

data/sig/gum/commands/file.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/gum/commands/file.rb with RBS::Inline
+
+module Gum
+  # Pick a file from a folder
+  #
+  # @example Basic file picker
+  #   path = Gum.file
+  #
+  # @example Start from specific directory
+  #   path = Gum.file(directory: "~/Documents")
+  #
+  # @example Show hidden files
+  #   path = Gum.file(all: true)
+  #
+  # @example Only show directories
+  #   dir = Gum.file(directory_only: true)
+  class FilePicker
+    # Pick a file from the filesystem
+    #
+    # @rbs path: String? -- starting directory path
+    # @rbs cursor: String? -- cursor character
+    # @rbs all: bool? -- show hidden files and directories
+    # @rbs file: bool? -- allow file selection (default: true)
+    # @rbs directory: bool? -- allow directory selection (default: false)
+    # @rbs directory_only: bool -- only allow directory selection (convenience option)
+    # @rbs height: Integer? -- height of the file picker
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor_style: Hash[Symbol, untyped]? -- cursor style options
+    # @rbs symlink_style: Hash[Symbol, untyped]? -- symlink text style
+    # @rbs directory_style: Hash[Symbol, untyped]? -- directory text style
+    # @rbs file_style: Hash[Symbol, untyped]? -- file text style
+    # @rbs permissions_style: Hash[Symbol, untyped]? -- permissions text style
+    # @rbs selected_style: Hash[Symbol, untyped]? -- selected item style
+    # @rbs file_size_style: Hash[Symbol, untyped]? -- file size text style
+    # @rbs return: String? -- selected file path, or nil if cancelled
+    def self.call: (?String? path, ?cursor: String?, ?all: bool?, ?file: bool?, ?directory: bool?, ?directory_only: bool, ?height: Integer?, ?timeout: Integer?, ?cursor_style: Hash[Symbol, untyped]?, ?symlink_style: Hash[Symbol, untyped]?, ?directory_style: Hash[Symbol, untyped]?, ?file_style: Hash[Symbol, untyped]?, ?permissions_style: Hash[Symbol, untyped]?, ?selected_style: Hash[Symbol, untyped]?, ?file_size_style: Hash[Symbol, untyped]?) -> String?
+  end
+end

data/sig/gum/commands/filter.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/gum/commands/filter.rb with RBS::Inline
+
+module Gum
+  # Filter items from a list with fuzzy matching
+  #
+  # @example Single selection filter with array
+  #   file = Gum.filter(Dir.glob("*"))
+  #
+  # @example Single selection filter with splat
+  #   file = Gum.filter("file1.rb", "file2.rb", "file3.rb")
+  #
+  # @example Multiple selection filter
+  #   files = Gum.filter(Dir.glob("*"), limit: 5)
+  #
+  # @example With placeholder and height
+  #   selection = Gum.filter(items, placeholder: "Search...", height: 20)
+  class Filter
+    # Filter a list with fuzzy matching
+    #
+    # @rbs *items: Array[String] | String -- list of items to filter (array or splat)
+    # @rbs limit: Integer? -- maximum number of items that can be selected
+    # @rbs no_limit: bool -- allow unlimited selections (use tab/ctrl+space to select)
+    # @rbs height: Integer? -- height of the list
+    # @rbs width: Integer? -- width of the filter input
+    # @rbs placeholder: String? -- placeholder text for the filter input
+    # @rbs prompt: String? -- prompt string shown before input
+    # @rbs value: String? -- initial filter value
+    # @rbs header: String? -- header text displayed above the list
+    # @rbs indicator: String? -- character for selected item indicator
+    # @rbs selected_prefix: String? -- prefix for selected items
+    # @rbs unselected_prefix: String? -- prefix for unselected items
+    # @rbs match_prefix: String? -- prefix for matched text
+    # @rbs fuzzy: bool? -- enable fuzzy matching (default: true)
+    # @rbs sort: bool? -- sort results by match score (default: true)
+    # @rbs strict: bool? -- require exact match
+    # @rbs reverse: bool? -- reverse the order of results
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style
+    # @rbs text_style: Hash[Symbol, untyped]? -- text style for items
+    # @rbs cursor_text_style: Hash[Symbol, untyped]? -- style for cursor line text
+    # @rbs match_style: Hash[Symbol, untyped]? -- style for matched characters
+    # @rbs placeholder_style: Hash[Symbol, untyped]? -- placeholder text style
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style
+    # @rbs indicator_style: Hash[Symbol, untyped]? -- indicator character style
+    # @rbs return: String | Array[String] | nil -- selected item(s), or nil if cancelled
+    def self.call: (*Array[String] | String items, ?limit: Integer?, ?no_limit: bool, ?height: Integer?, ?width: Integer?, ?placeholder: String?, ?prompt: String?, ?value: String?, ?header: String?, ?indicator: String?, ?selected_prefix: String?, ?unselected_prefix: String?, ?match_prefix: String?, ?fuzzy: bool?, ?sort: bool?, ?strict: bool?, ?reverse: bool?, ?timeout: Integer?, ?header_style: Hash[Symbol, untyped]?, ?text_style: Hash[Symbol, untyped]?, ?cursor_text_style: Hash[Symbol, untyped]?, ?match_style: Hash[Symbol, untyped]?, ?placeholder_style: Hash[Symbol, untyped]?, ?prompt_style: Hash[Symbol, untyped]?, ?indicator_style: Hash[Symbol, untyped]?) -> (String | Array[String] | nil)
+  end
+end

data/sig/gum/commands/format.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/gum/commands/format.rb with RBS::Inline
+
+module Gum
+  # Format text with markdown, code highlighting, templates, or emojis
+  #
+  # @example Markdown formatting
+  #   Gum.format("# Hello\n- Item 1\n- Item 2")
+  #
+  # @example Code highlighting
+  #   Gum.format(code, type: :code, language: "ruby")
+  #
+  # @example Template formatting
+  #   Gum.format('{{ Bold "Hello" }} {{ Color "99" "0" " World " }}', type: :template)
+  #
+  # @example Emoji formatting
+  #   Gum.format("I :heart: Ruby :gem:", type: :emoji)
+  class Format
+    TYPES: Array[Symbol]
+
+    # Format and render text
+    #
+    # @rbs *text: String -- text content to format (multiple strings joined with newlines)
+    # @rbs type: Symbol | String | nil -- format type (:markdown, :code, :template, :emoji)
+    # @rbs language: String? -- programming language for code highlighting
+    # @rbs theme: String? -- syntax highlighting theme
+    # @rbs return: String? -- formatted text output
+    def self.call: (*String text, ?type: Symbol | String | nil, ?language: String?, ?theme: String?) -> String?
+
+    # @rbs text: String -- markdown text to format
+    # @rbs return: String? -- rendered markdown output
+    def self.markdown: (String text) -> String?
+
+    # @rbs text: String -- source code to highlight
+    # @rbs language: String? -- programming language for highlighting
+    # @rbs theme: String? -- syntax highlighting theme
+    # @rbs return: String? -- syntax-highlighted code output
+    def self.code: (String text, ?language: String?, ?theme: String?) -> String?
+
+    # @rbs text: String -- template string with Termenv helpers
+    # @rbs return: String? -- rendered template output
+    def self.template: (String text) -> String?
+
+    # @rbs text: String -- text with :emoji_name: codes
+    # @rbs return: String? -- text with emojis rendered
+    def self.emoji: (String text) -> String?
+  end
+end

data/sig/gum/commands/input.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/gum/commands/input.rb with RBS::Inline
+
+module Gum
+  # Prompt for single-line input
+  #
+  # @example Basic input
+  #   name = Gum.input(placeholder: "Enter your name")
+  #
+  # @example Password input
+  #   password = Gum.input(password: true)
+  #
+  # @example With default value and custom prompt
+  #   email = Gum.input(value: "user@", prompt: "> ", placeholder: "email")
+  class Input
+    # Prompt for single-line input
+    #
+    # @rbs placeholder: String? -- placeholder text shown when input is empty
+    # @rbs prompt: String? -- prompt string shown before input
+    # @rbs value: String? -- initial value for the input
+    # @rbs char_limit: Integer? -- maximum number of characters allowed
+    # @rbs width: Integer? -- width of the input field
+    # @rbs password: bool -- mask input characters for password entry
+    # @rbs header: String? -- header text displayed above the input
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor: Hash[Symbol, untyped]? -- cursor style options (foreground, background)
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style options
+    # @rbs placeholder_style: Hash[Symbol, untyped]? -- placeholder text style options
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style options
+    # @rbs return: String? -- the entered text, or nil if cancelled
+    def self.call: (?placeholder: String?, ?prompt: String?, ?value: String?, ?char_limit: Integer?, ?width: Integer?, ?password: bool, ?header: String?, ?timeout: Integer?, ?cursor: Hash[Symbol, untyped]?, ?prompt_style: Hash[Symbol, untyped]?, ?placeholder_style: Hash[Symbol, untyped]?, ?header_style: Hash[Symbol, untyped]?) -> String?
+  end
+end

data/sig/gum/commands/join.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/gum/commands/join.rb with RBS::Inline
+
+module Gum
+  # Join text blocks horizontally or vertically
+  #
+  # @example Horizontal join (default)
+  #   combined = Gum.join(box1, box2)
+  #
+  # @example Vertical join
+  #   stacked = Gum.join(box1, box2, vertical: true)
+  #
+  # @example With alignment
+  #   aligned = Gum.join(box1, box2, vertical: true, align: :center)
+  class Join
+    # Join text blocks together
+    #
+    # @rbs *texts: String -- text blocks to join (usually styled with Gum.style)
+    # @rbs vertical: bool -- stack blocks vertically (default: false, horizontal)
+    # @rbs horizontal: bool -- place blocks side by side (default)
+    # @rbs align: Symbol | String | nil -- alignment (:left, :center, :right for vertical; :top, :middle, :bottom for horizontal)
+    # @rbs return: String? -- combined text output
+    def self.call: (*String texts, ?vertical: bool, ?horizontal: bool, ?align: Symbol | String | nil) -> String?
+  end
+end

data/sig/gum/commands/log.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/gum/commands/log.rb with RBS::Inline
+
+module Gum
+  # Log messages with different levels and formatting
+  #
+  # @example Basic logging
+  #   Gum.log("Application started", level: :info)
+  #
+  # @example Structured logging with key-value pairs
+  #   Gum.log("User created", level: :info, user_id: 123, email: "user@example.com")
+  #
+  # @example With timestamp
+  #   Gum.log("Error occurred", level: :error, time: :rfc822)
+  class Log
+    LEVELS: Array[Symbol]
+
+    TIME_FORMATS: Array[Symbol]
+
+    # Log a message
+    #
+    # @rbs message: String -- log message text
+    # @rbs level: Symbol | String | nil -- log level (:debug, :info, :warn, :error, :fatal, :none)
+    # @rbs time: Symbol | String | nil -- time format (:rfc822, :rfc3339, :kitchen, etc.) or custom Go time format
+    # @rbs structured: bool? -- output structured log format (key=value pairs)
+    # @rbs formatter: Symbol | String | nil -- log formatter (:text, :json, :logfmt)
+    # @rbs prefix: String? -- log message prefix
+    # @rbs **fields: untyped -- additional key-value fields for structured logging
+    # @rbs return: String? -- formatted log output
+    def self.call: (String message, ?level: Symbol | String | nil, ?time: Symbol | String | nil, ?structured: bool?, ?formatter: Symbol | String | nil, ?prefix: String?, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted debug log output
+    def self.debug: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted info log output
+    def self.info: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted warn log output
+    def self.warn: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted error log output
+    def self.error: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted fatal log output
+    def self.fatal: (String message, **untyped fields) -> String?
+  end
+end

data/sig/gum/commands/pager.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/gum/commands/pager.rb with RBS::Inline
+
+module Gum
+  # Scroll through content in a pager
+  #
+  # @example View file content
+  #   Gum.pager(File.read("README.md"))
+  #
+  # @example With line numbers
+  #   Gum.pager(content, show_line_numbers: true)
+  #
+  # @example Soft wrap long lines
+  #   Gum.pager(content, soft_wrap: true)
+  class Pager
+    # Display content in a scrollable pager
+    #
+    # @rbs content: String -- content to display in the pager
+    # @rbs show_line_numbers: bool? -- display line numbers
+    # @rbs soft_wrap: bool? -- wrap long lines instead of horizontal scrolling
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs help_style: Hash[Symbol, untyped]? -- help text style
+    # @rbs line_number_style: Hash[Symbol, untyped]? -- line number style
+    # @rbs match_style: Hash[Symbol, untyped]? -- search match style
+    # @rbs match_highlight_style: Hash[Symbol, untyped]? -- current search match highlight style
+    # @rbs return: void
+    def self.call: (String content, ?show_line_numbers: bool?, ?soft_wrap: bool?, ?timeout: Integer?, ?help_style: Hash[Symbol, untyped]?, ?line_number_style: Hash[Symbol, untyped]?, ?match_style: Hash[Symbol, untyped]?, ?match_highlight_style: Hash[Symbol, untyped]?) -> void
+  end
+end

data/sig/gum/commands/spin.rbs

@@ -0,0 +1,55 @@
+# Generated from lib/gum/commands/spin.rb with RBS::Inline
+
+module Gum
+  # Display a spinner while running a command or block
+  #
+  # @example With shell command
+  #   Gum.spin("Installing...", command: "npm install")
+  #
+  # @example With Ruby block
+  #   result = Gum.spin("Processing...") do
+  #     # long running operation
+  #     expensive_computation
+  #   end
+  #
+  # @example Custom spinner type
+  #   Gum.spin("Loading...", spinner: :dot, command: "sleep 5")
+  class Spin
+    SPINNERS: Array[Symbol]
+
+    # Display a spinner while running a command or block
+    #
+    # @rbs title: String -- spinner title text (default: "Loading...")
+    # @rbs command: String? -- shell command to execute
+    # @rbs spinner: Symbol | String | nil -- spinner type (see SPINNERS constant)
+    # @rbs show_output: bool? -- show command stdout after completion
+    # @rbs show_error: bool? -- show command stderr after completion
+    # @rbs align: Symbol? -- alignment of spinner and title (:left, :right)
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs spinner_style: Hash[Symbol, untyped]? -- spinner animation style
+    # @rbs title_style: Hash[Symbol, untyped]? -- title text style
+    # @rbs &block: ^() -> untyped | nil -- Ruby block to execute (alternative to command)
+    # @rbs return: String | untyped | nil -- command output or block result, nil if cancelled
+    def self.call: (?String title, ?command: String?, ?spinner: Symbol | String | nil, ?show_output: bool?, ?show_error: bool?, ?align: Symbol?, ?timeout: Integer?, ?spinner_style: Hash[Symbol, untyped]?, ?title_style: Hash[Symbol, untyped]?) ?{ (?) -> untyped } -> (String | untyped | nil)
+
+    # @rbs title: String -- spinner title text
+    # @rbs command: String -- shell command to execute
+    # @rbs spinner: Symbol | String | nil -- spinner type
+    # @rbs show_output: bool? -- show command stdout
+    # @rbs show_error: bool? -- show command stderr
+    # @rbs align: Symbol? -- alignment of spinner
+    # @rbs timeout: Integer? -- timeout in seconds
+    # @rbs spinner_style: Hash[Symbol, untyped]? -- spinner animation style
+    # @rbs title_style: Hash[Symbol, untyped]? -- title text style
+    # @rbs return: bool? -- true if command succeeded, false/nil otherwise
+    def self.run_with_command: (String title, command: String, spinner: Symbol | String | nil, show_output: bool?, show_error: bool?, align: Symbol?, timeout: Integer?, spinner_style: Hash[Symbol, untyped]?, title_style: Hash[Symbol, untyped]?) -> bool?
+
+    # @rbs title: String -- spinner title text
+    # @rbs spinner: Symbol | String | nil -- spinner type
+    # @rbs spinner_style: Hash[Symbol, untyped]? -- spinner animation style
+    # @rbs title_style: Hash[Symbol, untyped]? -- title text style
+    # @rbs &block: ^() -> untyped -- Ruby block to execute
+    # @rbs return: untyped -- block result
+    def self.run_with_block: (String title, spinner: Symbol | String | nil, spinner_style: Hash[Symbol, untyped]?, title_style: Hash[Symbol, untyped]?) ?{ (?) -> untyped } -> untyped
+  end
+end

data/sig/gum/commands/style.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/gum/commands/style.rb with RBS::Inline
+
+module Gum
+  # Apply styling to text
+  #
+  # @example Basic styling
+  #   styled = Gum.style("Hello", foreground: "212", bold: true)
+  #
+  # @example With border
+  #   box = Gum.style("Content", border: :double, padding: "1 2")
+  #
+  # @example Multiple lines
+  #   styled = Gum.style("Line 1", "Line 2", align: :center, width: 50)
+  class Style
+    BORDERS: Array[Symbol]
+
+    ALIGNMENTS: Array[Symbol]
+
+    # Apply styling to text
+    #
+    # @rbs *text: String -- text content to style (multiple strings become separate lines)
+    # @rbs foreground: String | Integer | nil -- text color (ANSI code, hex, or color name)
+    # @rbs background: String | Integer | nil -- background color (ANSI code, hex, or color name)
+    # @rbs border: Symbol | String | nil -- border style (:none, :hidden, :rounded, :double, :thick, :normal)
+    # @rbs border_foreground: String | Integer | nil -- border color
+    # @rbs border_background: String | Integer | nil -- border background color
+    # @rbs align: Symbol | String | nil -- text alignment (:left, :center, :right)
+    # @rbs height: Integer? -- fixed height in lines
+    # @rbs width: Integer? -- fixed width in characters
+    # @rbs margin: String | Array[Integer] | nil -- margin around the box ("1" or "1 2" or [1, 2, 1, 2])
+    # @rbs padding: String | Array[Integer] | nil -- padding inside the box ("1" or "1 2" or [1, 2, 1, 2])
+    # @rbs bold: bool? -- bold text
+    # @rbs italic: bool? -- italic text
+    # @rbs strikethrough: bool? -- strikethrough text
+    # @rbs underline: bool? -- underlined text
+    # @rbs faint: bool? -- faint/dim text
+    # @rbs return: String? -- styled text output
+    def self.call: (*String text, ?foreground: String | Integer | nil, ?background: String | Integer | nil, ?border: Symbol | String | nil, ?border_foreground: String | Integer | nil, ?border_background: String | Integer | nil, ?align: Symbol | String | nil, ?height: Integer?, ?width: Integer?, ?margin: String | Array[Integer] | nil, ?padding: String | Array[Integer] | nil, ?bold: bool?, ?italic: bool?, ?strikethrough: bool?, ?underline: bool?, ?faint: bool?) -> String?
+
+    # @rbs value: String | Integer | Array[Integer] | nil -- spacing value to format
+    # @rbs return: String? -- formatted spacing string
+    def self.format_spacing: (String | Integer | Array[Integer] | nil value) -> String?
+  end
+end

data/sig/gum/commands/table.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/gum/commands/table.rb with RBS::Inline
+
+module Gum
+  # Display and select from tabular data
+  #
+  # @example From array of arrays
+  #   selection = Gum.table([["Alice", 30], ["Bob", 25]], columns: %w[Name Age])
+  #
+  # @example From CSV string
+  #   Gum.table(File.read("data.csv"))
+  #
+  # @example With custom separator
+  #   Gum.table(data, separator: "\t")
+  class Table
+    # Display tabular data and optionally allow row selection
+    #
+    # @rbs data: String | Array[Array[untyped]] -- CSV string or array of row arrays
+    # @rbs columns: Array[String]? -- column headers (required when data is array)
+    # @rbs separator: String? -- column separator (default: ",")
+    # @rbs widths: Array[Integer]? -- column widths
+    # @rbs height: Integer? -- table height in rows
+    # @rbs print: bool? -- print table without selection (non-interactive)
+    # @rbs border: Symbol | String | nil -- border style (:rounded, :thick, :normal, :hidden, :double, :none)
+    # @rbs border_foreground: String | Integer | nil -- border color
+    # @rbs border_background: String | Integer | nil -- border background color
+    # @rbs cell_foreground: String | Integer | nil -- cell text color
+    # @rbs cell_background: String | Integer | nil -- cell background color
+    # @rbs header_foreground: String | Integer | nil -- header text color
+    # @rbs header_background: String | Integer | nil -- header background color
+    # @rbs selected_foreground: String | Integer | nil -- selected row text color
+    # @rbs selected_background: String | Integer | nil -- selected row background color
+    # @rbs return: String? -- selected row data, or nil if cancelled
+    def self.call: (String | Array[Array[untyped]] data, ?columns: Array[String]?, ?separator: String?, ?widths: Array[Integer]?, ?height: Integer?, ?print: bool?, ?border: Symbol | String | nil, ?border_foreground: String | Integer | nil, ?border_background: String | Integer | nil, ?cell_foreground: String | Integer | nil, ?cell_background: String | Integer | nil, ?header_foreground: String | Integer | nil, ?header_background: String | Integer | nil, ?selected_foreground: String | Integer | nil, ?selected_background: String | Integer | nil) -> String?
+  end
+end

data/sig/gum/commands/write.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/gum/commands/write.rb with RBS::Inline
+
+module Gum
+  # Prompt for multi-line text input
+  #
+  # @example Basic multi-line input
+  #   description = Gum.write(placeholder: "Enter description...")
+  #
+  # @example With dimensions
+  #   notes = Gum.write(width: 80, height: 10, header: "Notes")
+  class Write
+    # Prompt for multi-line text input (Ctrl+D to submit)
+    #
+    # @rbs placeholder: String? -- placeholder text shown when empty
+    # @rbs prompt: String? -- prompt string shown at the start of each line
+    # @rbs value: String? -- initial value for the text area
+    # @rbs char_limit: Integer? -- maximum number of characters allowed
+    # @rbs width: Integer? -- width of the text area
+    # @rbs height: Integer? -- height of the text area in lines
+    # @rbs header: String? -- header text displayed above the input
+    # @rbs show_cursor_line: bool? -- highlight the line with the cursor
+    # @rbs show_line_numbers: bool? -- display line numbers
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor: Hash[Symbol, untyped]? -- cursor style options
+    # @rbs cursor_line: Hash[Symbol, untyped]? -- cursor line highlight style
+    # @rbs placeholder_style: Hash[Symbol, untyped]? -- placeholder text style
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style
+    # @rbs end_of_buffer: Hash[Symbol, untyped]? -- end of buffer character style
+    # @rbs line_number: Hash[Symbol, untyped]? -- line number style
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style
+    # @rbs base: Hash[Symbol, untyped]? -- base text style
+    # @rbs return: String? -- the entered text, or nil if cancelled
+    def self.call: (?placeholder: String?, ?prompt: String?, ?value: String?, ?char_limit: Integer?, ?width: Integer?, ?height: Integer?, ?header: String?, ?show_cursor_line: bool?, ?show_line_numbers: bool?, ?timeout: Integer?, ?cursor: Hash[Symbol, untyped]?, ?cursor_line: Hash[Symbol, untyped]?, ?placeholder_style: Hash[Symbol, untyped]?, ?prompt_style: Hash[Symbol, untyped]?, ?end_of_buffer: Hash[Symbol, untyped]?, ?line_number: Hash[Symbol, untyped]?, ?header_style: Hash[Symbol, untyped]?, ?base: Hash[Symbol, untyped]?) -> String?
+  end
+end

data/sig/gum/upstream.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/gum/upstream.rb with RBS::Inline
+
+module Gum
+  module Upstream
+    VERSION: ::String
+
+    NATIVE_PLATFORMS: untyped
+  end
+end

data/sig/gum/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/gum/version.rb with RBS::Inline
+
+module Gum
+  VERSION: ::String
+end

data/sig/gum.rbs

@@ -0,0 +1,79 @@
+# Generated from lib/gum.rb with RBS::Inline
+
+module Gum
+  GEM_NAME: ::String
+
+  DEFAULT_DIR: untyped
+
+  class Error < StandardError
+  end
+
+  class ExecutableNotFoundException < Error
+  end
+
+  class UnsupportedPlatformException < Error
+  end
+
+  class DirectoryNotFoundException < Error
+  end
+
+  def self.execute: (*untyped args) -> untyped
+
+  def self.platform: () -> untyped
+
+  def self.version: () -> untyped
+
+  def self.executable: (?exe_path: untyped) -> untyped
+
+  # Prompt for single-line input
+  # @see Gum::Input#call
+  def self.input: (**untyped) -> untyped
+
+  # Prompt for multi-line text input
+  # @see Gum::Write#call
+  def self.write: (**untyped) -> untyped
+
+  # Choose from a list of options
+  # @see Gum::Choose#call
+  def self.choose: (untyped items, **untyped) -> untyped
+
+  # Filter items with fuzzy matching
+  # @see Gum::Filter#call
+  def self.filter: (untyped items, **untyped) -> untyped
+
+  # Prompt for confirmation
+  # @see Gum::Confirm#call
+  def self.confirm: (?untyped prompt, **untyped) -> untyped
+
+  # Pick a file from the filesystem
+  # @see Gum::FilePicker#call
+  def self.file: (?untyped path, **untyped) -> untyped
+
+  # Display content in a scrollable pager
+  # @see Gum::Pager#call
+  def self.pager: (untyped content, **untyped) -> untyped
+
+  # Display a spinner while running a command or block
+  # @see Gum::Spin#call
+  def self.spin: (?untyped title, **untyped) ?{ (?) -> untyped } -> untyped
+
+  # Apply styling to text
+  # @see Gum::Style#call
+  def self.style: (*untyped text, **untyped) -> untyped
+
+  # Join text blocks together
+  # @see Gum::Join#call
+  def self.join: (*untyped texts, **untyped) -> untyped
+
+  # Format text (markdown, code, template, emoji)
+  # @see Gum::Format#call
+  def self.format: (*untyped text, **untyped) -> untyped
+
+  # Display and select from tabular data
+  # @see Gum::Table#call
+  def self.table: (untyped data, **untyped) -> untyped
+
+  # Log a message
+  # @see Gum::Log#call
+  def self.log: (untyped message, **untyped) -> untyped
+end