typescript-to-gdscript 0.1.0

package/typings/classes/CodeEdit.d.ts

@@ -0,0 +1,402 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A multiline text editor designed for editing code. */
+declare class CodeEdit extends TextEdit {
+  /**
+   * If `true`, uses {@link auto_brace_completion_pairs} to automatically insert the closing brace when the opening brace is inserted by typing or autocompletion. Also automatically removes the closing brace when using backspace on the opening brace.
+   */
+  auto_brace_completion_enabled: boolean;
+  /**
+   * If `true`, highlights brace pairs when the caret is on either one, using {@link auto_brace_completion_pairs}. If matching, the pairs will be underlined. If a brace is unmatched, it is colored with .
+   */
+  auto_brace_completion_highlight_matching: boolean;
+  /**
+   * Sets the brace pairs to be autocompleted. For each entry in the dictionary, the key is the opening brace and the value is the closing brace that matches it. A brace is a {@link String} made of symbols. See {@link auto_brace_completion_enabled} and {@link auto_brace_completion_highlight_matching}.
+   */
+  auto_brace_completion_pairs: Dictionary;
+  /**
+   * If `true`, the {@link ProjectSettings.input/ui_text_completion_query} action requests code completion. To handle it, see {@link _request_code_completion} or {@link code_completion_requested}.
+   */
+  code_completion_enabled: boolean;
+  /** Sets prefixes that will trigger code completion. */
+  code_completion_prefixes: Array<string>;
+  /** Sets the comment delimiters. All existing comment delimiters will be removed. */
+  delimiter_comments: Array<string>;
+  /** Sets the string delimiters. All existing string delimiters will be removed. */
+  delimiter_strings: Array<string>;
+  /**
+   * If `true`, bookmarks are drawn in the gutter. This gutter is shared with breakpoints and executing lines. See {@link set_line_as_bookmarked}.
+   */
+  gutters_draw_bookmarks: boolean;
+  /**
+   * If `true`, breakpoints are drawn in the gutter. This gutter is shared with bookmarks and executing lines. Clicking the gutter will toggle the breakpoint for the line, see {@link set_line_as_breakpoint}.
+   */
+  gutters_draw_breakpoints_gutter: boolean;
+  /**
+   * If `true`, executing lines are marked in the gutter. This gutter is shared with breakpoints and bookmarks. See {@link set_line_as_executing}.
+   */
+  gutters_draw_executing_lines: boolean;
+  /**
+   * If `true`, the fold gutter is drawn. In this gutter, the  icon is drawn for each foldable line (see {@link can_fold_line}) and the  icon is drawn for each folded line (see {@link is_line_folded}). These icons can be clicked to toggle the fold state, see {@link toggle_foldable_line}. {@link line_folding} must be `true` to show icons.
+   */
+  gutters_draw_fold_gutter: boolean;
+  /**
+   * If `true`, the line number gutter is drawn. Line numbers start at `1` and are incremented for each line of text. Clicking and dragging in the line number gutter will select entire lines of text.
+   */
+  gutters_draw_line_numbers: boolean;
+  /** The minimum width in digits reserved for the line number gutter. */
+  gutters_line_numbers_min_digits: int;
+  /**
+   * If `true`, line numbers drawn in the gutter are zero padded based on the total line count. Requires {@link gutters_draw_line_numbers} to be set to `true`.
+   */
+  gutters_zero_pad_line_numbers: boolean;
+  /**
+   * If `true`, an extra indent is automatically inserted when a new line is added and a prefix in {@link indent_automatic_prefixes} is found. If a brace pair opening key is found, the matching closing brace will be moved to another new line (see {@link auto_brace_completion_pairs}).
+   */
+  indent_automatic: boolean;
+  /** Prefixes to trigger an automatic indent. Used when {@link indent_automatic} is set to `true`. */
+  indent_automatic_prefixes: Array<string>;
+  /**
+   * Size of the tabulation indent (one `Tab` press) in characters. If {@link indent_use_spaces} is enabled the number of spaces to use.
+   */
+  indent_size: int;
+  /** Use spaces instead of tabs for indentation. */
+  indent_use_spaces: boolean;
+  /**
+   * <member name="line_folding" type="bool" setter="set_line_folding_enabled" getter="is_line_folding_enabled" default="false">
+   * If `true`, lines can be folded. Otherwise, line folding methods like {@link fold_line} will not work and {@link can_fold_line} will always return `false`. See {@link gutters_draw_fold_gutter}.
+   */
+  layout_direction: int;
+  /**
+   * Draws vertical lines at the provided columns. The first entry is considered a main hard guideline and is drawn more prominently.
+   */
+  line_length_guidelines: Array<int>;
+  /**
+   * Set when a validated word from {@link symbol_validate} is clicked, the {@link symbol_lookup} should be emitted.
+   */
+  symbol_lookup_on_click: boolean;
+  /** If `true`, the {@link symbol_hovered} signal is emitted when hovering over a word. */
+  symbol_tooltip_on_hover: boolean;
+  text_direction: int;
+  set_auto_brace_completion_enabled(value: boolean): void;
+  is_auto_brace_completion_enabled(): boolean;
+  set_highlight_matching_braces_enabled(value: boolean): void;
+  is_highlight_matching_braces_enabled(): boolean;
+  set_auto_brace_completion_pairs(value: Dictionary): void;
+  get_auto_brace_completion_pairs(): Dictionary;
+  set_code_completion_enabled(value: boolean): void;
+  is_code_completion_enabled(): boolean;
+  set_code_completion_prefixes(value: Array<string>): void;
+  get_code_completion_prefixes(): Array<string>;
+  set_comment_delimiters(value: Array<string>): void;
+  get_comment_delimiters(): Array<string>;
+  set_string_delimiters(value: Array<string>): void;
+  get_string_delimiters(): Array<string>;
+  set_draw_bookmarks_gutter(value: boolean): void;
+  is_drawing_bookmarks_gutter(): boolean;
+  set_draw_breakpoints_gutter(value: boolean): void;
+  is_drawing_breakpoints_gutter(): boolean;
+  set_draw_executing_lines_gutter(value: boolean): void;
+  is_drawing_executing_lines_gutter(): boolean;
+  set_draw_fold_gutter(value: boolean): void;
+  is_drawing_fold_gutter(): boolean;
+  set_draw_line_numbers(value: boolean): void;
+  is_draw_line_numbers_enabled(): boolean;
+  set_line_numbers_min_digits(value: int): void;
+  get_line_numbers_min_digits(): int;
+  set_line_numbers_zero_padded(value: boolean): void;
+  is_line_numbers_zero_padded(): boolean;
+  set_auto_indent_enabled(value: boolean): void;
+  is_auto_indent_enabled(): boolean;
+  set_auto_indent_prefixes(value: Array<string>): void;
+  get_auto_indent_prefixes(): Array<string>;
+  set_indent_size(value: int): void;
+  get_indent_size(): int;
+  set_indent_using_spaces(value: boolean): void;
+  is_indent_using_spaces(): boolean;
+  set_line_length_guidelines(value: Array<int>): void;
+  get_line_length_guidelines(): Array<int>;
+  set_symbol_lookup_on_click_enabled(value: boolean): void;
+  is_symbol_lookup_on_click_enabled(): boolean;
+  set_symbol_tooltip_on_hover_enabled(value: boolean): void;
+  is_symbol_tooltip_on_hover_enabled(): boolean;
+
+  /**
+   * Override this method to define how the selected entry should be inserted. If `replace` is `true`, any existing text should be replaced.
+   */
+  _confirm_code_completion(replace: boolean): void;
+  /**
+   * Override this method to define what items in `candidates` should be displayed.
+   * Both `candidates` and the return is an {@link Array} of {@link Dictionary}, see {@link get_code_completion_option} for {@link Dictionary} content.
+   */
+  _filter_code_completion_candidates(candidates: Array<Dictionary>): Array<Dictionary>;
+  /**
+   * Override this method to define what happens when the user requests code completion. If `force` is `true`, any checks should be bypassed.
+   */
+  _request_code_completion(force: boolean): void;
+  /**
+   * Adds a brace pair.
+   * Both the start and end keys must be symbols. Only the start key has to be unique.
+   */
+  add_auto_brace_completion_pair(start_key: string | NodePath, end_key: string | NodePath): void;
+  /**
+   * Submits an item to the queue of potential candidates for the autocomplete menu. Call {@link update_code_completion_options} to update the list.
+   * `location` indicates location of the option relative to the location of the code completion query. See {@link CodeEdit.CodeCompletionLocation} for how to set this value.
+   * **Note:** This list will replace all current candidates.
+   */
+  add_code_completion_option(type_: int, display_text: string | NodePath, insert_text: string | NodePath, text_color?: Color, icon?: Resource, value?: unknown, location?: int): void;
+  /**
+   * Adds a comment delimiter from `start_key` to `end_key`. Both keys should be symbols, and `start_key` must not be shared with other delimiters.
+   * If `line_only` is `true` or `end_key` is an empty {@link String}, the region does not carry over to the next line.
+   */
+  add_comment_delimiter(start_key: string | NodePath, end_key: string | NodePath, line_only?: boolean): void;
+  /**
+   * Defines a string delimiter from `start_key` to `end_key`. Both keys should be symbols, and `start_key` must not be shared with other delimiters.
+   * If `line_only` is `true` or `end_key` is an empty {@link String}, the region does not carry over to the next line.
+   */
+  add_string_delimiter(start_key: string | NodePath, end_key: string | NodePath, line_only?: boolean): void;
+  /**
+   * Returns `true` if the given line is foldable. A line is foldable if it is the start of a valid code region (see {@link get_code_region_start_tag}), if it is the start of a comment or string block, or if the next non-empty line is more indented (see {@link TextEdit.get_indent_level}).
+   */
+  can_fold_line(line: int): boolean;
+  /** Cancels the autocomplete menu. */
+  cancel_code_completion(): void;
+  /** Clears all bookmarked lines. */
+  clear_bookmarked_lines(): void;
+  /** Clears all breakpointed lines. */
+  clear_breakpointed_lines(): void;
+  /** Removes all comment delimiters. */
+  clear_comment_delimiters(): void;
+  /** Clears all executed lines. */
+  clear_executing_lines(): void;
+  /** Removes all string delimiters. */
+  clear_string_delimiters(): void;
+  /**
+   * Inserts the selected entry into the text. If `replace` is `true`, any existing text is replaced rather than merged.
+   */
+  confirm_code_completion(replace?: boolean): void;
+  /**
+   * Converts the indents of lines between `from_line` and `to_line` to tabs or spaces as set by {@link indent_use_spaces}.
+   * Values of `-1` convert the entire text.
+   */
+  convert_indent(from_line?: int, to_line?: int): void;
+  /**
+   * Creates a new code region with the selection. At least one single line comment delimiter have to be defined (see {@link add_comment_delimiter}).
+   * A code region is a part of code that is highlighted when folded and can help organize your script.
+   * Code region start and end tags can be customized (see {@link set_code_region_tags}).
+   * Code regions are delimited using start and end tags (respectively `region` and `endregion` by default) preceded by one line comment delimiter. (eg. `#region` and `#endregion`)
+   */
+  create_code_region(): void;
+  /** Deletes all lines that are selected or have a caret on them. */
+  delete_lines(): void;
+  /**
+   * If there is no selection, indentation is inserted at the caret. Otherwise, the selected lines are indented like {@link indent_lines}. Equivalent to the {@link ProjectSettings.input/ui_text_indent} action. The indentation characters used depend on {@link indent_use_spaces} and {@link indent_size}.
+   */
+  do_indent(): void;
+  /**
+   * Duplicates all lines currently selected with any caret. Duplicates the entire line beneath the current one no matter where the caret is within the line.
+   */
+  duplicate_lines(): void;
+  /** Duplicates all selected text and duplicates all lines with a caret on them. */
+  duplicate_selection(): void;
+  /** Folds all lines that are possible to be folded (see {@link can_fold_line}). */
+  fold_all_lines(): void;
+  /** Folds the given line, if possible (see {@link can_fold_line}). */
+  fold_line(line: int): void;
+  /** Gets the matching auto brace close key for `open_key`. */
+  get_auto_brace_completion_close_key(open_key: string | NodePath): string;
+  /** Gets all bookmarked lines. */
+  get_bookmarked_lines(): PackedInt32Array;
+  /** Gets all breakpointed lines. */
+  get_breakpointed_lines(): PackedInt32Array;
+  /**
+   * Gets the completion option at `index`. The return {@link Dictionary} has the following key-values:
+   * `kind`: {@link CodeCompletionKind}
+   * `display_text`: Text that is shown on the autocomplete menu.
+   * `insert_text`: Text that is to be inserted when this item is selected.
+   * `font_color`: Color of the text on the autocomplete menu.
+   * `icon`: Icon to draw on the autocomplete menu.
+   * `default_value`: Value of the symbol.
+   */
+  get_code_completion_option(index: int): Dictionary;
+  /** Gets all completion options, see {@link get_code_completion_option} for return content. */
+  get_code_completion_options(): Array<Dictionary>;
+  /** Gets the index of the current selected completion option. */
+  get_code_completion_selected_index(): int;
+  /** Returns the code region end tag (without comment delimiter). */
+  get_code_region_end_tag(): string;
+  /** Returns the code region start tag (without comment delimiter). */
+  get_code_region_start_tag(): string;
+  /** Gets the end key for a string or comment region index. */
+  get_delimiter_end_key(delimiter_index: int): string;
+  /**
+   * If `line` `column` is in a string or comment, returns the end position of the region. If not or no end could be found, both {@link Vector2} values will be `-1`.
+   */
+  get_delimiter_end_position(line: int, column: int): Vector2;
+  /** Gets the start key for a string or comment region index. */
+  get_delimiter_start_key(delimiter_index: int): string;
+  /**
+   * If `line` `column` is in a string or comment, returns the start position of the region. If not or no start could be found, both {@link Vector2} values will be `-1`.
+   */
+  get_delimiter_start_position(line: int, column: int): Vector2;
+  /** Gets all executing lines. */
+  get_executing_lines(): PackedInt32Array;
+  /** Returns all lines that are currently folded. */
+  get_folded_lines(): Array<int>;
+  /** Returns the full text with char `0xFFFF` at the caret location. */
+  get_text_for_code_completion(): string;
+  /** Returns the full text with char `0xFFFF` at the cursor location. */
+  get_text_for_symbol_lookup(): string;
+  /** Returns the full text with char `0xFFFF` at the specified location. */
+  get_text_with_cursor_char(line: int, column: int): string;
+  /** Returns `true` if close key `close_key` exists. */
+  has_auto_brace_completion_close_key(close_key: string | NodePath): boolean;
+  /** Returns `true` if open key `open_key` exists. */
+  has_auto_brace_completion_open_key(open_key: string | NodePath): boolean;
+  /** Returns `true` if comment `start_key` exists. */
+  has_comment_delimiter(start_key: string | NodePath): boolean;
+  /** Returns `true` if string `start_key` exists. */
+  has_string_delimiter(start_key: string | NodePath): boolean;
+  /**
+   * Indents all lines that are selected or have a caret on them. Uses spaces or a tab depending on {@link indent_use_spaces}. See {@link unindent_lines}.
+   */
+  indent_lines(): void;
+  /**
+   * Returns delimiter index if `line` `column` is in a comment. If `column` is not provided, will return delimiter index if the entire `line` is a comment. Otherwise `-1`.
+   */
+  is_in_comment(line: int, column?: int): int;
+  /**
+   * Returns the delimiter index if `line` `column` is in a string. If `column` is not provided, will return the delimiter index if the entire `line` is a string. Otherwise `-1`.
+   */
+  is_in_string(line: int, column?: int): int;
+  /** Returns `true` if the given line is bookmarked. See {@link set_line_as_bookmarked}. */
+  is_line_bookmarked(line: int): boolean;
+  /** Returns `true` if the given line is breakpointed. See {@link set_line_as_breakpoint}. */
+  is_line_breakpointed(line: int): boolean;
+  /** Returns `true` if the given line is a code region end. See {@link set_code_region_tags}. */
+  is_line_code_region_end(line: int): boolean;
+  /** Returns `true` if the given line is a code region start. See {@link set_code_region_tags}. */
+  is_line_code_region_start(line: int): boolean;
+  /** Returns `true` if the given line is marked as executing. See {@link set_line_as_executing}. */
+  is_line_executing(line: int): boolean;
+  /** Returns `true` if the given line is folded. See {@link fold_line}. */
+  is_line_folded(line: int): boolean;
+  /**
+   * Joins all selected lines or lines containing a caret with their next line. Whitespace in between will be removed. If the next line has content, the `line_ending` will be inserted in between.
+   */
+  join_lines(line_ending?: string | NodePath): void;
+  /** Moves all lines down that are selected or have a caret on them. */
+  move_lines_down(): void;
+  /** Moves all lines up that are selected or have a caret on them. */
+  move_lines_up(): void;
+  /** Removes the comment delimiter with `start_key`. */
+  remove_comment_delimiter(start_key: string | NodePath): void;
+  /** Removes the string delimiter with `start_key`. */
+  remove_string_delimiter(start_key: string | NodePath): void;
+  /**
+   * Emits {@link code_completion_requested}, if `force` is `true` will bypass all checks. Otherwise will check that the caret is in a word or in front of a prefix. Will ignore the request if all current options are of type file path, node path, or signal.
+   */
+  request_code_completion(force?: boolean): void;
+  /** Sets the current selected completion option. */
+  set_code_completion_selected_index(index: int): void;
+  /** Sets the code hint text. Pass an empty string to clear. */
+  set_code_hint(code_hint: string | NodePath): void;
+  /**
+   * If `true`, the code hint will draw below the main caret. If `false`, the code hint will draw above the main caret. See {@link set_code_hint}.
+   */
+  set_code_hint_draw_below(draw_below: boolean): void;
+  /** Sets the code region start and end tags (without comment delimiter). */
+  set_code_region_tags(start?: string | NodePath, end?: string | NodePath): void;
+  /**
+   * Sets the given line as bookmarked. If `true` and {@link gutters_draw_bookmarks} is `true`, draws the  icon in the gutter for this line. See {@link get_bookmarked_lines} and {@link is_line_bookmarked}.
+   */
+  set_line_as_bookmarked(line: int, bookmarked: boolean): void;
+  /**
+   * Sets the given line as a breakpoint. If `true` and {@link gutters_draw_breakpoints_gutter} is `true`, draws the  icon in the gutter for this line. See {@link get_breakpointed_lines} and {@link is_line_breakpointed}.
+   */
+  set_line_as_breakpoint(line: int, breakpointed: boolean): void;
+  /**
+   * Sets the given line as executing. If `true` and {@link gutters_draw_executing_lines} is `true`, draws the  icon in the gutter for this line. See {@link get_executing_lines} and {@link is_line_executing}.
+   */
+  set_line_as_executing(line: int, executing: boolean): void;
+  /** Sets the symbol emitted by {@link symbol_validate} as a valid lookup. */
+  set_symbol_lookup_word_as_valid(valid: boolean): void;
+  /** Toggle the folding of the code block at the given line. */
+  toggle_foldable_line(line: int): void;
+  /** Toggle the folding of the code block on all lines with a caret on them. */
+  toggle_foldable_lines_at_carets(): void;
+  /** Unfolds all lines that are folded. */
+  unfold_all_lines(): void;
+  /** Unfolds the given line if it is folded or if it is hidden under a folded line. */
+  unfold_line(line: int): void;
+  /**
+   * Unindents all lines that are selected or have a caret on them. Uses spaces or a tab depending on {@link indent_use_spaces}. Equivalent to the {@link ProjectSettings.input/ui_text_dedent} action. See {@link indent_lines}.
+   */
+  unindent_lines(): void;
+  /**
+   * Submits all completion options added with {@link add_code_completion_option}. Will try to force the autocomplete menu to popup, if `force` is `true`.
+   * **Note:** This will replace all current candidates.
+   */
+  update_code_completion_options(force: boolean): void;
+
+  /**
+   * Emitted when a breakpoint is added or removed from a line. If the line is removed via backspace, a signal is emitted at the old line.
+   */
+  breakpoint_toggled: Signal<[int]>;
+  /**
+   * Emitted when the user requests code completion. This signal will not be sent if {@link _request_code_completion} is overridden or {@link code_completion_enabled} is `false`.
+   */
+  code_completion_requested: Signal<[]>;
+  /**
+   * Emitted when the user hovers over a symbol. Unlike {@link Control.mouse_entered}, this signal is not emitted immediately, but when the cursor is over the symbol for {@link ProjectSettings.gui/timers/tooltip_delay_sec} seconds.
+   * **Note:** {@link symbol_tooltip_on_hover} must be `true` for this signal to be emitted.
+   */
+  symbol_hovered: Signal<[string, int, int]>;
+  /** Emitted when the user has clicked on a valid symbol. */
+  symbol_lookup: Signal<[string, int, int]>;
+  /**
+   * Emitted when the user hovers over a symbol. The symbol should be validated and responded to, by calling {@link set_symbol_lookup_word_as_valid}.
+   * **Note:** {@link symbol_lookup_on_click} must be `true` for this signal to be emitted.
+   */
+  symbol_validate: Signal<[string]>;
+
+  // enum CodeCompletionKind
+  /** Marks the option as a class. */
+  static readonly KIND_CLASS: int;
+  /** Marks the option as a function. */
+  static readonly KIND_FUNCTION: int;
+  /** Marks the option as a Godot signal. */
+  static readonly KIND_SIGNAL: int;
+  /** Marks the option as a variable. */
+  static readonly KIND_VARIABLE: int;
+  /** Marks the option as a member. */
+  static readonly KIND_MEMBER: int;
+  /** Marks the option as an enum entry. */
+  static readonly KIND_ENUM: int;
+  /** Marks the option as a constant. */
+  static readonly KIND_CONSTANT: int;
+  /** Marks the option as a Godot node path. */
+  static readonly KIND_NODE_PATH: int;
+  /** Marks the option as a file path. */
+  static readonly KIND_FILE_PATH: int;
+  /** Marks the option as unclassified or plain text. */
+  static readonly KIND_PLAIN_TEXT: int;
+  // enum CodeCompletionLocation
+  /**
+   * The option is local to the location of the code completion query - e.g. a local variable. Subsequent value of location represent options from the outer class, the exact value represent how far they are (in terms of inner classes).
+   */
+  static readonly LOCATION_LOCAL: int;
+  /**
+   * The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. `0` for the local class, `1` for the parent, `2` for the grandparent, etc.) to store the depth of an option in the class or a parent class.
+   */
+  static readonly LOCATION_PARENT_MASK: int;
+  /**
+   * The option is from user code which is not local and not in a derived class (e.g. Autoload Singletons).
+   */
+  static readonly LOCATION_OTHER_USER_CODE: int;
+  /**
+   * The option is from other engine code, not covered by the other enum constants - e.g. built-in classes.
+   */
+  static readonly LOCATION_OTHER: int;
+}

