@trioforge/brigadier 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+Copyright (c) 2026 Trio Forge Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# @trioforge/brigadier
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A roblox-ts port of [Mojang's Brigadier](https://github.com/Mojang/brigadier), the command parser and dispatcher behind Minecraft's commands. It is a class-for-class port of Brigadier 1.3, and it passes all of Brigadier's unit tests.
+
+Read the documentation at <https://website.trio-forge.workers.dev/brigadier/>.
+
+## Install
+
+```sh
+pnpm add @trioforge/brigadier
+```
+
+roblox-ts only looks for packages in the scopes your project lists, so add the `@trioforge` scope in two places.
+
+1. In `tsconfig.json`, add it to `typeRoots`:
+
+	```json
+	"typeRoots": ["node_modules/@rbxts", "node_modules/@trioforge"]
+	```
+
+2. In your Rojo project, map it beside `@rbxts` under `rbxts_include/node_modules`:
+
+	```json
+	"node_modules": {
+		"$className": "Folder",
+		"@rbxts": { "$path": "node_modules/@rbxts" },
+		"@trioforge": { "$path": "node_modules/@trioforge" }
+	}
+	```
+
+## Example
+
+```ts
+import { CommandDispatcher, argument, getInteger, getString, integer, literal, word } from "@trioforge/brigadier";
+
+const dispatcher = new CommandDispatcher<Player>();
+
+dispatcher.register(
+	literal<Player>("give").then(
+		argument<Player, string>("target", word()).then(
+			argument<Player, number>("amount", integer(1, 100)).executes((context) => {
+				const target = getString(context, "target");
+				const amount = getInteger(context, "amount");
+				print(`${context.getSource().Name} gives ${amount} to ${target}`);
+				return 1;
+			}),
+		),
+	),
+);
+
+dispatcher.execute("give Bob 50", player);
+// → Ann gives 50 to Bob
+```
+
+A command that fails to parse throws a `CommandSyntaxException`. Its `getMessage()` names the problem and points at the character, such as `Integer must not be more than 100, found 500 at position 9: give Bob <--[HERE]`.
+
+## Differences from the Java
+
+The names are Brigadier's. [docs/porting.md](docs/porting.md) lists every place the port differs, such as Promises instead of `CompletableFuture` and `stringArg()` instead of `string()`.
+
+## Development
+
+Install the Node tools with `pnpm install`, and Lune and StyLua with `rokit install`.
+
+```sh
+pnpm run check   # oxfmt, rbxtsc, StyLua, the tests and the README example
+pnpm run test    # build, then run the tests
+```
+
+The tests in `test/` are Brigadier's JUnit tests, ported to Luau one to one. `test/lib/runtime.luau` loads the compiled package from `out/` through roblox-ts's runtime, as a place does, and Lune runs them. [AGENTS.md](AGENTS.md) has the rules for changing the port.
+
+## License
+
+MIT, like Brigadier. See [LICENSE](LICENSE).

package/out/arguments.d.ts

@@ -0,0 +1,91 @@
+import type { CommandContext } from "./context";
+import { StringReader } from "./string-reader";
+import type { Suggestions, SuggestionsBuilder } from "./suggestion";
+export interface ArgumentType<T> {
+    parse(reader: StringReader, source?: unknown): T;
+    listSuggestions?<S>(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+    getExamples?(): readonly string[];
+}
+export declare class BoolArgumentType implements ArgumentType<boolean> {
+    parse(reader: StringReader): boolean;
+    listSuggestions<S>(_context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+    getExamples(): readonly string[];
+}
+export declare function bool(): BoolArgumentType;
+export declare function getBool<S>(context: CommandContext<S>, name: string): boolean;
+export declare class IntegerArgumentType implements ArgumentType<number> {
+    private readonly minimum;
+    private readonly maximum;
+    constructor(minimum: number, maximum: number);
+    getMinimum(): number;
+    getMaximum(): number;
+    parse(reader: StringReader): number;
+    equals(other: unknown): boolean;
+    toString(): string;
+    getExamples(): readonly string[];
+}
+export declare function integer(min?: number, max?: number): IntegerArgumentType;
+export declare function getInteger<S>(context: CommandContext<S>, name: string): number;
+export declare class LongArgumentType implements ArgumentType<number> {
+    private readonly minimum;
+    private readonly maximum;
+    constructor(minimum: number, maximum: number);
+    getMinimum(): number;
+    getMaximum(): number;
+    parse(reader: StringReader): number;
+    equals(other: unknown): boolean;
+    toString(): string;
+    getExamples(): readonly string[];
+}
+export declare function longArg(min?: number, max?: number): LongArgumentType;
+export declare function getLong<S>(context: CommandContext<S>, name: string): number;
+export declare class DoubleArgumentType implements ArgumentType<number> {
+    private readonly minimum;
+    private readonly maximum;
+    constructor(minimum: number, maximum: number);
+    getMinimum(): number;
+    getMaximum(): number;
+    parse(reader: StringReader): number;
+    equals(other: unknown): boolean;
+    toString(): string;
+    getExamples(): readonly string[];
+}
+export declare function doubleArg(min?: number, max?: number): DoubleArgumentType;
+export declare function getDouble<S>(context: CommandContext<S>, name: string): number;
+export declare class FloatArgumentType implements ArgumentType<number> {
+    private readonly minimum;
+    private readonly maximum;
+    constructor(minimum: number, maximum: number);
+    getMinimum(): number;
+    getMaximum(): number;
+    parse(reader: StringReader): number;
+    equals(other: unknown): boolean;
+    toString(): string;
+    getExamples(): readonly string[];
+}
+export declare function floatArg(min?: number, max?: number): FloatArgumentType;
+export declare function getFloat<S>(context: CommandContext<S>, name: string): number;
+export declare class StringType {
+    private readonly constantName;
+    private readonly examples;
+    static readonly SINGLE_WORD: StringType;
+    static readonly QUOTABLE_PHRASE: StringType;
+    static readonly GREEDY_PHRASE: StringType;
+    private constructor();
+    name(): string;
+    getExamples(): readonly string[];
+    toString(): string;
+}
+export declare class StringArgumentType implements ArgumentType<string> {
+    private readonly stringType;
+    constructor(stringType: StringType);
+    getType(): StringType;
+    parse(reader: StringReader): string;
+    toString(): string;
+    getExamples(): readonly string[];
+}
+export declare function word(): StringArgumentType;
+export declare function stringArg(): StringArgumentType;
+export declare function greedyString(): StringArgumentType;
+export declare function getString<S>(context: CommandContext<S>, name: string): string;
+export declare function escapeIfRequired(input: string): string;

package/out/arguments.luau

@@ -0,0 +1,475 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local CommandSyntaxException = TS.import(script, script.Parent, "exceptions").CommandSyntaxException
+local _java = TS.import(script, script.Parent, "java")
+local formatDouble = _java.formatDouble
+local formatFloat = _java.formatFloat
+local formatInteger = _java.formatInteger
+local startsWith = _java.startsWith
+local toFloat = _java.toFloat
+local StringReader = TS.import(script, script.Parent, "string-reader").StringReader
+-- Java's default methods are optional: a type without listSuggestions suggests nothing, and one without
+-- getExamples has none.
+local BOOL_EXAMPLES = { "true", "false" }
+local BoolArgumentType
+do
+	BoolArgumentType = setmetatable({}, {
+		__tostring = function()
+			return "BoolArgumentType"
+		end,
+	})
+	BoolArgumentType.__index = BoolArgumentType
+	function BoolArgumentType.new(...)
+		local self = setmetatable({}, BoolArgumentType)
+		return self:constructor(...) or self
+	end
+	function BoolArgumentType:constructor()
+	end
+	function BoolArgumentType:parse(reader)
+		return reader:readBoolean()
+	end
+	function BoolArgumentType:listSuggestions(_context, builder)
+		if startsWith("true", builder:getRemainingLowerCase()) then
+			builder:suggest("true")
+		end
+		if startsWith("false", builder:getRemainingLowerCase()) then
+			builder:suggest("false")
+		end
+		return builder:buildFuture()
+	end
+	function BoolArgumentType:getExamples()
+		return BOOL_EXAMPLES
+	end
+end
+local function bool()
+	return BoolArgumentType.new()
+end
+local function getBool(context, name)
+	return context:getArgument(name, "boolean")
+end
+local INTEGER_EXAMPLES = { "0", "123", "-123" }
+local INTEGER_MIN = -2147483648
+local INTEGER_MAX = 2147483647
+local IntegerArgumentType
+do
+	IntegerArgumentType = setmetatable({}, {
+		__tostring = function()
+			return "IntegerArgumentType"
+		end,
+	})
+	IntegerArgumentType.__index = IntegerArgumentType
+	function IntegerArgumentType.new(...)
+		local self = setmetatable({}, IntegerArgumentType)
+		return self:constructor(...) or self
+	end
+	function IntegerArgumentType:constructor(minimum, maximum)
+		self.minimum = minimum
+		self.maximum = maximum
+	end
+	function IntegerArgumentType:getMinimum()
+		return self.minimum
+	end
+	function IntegerArgumentType:getMaximum()
+		return self.maximum
+	end
+	function IntegerArgumentType:parse(reader)
+		local start = reader:getCursor()
+		local result = reader:readInt()
+		if result < self.minimum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:integerTooLow():createWithContext(reader, result, self.minimum))
+		end
+		if result > self.maximum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:integerTooHigh():createWithContext(reader, result, self.maximum))
+		end
+		return result
+	end
+	function IntegerArgumentType:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, IntegerArgumentType)) then
+			return false
+		end
+		return self.maximum == other.maximum and self.minimum == other.minimum
+	end
+	function IntegerArgumentType:toString()
+		if self.minimum == INTEGER_MIN and self.maximum == INTEGER_MAX then
+			return "integer()"
+		elseif self.maximum == INTEGER_MAX then
+			return `integer({formatInteger(self.minimum)})`
+		end
+		return `integer({formatInteger(self.minimum)}, {formatInteger(self.maximum)})`
+	end
+	function IntegerArgumentType:getExamples()
+		return INTEGER_EXAMPLES
+	end
+	function IntegerArgumentType:__tostring()
+		return self:toString()
+	end
+end
+local function integer(min, max)
+	if min == nil then
+		min = INTEGER_MIN
+	end
+	if max == nil then
+		max = INTEGER_MAX
+	end
+	return IntegerArgumentType.new(min, max)
+end
+local function getInteger(context, name)
+	return context:getArgument(name, "number")
+end
+local LONG_MIN = -(2 ^ 63)
+local LONG_MAX = 2 ^ 63
+local LongArgumentType
+do
+	LongArgumentType = setmetatable({}, {
+		__tostring = function()
+			return "LongArgumentType"
+		end,
+	})
+	LongArgumentType.__index = LongArgumentType
+	function LongArgumentType.new(...)
+		local self = setmetatable({}, LongArgumentType)
+		return self:constructor(...) or self
+	end
+	function LongArgumentType:constructor(minimum, maximum)
+		self.minimum = minimum
+		self.maximum = maximum
+	end
+	function LongArgumentType:getMinimum()
+		return self.minimum
+	end
+	function LongArgumentType:getMaximum()
+		return self.maximum
+	end
+	function LongArgumentType:parse(reader)
+		local start = reader:getCursor()
+		local result = reader:readLong()
+		if result < self.minimum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:longTooLow():createWithContext(reader, result, self.minimum))
+		end
+		if result > self.maximum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:longTooHigh():createWithContext(reader, result, self.maximum))
+		end
+		return result
+	end
+	function LongArgumentType:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, LongArgumentType)) then
+			return false
+		end
+		return self.maximum == other.maximum and self.minimum == other.minimum
+	end
+	function LongArgumentType:toString()
+		if self.minimum == LONG_MIN and self.maximum == LONG_MAX then
+			return "longArg()"
+		elseif self.maximum == LONG_MAX then
+			return `longArg({formatInteger(self.minimum)})`
+		end
+		return `longArg({formatInteger(self.minimum)}, {formatInteger(self.maximum)})`
+	end
+	function LongArgumentType:getExamples()
+		return INTEGER_EXAMPLES
+	end
+	function LongArgumentType:__tostring()
+		return self:toString()
+	end
+end
+local function longArg(min, max)
+	if min == nil then
+		min = LONG_MIN
+	end
+	if max == nil then
+		max = LONG_MAX
+	end
+	return LongArgumentType.new(min, max)
+end
+local function getLong(context, name)
+	return context:getArgument(name, "number")
+end
+local DECIMAL_EXAMPLES = { "0", "1.2", ".5", "-1", "-.5", "-1234.56" }
+local DOUBLE_MIN = -1.7976931348623157e308
+local DOUBLE_MAX = 1.7976931348623157e308
+local DoubleArgumentType
+do
+	DoubleArgumentType = setmetatable({}, {
+		__tostring = function()
+			return "DoubleArgumentType"
+		end,
+	})
+	DoubleArgumentType.__index = DoubleArgumentType
+	function DoubleArgumentType.new(...)
+		local self = setmetatable({}, DoubleArgumentType)
+		return self:constructor(...) or self
+	end
+	function DoubleArgumentType:constructor(minimum, maximum)
+		self.minimum = minimum
+		self.maximum = maximum
+	end
+	function DoubleArgumentType:getMinimum()
+		return self.minimum
+	end
+	function DoubleArgumentType:getMaximum()
+		return self.maximum
+	end
+	function DoubleArgumentType:parse(reader)
+		local start = reader:getCursor()
+		local result = reader:readDouble()
+		if result < self.minimum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:doubleTooLow():createWithContext(reader, result, self.minimum))
+		end
+		if result > self.maximum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:doubleTooHigh():createWithContext(reader, result, self.maximum))
+		end
+		return result
+	end
+	function DoubleArgumentType:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, DoubleArgumentType)) then
+			return false
+		end
+		return self.maximum == other.maximum and self.minimum == other.minimum
+	end
+	function DoubleArgumentType:toString()
+		if self.minimum == DOUBLE_MIN and self.maximum == DOUBLE_MAX then
+			return "double()"
+		elseif self.maximum == DOUBLE_MAX then
+			return `double({formatDouble(self.minimum)})`
+		end
+		return `double({formatDouble(self.minimum)}, {formatDouble(self.maximum)})`
+	end
+	function DoubleArgumentType:getExamples()
+		return DECIMAL_EXAMPLES
+	end
+	function DoubleArgumentType:__tostring()
+		return self:toString()
+	end
+end
+local function doubleArg(min, max)
+	if min == nil then
+		min = DOUBLE_MIN
+	end
+	if max == nil then
+		max = DOUBLE_MAX
+	end
+	return DoubleArgumentType.new(min, max)
+end
+local function getDouble(context, name)
+	return context:getArgument(name, "number")
+end
+local FLOAT_MIN = -3.4028234663852886e38
+local FLOAT_MAX = 3.4028234663852886e38
+local FloatArgumentType
+do
+	FloatArgumentType = setmetatable({}, {
+		__tostring = function()
+			return "FloatArgumentType"
+		end,
+	})
+	FloatArgumentType.__index = FloatArgumentType
+	function FloatArgumentType.new(...)
+		local self = setmetatable({}, FloatArgumentType)
+		return self:constructor(...) or self
+	end
+	function FloatArgumentType:constructor(minimum, maximum)
+		self.minimum = toFloat(minimum)
+		self.maximum = toFloat(maximum)
+	end
+	function FloatArgumentType:getMinimum()
+		return self.minimum
+	end
+	function FloatArgumentType:getMaximum()
+		return self.maximum
+	end
+	function FloatArgumentType:parse(reader)
+		local start = reader:getCursor()
+		local result = reader:readFloat()
+		if result < self.minimum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:floatTooLow():createWithContext(reader, result, self.minimum))
+		end
+		if result > self.maximum then
+			reader:setCursor(start)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:floatTooHigh():createWithContext(reader, result, self.maximum))
+		end
+		return result
+	end
+	function FloatArgumentType:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, FloatArgumentType)) then
+			return false
+		end
+		return self.maximum == other.maximum and self.minimum == other.minimum
+	end
+	function FloatArgumentType:toString()
+		if self.minimum == FLOAT_MIN and self.maximum == FLOAT_MAX then
+			return "float()"
+		elseif self.maximum == FLOAT_MAX then
+			return `float({formatFloat(self.minimum)})`
+		end
+		return `float({formatFloat(self.minimum)}, {formatFloat(self.maximum)})`
+	end
+	function FloatArgumentType:getExamples()
+		return DECIMAL_EXAMPLES
+	end
+	function FloatArgumentType:__tostring()
+		return self:toString()
+	end
+end
+local function floatArg(min, max)
+	if min == nil then
+		min = FLOAT_MIN
+	end
+	if max == nil then
+		max = FLOAT_MAX
+	end
+	return FloatArgumentType.new(min, max)
+end
+local function getFloat(context, name)
+	return context:getArgument(name, "number")
+end
+local StringType
+do
+	StringType = setmetatable({}, {
+		__tostring = function()
+			return "StringType"
+		end,
+	})
+	StringType.__index = StringType
+	function StringType.new(...)
+		local self = setmetatable({}, StringType)
+		return self:constructor(...) or self
+	end
+	function StringType:constructor(constantName, examples)
+		self.constantName = constantName
+		self.examples = examples
+	end
+	function StringType:name()
+		return self.constantName
+	end
+	function StringType:getExamples()
+		return self.examples
+	end
+	function StringType:toString()
+		return self.constantName
+	end
+	function StringType:__tostring()
+		return self:toString()
+	end
+	StringType.SINGLE_WORD = StringType.new("SINGLE_WORD", { "word", "words_with_underscores" })
+	StringType.QUOTABLE_PHRASE = StringType.new("QUOTABLE_PHRASE", { '"quoted phrase"', "word", '""' })
+	StringType.GREEDY_PHRASE = StringType.new("GREEDY_PHRASE", { "word", "words with spaces", '"and symbols"' })
+end
+local StringArgumentType
+do
+	StringArgumentType = setmetatable({}, {
+		__tostring = function()
+			return "StringArgumentType"
+		end,
+	})
+	StringArgumentType.__index = StringArgumentType
+	function StringArgumentType.new(...)
+		local self = setmetatable({}, StringArgumentType)
+		return self:constructor(...) or self
+	end
+	function StringArgumentType:constructor(stringType)
+		self.stringType = stringType
+	end
+	function StringArgumentType:getType()
+		return self.stringType
+	end
+	function StringArgumentType:parse(reader)
+		if self.stringType == StringType.GREEDY_PHRASE then
+			local text = reader:getRemaining()
+			reader:setCursor(reader:getTotalLength())
+			return text
+		elseif self.stringType == StringType.SINGLE_WORD then
+			return reader:readUnquotedString()
+		end
+		return reader:readString()
+	end
+	function StringArgumentType:toString()
+		return "string()"
+	end
+	function StringArgumentType:getExamples()
+		return self.stringType:getExamples()
+	end
+	function StringArgumentType:__tostring()
+		return self:toString()
+	end
+end
+local function word()
+	return StringArgumentType.new(StringType.SINGLE_WORD)
+end
+local function stringArg()
+	return StringArgumentType.new(StringType.QUOTABLE_PHRASE)
+end
+local function greedyString()
+	return StringArgumentType.new(StringType.GREEDY_PHRASE)
+end
+local function getString(context, name)
+	return context:getArgument(name, "string")
+end
+local function escape(input)
+	local result = { '"' }
+	for index = 1, #input do
+		local _input = input
+		local _index = index
+		local _index_1 = index
+		local c = string.sub(_input, _index, _index_1)
+		if c == "\\" or c == '"' then
+			table.insert(result, "\\")
+		end
+		table.insert(result, c)
+	end
+	table.insert(result, '"')
+	return table.concat(result, "")
+end
+local function escapeIfRequired(input)
+	for index = 1, #input do
+		local _input = input
+		local _index = index
+		local _index_1 = index
+		if not StringReader:isAllowedInUnquotedString(string.sub(_input, _index, _index_1)) then
+			return escape(input)
+		end
+	end
+	return input
+end
+return {
+	bool = bool,
+	getBool = getBool,
+	integer = integer,
+	getInteger = getInteger,
+	longArg = longArg,
+	getLong = getLong,
+	doubleArg = doubleArg,
+	getDouble = getDouble,
+	floatArg = floatArg,
+	getFloat = getFloat,
+	word = word,
+	stringArg = stringArg,
+	greedyString = greedyString,
+	getString = getString,
+	escapeIfRequired = escapeIfRequired,
+	BoolArgumentType = BoolArgumentType,
+	IntegerArgumentType = IntegerArgumentType,
+	LongArgumentType = LongArgumentType,
+	DoubleArgumentType = DoubleArgumentType,
+	FloatArgumentType = FloatArgumentType,
+	StringType = StringType,
+	StringArgumentType = StringArgumentType,
+}