package/typings/classes/CodeHighlighter.d.ts

@@ -0,0 +1,81 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A syntax highlighter intended for code. */
+declare class CodeHighlighter extends SyntaxHighlighter {
+  /**
+   * Sets the color regions. All existing regions will be removed. The {@link Dictionary} key is the region start and end key, separated by a space. The value is the region color.
+   */
+  color_regions: Dictionary;
+  /** Sets color for functions. A function is a non-keyword string followed by a '('. */
+  function_color: Color;
+  /**
+   * Sets the keyword colors. All existing keywords will be removed. The {@link Dictionary} key is the keyword. The value is the keyword color.
+   */
+  keyword_colors: Dictionary;
+  /**
+   * Sets the member keyword colors. All existing member keyword will be removed. The {@link Dictionary} key is the member keyword. The value is the member keyword color.
+   */
+  member_keyword_colors: Dictionary;
+  /**
+   * Sets color for member variables. A member variable is non-keyword, non-function string proceeded with a '.'.
+   */
+  member_variable_color: Color;
+  /** Sets the color for numbers. */
+  number_color: Color;
+  /** Sets the color for symbols. */
+  symbol_color: Color;
+  set_color_regions(value: Dictionary): void;
+  get_color_regions(): Dictionary;
+  set_function_color(value: Color): void;
+  get_function_color(): Color;
+  set_keyword_colors(value: Dictionary): void;
+  get_keyword_colors(): Dictionary;
+  set_member_keyword_colors(value: Dictionary): void;
+  get_member_keyword_colors(): Dictionary;
+  set_member_variable_color(value: Color): void;
+  get_member_variable_color(): Color;
+  set_number_color(value: Color): void;
+  get_number_color(): Color;
+  set_symbol_color(value: Color): void;
+  get_symbol_color(): Color;
+
+  /**
+   * Adds a color region (such as for comments or strings) from `start_key` to `end_key`. Both keys should be symbols, and `start_key` must not be shared with other delimiters.
+   * If `line_only` is `true` or `end_key` is an empty {@link String}, the region does not carry over to the next line.
+   */
+  add_color_region(start_key: string | NodePath, end_key: string | NodePath, color: Color, line_only?: boolean): void;
+  /**
+   * Sets the color for a keyword.
+   * The keyword cannot contain any symbols except '_'.
+   */
+  add_keyword_color(keyword: string | NodePath, color: Color): void;
+  /**
+   * Sets the color for a member keyword.
+   * The member keyword cannot contain any symbols except '_'.
+   * It will not be highlighted if preceded by a '.'.
+   */
+  add_member_keyword_color(member_keyword: string | NodePath, color: Color): void;
+  /** Removes all color regions. */
+  clear_color_regions(): void;
+  /** Removes all keywords. */
+  clear_keyword_colors(): void;
+  /** Removes all member keywords. */
+  clear_member_keyword_colors(): void;
+  /** Returns the color for a keyword. */
+  get_keyword_color(keyword: string | NodePath): Color;
+  /** Returns the color for a member keyword. */
+  get_member_keyword_color(member_keyword: string | NodePath): Color;
+  /** Returns `true` if the start key exists, else `false`. */
+  has_color_region(start_key: string | NodePath): boolean;
+  /** Returns `true` if the keyword exists, else `false`. */
+  has_keyword_color(keyword: string | NodePath): boolean;
+  /** Returns `true` if the member keyword exists, else `false`. */
+  has_member_keyword_color(member_keyword: string | NodePath): boolean;
+  /** Removes the color region that uses that start key. */
+  remove_color_region(start_key: string | NodePath): void;
+  /** Removes the keyword. */
+  remove_keyword_color(keyword: string | NodePath): void;
+  /** Removes the member keyword. */
+  remove_member_keyword_color(member_keyword: string | NodePath): void;
+}

package/typings/classes/CollisionObject2D.d.ts

@@ -0,0 +1,171 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 2D physics objects. */
+declare class CollisionObject2D extends Node2D {
+  /**
+   * The physics layers this CollisionObject2D is in. Collision objects can exist in one or more of 32 different layers. See also {@link collision_mask}.
+   * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_layer: int;
+  /**
+   * The physics layers this CollisionObject2D scans. Collision objects can scan one or more of 32 different layers. See also {@link collision_layer}.
+   * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The priority used to solve colliding when occurring penetration. The higher the priority is, the lower the penetration into the object will be. This can for example be used to prevent the player from breaking through the boundaries of a level.
+   */
+  collision_priority: float;
+  /**
+   * Defines the behavior in physics when {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}.
+   */
+  disable_mode: int;
+  /**
+   * If `true`, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one {@link collision_layer} bit to be set.
+   */
+  input_pickable: boolean;
+  set_collision_layer(value: int): void;
+  get_collision_layer(): int;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_collision_priority(value: float): void;
+  get_collision_priority(): float;
+  set_disable_mode(value: int): void;
+  get_disable_mode(): int;
+  set_pickable(value: boolean): void;
+  is_pickable(): boolean;
+
+  /**
+   * Accepts unhandled {@link InputEvent}s. `shape_idx` is the child index of the clicked {@link Shape2D}. Connect to {@link input_event} to easily pick up these events.
+   * **Note:** {@link _input_event} requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set.
+   */
+  _input_event(viewport: Viewport, event: InputEvent, shape_idx: int): void;
+  /**
+   * Called when the mouse pointer enters any of this object's shapes. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject2D} won't cause this function to be called.
+   */
+  _mouse_enter(): void;
+  /**
+   * Called when the mouse pointer exits all this object's shapes. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject2D} won't cause this function to be called.
+   */
+  _mouse_exit(): void;
+  /**
+   * Called when the mouse pointer enters any of this object's shapes or moves from one shape to another. `shape_idx` is the child index of the newly entered {@link Shape2D}. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be called.
+   */
+  _mouse_shape_enter(shape_idx: int): void;
+  /**
+   * Called when the mouse pointer exits any of this object's shapes. `shape_idx` is the child index of the exited {@link Shape2D}. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be called.
+   */
+  _mouse_shape_exit(shape_idx: int): void;
+  /**
+   * Creates a new shape owner for the given object. Returns `owner_id` of the new owner for future reference.
+   */
+  create_shape_owner(owner: GodotObject): int;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_layer} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_layer_value(layer_number: int): boolean;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /** Returns the object's {@link RID}. */
+  get_rid(): RID;
+  /** Returns the `one_way_collision_direction` of the shape owner identified by the given `owner_id`. */
+  get_shape_owner_one_way_collision_direction(owner_id: int): Vector2;
+  /** Returns the `one_way_collision_margin` of the shape owner identified by given `owner_id`. */
+  get_shape_owner_one_way_collision_margin(owner_id: int): float;
+  /**
+   * Returns an {@link Array} of `owner_id` identifiers. You can use these ids in other methods that take `owner_id` as an argument.
+   */
+  get_shape_owners(): PackedInt32Array;
+  /** If `true`, the shape owner and its shapes are disabled. */
+  is_shape_owner_disabled(owner_id: int): boolean;
+  /**
+   * Returns `true` if collisions for the shape owner originating from this {@link CollisionObject2D} will not be reported to collided with {@link CollisionObject2D}s.
+   */
+  is_shape_owner_one_way_collision_enabled(owner_id: int): boolean;
+  /** Removes the given shape owner. */
+  remove_shape_owner(owner_id: int): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_layer}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+  /** Returns the `owner_id` of the given shape. */
+  shape_find_owner(shape_index: int): int;
+  /** Adds a {@link Shape2D} to the shape owner. */
+  shape_owner_add_shape(owner_id: int, shape: Shape2D): void;
+  /** Removes all shapes from the shape owner. */
+  shape_owner_clear_shapes(owner_id: int): void;
+  /** Returns the parent object of the given shape owner. */
+  shape_owner_get_owner(owner_id: int): GodotObject | null;
+  /** Returns the {@link Shape2D} with the given ID from the given shape owner. */
+  shape_owner_get_shape(owner_id: int, shape_id: int): Shape2D | null;
+  /** Returns the number of shapes the given shape owner contains. */
+  shape_owner_get_shape_count(owner_id: int): int;
+  /** Returns the child index of the {@link Shape2D} with the given ID from the given shape owner. */
+  shape_owner_get_shape_index(owner_id: int, shape_id: int): int;
+  /** Returns the shape owner's {@link Transform2D}. */
+  shape_owner_get_transform(owner_id: int): Transform2D;
+  /** Removes a shape from the given shape owner. */
+  shape_owner_remove_shape(owner_id: int, shape_id: int): void;
+  /** If `true`, disables the given shape owner. */
+  shape_owner_set_disabled(owner_id: int, disabled: boolean): void;
+  /**
+   * If `enable` is `true`, collisions for the shape owner originating from this {@link CollisionObject2D} will not be reported to collided with {@link CollisionObject2D}s.
+   */
+  shape_owner_set_one_way_collision(owner_id: int, enable: boolean): void;
+  /**
+   * Sets the `one_way_collision_direction` of the shape owner identified by the given `owner_id` to `p_direction`.
+   */
+  shape_owner_set_one_way_collision_direction(owner_id: int, p_direction: Vector2 | Vector2i): void;
+  /**
+   * Sets the `one_way_collision_margin` of the shape owner identified by given `owner_id` to `margin` pixels.
+   */
+  shape_owner_set_one_way_collision_margin(owner_id: int, margin: float): void;
+  /** Sets the {@link Transform2D} of the given shape owner. */
+  shape_owner_set_transform(owner_id: int, transform: Transform2D): void;
+
+  /**
+   * Emitted when an input event occurs. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set. See {@link _input_event} for details.
+   */
+  input_event: Signal<[Node, InputEvent, int]>;
+  /**
+   * Emitted when the mouse pointer enters any of this object's shapes. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject2D} won't cause this signal to be emitted.
+   * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject2D}'s area is small. This signal may also not be emitted if another {@link CollisionObject2D} is overlapping the {@link CollisionObject2D} in question.
+   */
+  mouse_entered: Signal<[]>;
+  /**
+   * Emitted when the mouse pointer exits all this object's shapes. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject2D} won't cause this signal to be emitted.
+   * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject2D}'s area is small. This signal may also not be emitted if another {@link CollisionObject2D} is overlapping the {@link CollisionObject2D} in question.
+   */
+  mouse_exited: Signal<[]>;
+  /**
+   * Emitted when the mouse pointer enters any of this object's shapes or moves from one shape to another. `shape_idx` is the child index of the newly entered {@link Shape2D}. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set.
+   */
+  mouse_shape_entered: Signal<[int]>;
+  /**
+   * Emitted when the mouse pointer exits any of this object's shapes. `shape_idx` is the child index of the exited {@link Shape2D}. Requires {@link input_pickable} to be `true` and at least one {@link collision_layer} bit to be set.
+   */
+  mouse_shape_exited: Signal<[int]>;
+
+  // enum DisableMode
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, remove from the physics simulation to stop all physics interactions with this {@link CollisionObject2D}.
+   * Automatically re-added to the physics simulation when the {@link Node} is processed again.
+   */
+  static readonly DISABLE_MODE_REMOVE: int;
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, make the body static. Doesn't affect {@link Area2D}. {@link PhysicsBody2D} can't be affected by forces or other bodies while static.
+   * Automatically set {@link PhysicsBody2D} back to its original mode when the {@link Node} is processed again.
+   */
+  static readonly DISABLE_MODE_MAKE_STATIC: int;
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, do not affect the physics simulation.
+   */
+  static readonly DISABLE_MODE_KEEP_ACTIVE: int;
+}