package/out/command-dispatcher.d.ts

@@ -0,0 +1,38 @@
+import type { AmbiguityConsumer, ResultConsumer } from "./command";
+import { CommandContextBuilder } from "./context";
+import { CommandSyntaxException } from "./exceptions";
+import { type ImmutableStringReader, StringReader } from "./string-reader";
+import { Suggestions } from "./suggestion";
+import { type CommandNode, type LiteralArgumentBuilder, type LiteralCommandNode, RootCommandNode } from "./tree";
+export declare class ParseResults<S> {
+    private readonly context;
+    private readonly reader;
+    private readonly exceptions;
+    constructor(context: CommandContextBuilder<S>, reader?: ImmutableStringReader, exceptions?: ReadonlyMap<CommandNode<S>, CommandSyntaxException>);
+    getContext(): CommandContextBuilder<S>;
+    getReader(): ImmutableStringReader;
+    getExceptions(): ReadonlyMap<CommandNode<S>, CommandSyntaxException>;
+}
+export declare class CommandDispatcher<S> {
+    static readonly ARGUMENT_SEPARATOR = " ";
+    static readonly ARGUMENT_SEPARATOR_CHAR = " ";
+    private readonly root;
+    private consumer;
+    constructor(root?: RootCommandNode<S>);
+    register(command: LiteralArgumentBuilder<S>): LiteralCommandNode<S>;
+    setConsumer(consumer: ResultConsumer<S>): void;
+    execute(input: string | StringReader, source: S): number;
+    execute(parse: ParseResults<S>): number;
+    private executeParse;
+    parse(command: string | StringReader, source: S): ParseResults<S>;
+    private parseNodes;
+    getAllUsage(node: CommandNode<S>, source: S, restricted: boolean): string[];
+    private getAllUsageRecursive;
+    getSmartUsage(node: CommandNode<S>, source: S): Map<CommandNode<S>, string>;
+    private getSmartUsageRecursive;
+    getCompletionSuggestions(parse: ParseResults<S>, cursor?: number): Promise<Suggestions>;
+    getRoot(): RootCommandNode<S>;
+    getPath(target: CommandNode<S>): string[];
+    findNode(path: readonly string[]): CommandNode<S> | undefined;
+    findAmbiguities(consumer: AmbiguityConsumer<S>): void;
+}