@wq2/brigadier-ts 1.0.0

package/dist/ParseResults.d.ts

@@ -0,0 +1,10 @@
+import { CommandContextBuilder, StringReader, CommandNode, CommandSyntaxError } from ".";
+export declare class ParseResults<S> {
+    private context;
+    private reader;
+    private errors;
+    constructor(context: CommandContextBuilder<S>, reader: StringReader, errors: Map<CommandNode<S>, CommandSyntaxError>);
+    getContext(): CommandContextBuilder<S>;
+    getReader(): StringReader;
+    getErrors(): Map<CommandNode<S>, CommandSyntaxError>;
+}

package/dist/ParseResults.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseResults = void 0;
+var ParseResults = /** @class */ (function () {
+    function ParseResults(context, reader, errors) {
+        this.context = context;
+        this.reader = reader;
+        this.errors = errors;
+    }
+    ParseResults.prototype.getContext = function () {
+        return this.context;
+    };
+    ParseResults.prototype.getReader = function () {
+        return this.reader;
+    };
+    ParseResults.prototype.getErrors = function () {
+        return this.errors;
+    };
+    return ParseResults;
+}());
+exports.ParseResults = ParseResults;

package/dist/Predicate.d.ts

@@ -0,0 +1 @@
+export type Predicate<S> = (c: S) => Promise<boolean>;

package/dist/Predicate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/StringReader.d.ts

@@ -0,0 +1,26 @@
+export declare class StringReader {
+    private string;
+    private cursor;
+    constructor(string: string | StringReader);
+    getString(): string;
+    getCursor(): number;
+    setCursor(cursor: number): void;
+    getRemainingLength(): number;
+    getTotalLength(): number;
+    getRead(): string;
+    getRemaining(): string;
+    canRead(length?: number): boolean;
+    peek(offset?: number): string;
+    read(): string;
+    skip(): void;
+    isAllowedNumber(c: string): boolean;
+    readInt(): number;
+    readLong(): BigInt;
+    readFloat(): number;
+    isAllowedInUnquotedString(c: string): boolean;
+    isQuotedStringStart(c: string): boolean;
+    readUnquotedString(): string;
+    readStringUntil(terminator: string): string;
+    readString(): string;
+    readBoolean(): boolean;
+}

package/dist/StringReader.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringReader = void 0;
+var CommandSyntaxError_1 = require("./exceptions/CommandSyntaxError");
+var StringReader = /** @class */ (function () {
+    function StringReader(string) {
+        if (string instanceof StringReader) {
+            this.string = string.getString();
+            this.cursor = string.getCursor();
+        }
+        else {
+            this.string = string;
+            this.cursor = 0;
+        }
+    }
+    StringReader.prototype.getString = function () {
+        return this.string;
+    };
+    StringReader.prototype.getCursor = function () {
+        return this.cursor;
+    };
+    StringReader.prototype.setCursor = function (cursor) {
+        this.cursor = cursor;
+    };
+    StringReader.prototype.getRemainingLength = function () {
+        return this.string.length - this.cursor;
+    };
+    StringReader.prototype.getTotalLength = function () {
+        return this.string.length;
+    };
+    StringReader.prototype.getRead = function () {
+        return this.string.substring(0, this.cursor);
+    };
+    StringReader.prototype.getRemaining = function () {
+        return this.string.substring(this.cursor);
+    };
+    StringReader.prototype.canRead = function (length) {
+        if (length === void 0) { length = 1; }
+        return this.cursor + length <= this.string.length;
+    };
+    StringReader.prototype.peek = function (offset) {
+        if (offset === void 0) { offset = 0; }
+        return this.string.charAt(this.cursor + offset);
+    };
+    StringReader.prototype.read = function () {
+        var char = this.string.charAt(this.cursor);
+        this.cursor += 1;
+        return char;
+    };
+    StringReader.prototype.skip = function () {
+        this.cursor += 1;
+    };
+    StringReader.prototype.isAllowedNumber = function (c) {
+        return c >= "0" && c <= "9" || c === "." || c === "-";
+    };
+    StringReader.prototype.readInt = function () {
+        var start = this.cursor;
+        while (this.canRead() && this.isAllowedNumber(this.peek())) {
+            this.skip();
+        }
+        var number = this.string.substring(start, this.cursor);
+        if (number.length === 0) {
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
+        }
+        try {
+            var value = Number(number);
+            if (isNaN(value) || !Number.isInteger(value)) {
+                throw new Error();
+            }
+            return value;
+        }
+        catch (e) {
+            this.cursor = start;
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
+        }
+    };
+    StringReader.prototype.readLong = function () {
+        var start = this.cursor;
+        while (this.canRead() && this.isAllowedNumber(this.peek())) {
+            this.skip();
+        }
+        var number = this.string.substring(start, this.cursor);
+        if (number.length === 0) {
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
+        }
+        try {
+            return BigInt(number);
+        }
+        catch (e) {
+            this.cursor = start;
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
+        }
+    };
+    StringReader.prototype.readFloat = function () {
+        var start = this.cursor;
+        while (this.canRead() && this.isAllowedNumber(this.peek())) {
+            this.skip();
+        }
+        var number = this.string.substring(start, this.cursor);
+        if (number.length === 0) {
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_FLOAT.createWithContext(this);
+        }
+        try {
+            var value = Number(number);
+            if (isNaN(value)) {
+                throw new Error();
+            }
+            return value;
+        }
+        catch (e) {
+            this.cursor = start;
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_FLOAT.createWithContext(this, number);
+        }
+    };
+    StringReader.prototype.isAllowedInUnquotedString = function (c) {
+        return c >= "0" && c <= "9"
+            || c >= "A" && c <= "Z"
+            || c >= "a" && c <= "z"
+            || c == "_" || c == "-"
+            || c == "." || c == "+";
+    };
+    StringReader.prototype.isQuotedStringStart = function (c) {
+        return c === "'" || c === "\"";
+    };
+    StringReader.prototype.readUnquotedString = function () {
+        var start = this.cursor;
+        while (this.canRead() && this.isAllowedInUnquotedString(this.peek())) {
+            this.skip();
+        }
+        return this.string.substring(start, this.cursor);
+    };
+    StringReader.prototype.readStringUntil = function (terminator) {
+        var result = [];
+        var escaped = false;
+        while (this.canRead()) {
+            var c = this.read();
+            if (escaped) {
+                if (c === terminator || c === "\\") {
+                    result.push(c);
+                    escaped = false;
+                }
+                else {
+                    this.setCursor(this.cursor - 1);
+                    throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_ESCAPE.createWithContext(this, c);
+                }
+            }
+            else if (c === "\\") {
+                escaped = true;
+            }
+            else if (c === terminator) {
+                return result.join("");
+            }
+            else {
+                result.push(c);
+            }
+        }
+        throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_END_OF_QUOTE.createWithContext(this);
+    };
+    StringReader.prototype.readString = function () {
+        if (!this.canRead()) {
+            return "";
+        }
+        var next = this.peek();
+        if (this.isQuotedStringStart(next)) {
+            this.skip();
+            return this.readStringUntil(next);
+        }
+        return this.readUnquotedString();
+    };
+    StringReader.prototype.readBoolean = function () {
+        var start = this.cursor;
+        var value = this.readUnquotedString();
+        if (value.length === 0) {
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_BOOL.createWithContext(this);
+        }
+        if (value === "true") {
+            return true;
+        }
+        else if (value === "false") {
+            return false;
+        }
+        else {
+            throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_BOOL.createWithContext(this, value);
+        }
+    };
+    return StringReader;
+}());
+exports.StringReader = StringReader;

package/dist/arguments/ArgumentType.d.ts

@@ -0,0 +1,5 @@
+import { StringReader, CommandContext, Suggestions, SuggestionsBuilder } from "..";
+export declare abstract class ArgumentType<T> {
+    abstract parse(reader: StringReader): T;
+    listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions>;
+}

package/dist/arguments/ArgumentType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentType = void 0;
+var __1 = require("..");
+var ArgumentType = /** @class */ (function () {
+    function ArgumentType() {
+    }
+    ArgumentType.prototype.listSuggestions = function (context, builder) {
+        return __1.Suggestions.empty();
+    };
+    return ArgumentType;
+}());
+exports.ArgumentType = ArgumentType;

package/dist/arguments/BoolArgumentType.d.ts

@@ -0,0 +1,6 @@
+import { ArgumentType, StringReader, CommandContext, SuggestionsBuilder, Suggestions } from "..";
+export declare class BoolArgumentType extends ArgumentType<boolean> {
+    parse(reader: StringReader): boolean;
+    listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions>;
+}
+export declare function bool(): BoolArgumentType;

package/dist/arguments/BoolArgumentType.js

@@ -0,0 +1,43 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoolArgumentType = void 0;
+exports.bool = bool;
+var __1 = require("..");
+var BoolArgumentType = /** @class */ (function (_super) {
+    __extends(BoolArgumentType, _super);
+    function BoolArgumentType() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BoolArgumentType.prototype.parse = function (reader) {
+        return reader.readBoolean();
+    };
+    BoolArgumentType.prototype.listSuggestions = function (context, builder) {
+        if ("true".startsWith(builder.getRemaining().toLowerCase())) {
+            builder.suggest("true");
+        }
+        if ("false".startsWith(builder.getRemaining().toLowerCase())) {
+            builder.suggest("false");
+        }
+        return builder.buildPromise();
+    };
+    return BoolArgumentType;
+}(__1.ArgumentType));
+exports.BoolArgumentType = BoolArgumentType;
+function bool() {
+    return new BoolArgumentType();
+}

package/dist/arguments/FloatArgumentType.d.ts

@@ -0,0 +1,7 @@
+import { StringReader, NumberArgumentType } from "..";
+export declare class FloatArgumentType extends NumberArgumentType {
+    constructor(minimum?: number, maximum?: number);
+    readNumber(reader: StringReader): number;
+    getTooSmallError(): import("..").CommandErrorType;
+    getTooBigError(): import("..").CommandErrorType;
+}

package/dist/arguments/FloatArgumentType.js

@@ -0,0 +1,38 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatArgumentType = void 0;
+var __1 = require("..");
+var FloatArgumentType = /** @class */ (function (_super) {
+    __extends(FloatArgumentType, _super);
+    function FloatArgumentType(minimum, maximum) {
+        if (minimum === void 0) { minimum = -Infinity; }
+        if (maximum === void 0) { maximum = Infinity; }
+        return _super.call(this, minimum, maximum) || this;
+    }
+    FloatArgumentType.prototype.readNumber = function (reader) {
+        return reader.readFloat();
+    };
+    FloatArgumentType.prototype.getTooSmallError = function () {
+        return __1.CommandSyntaxError.FLOAT_TOO_SMALL;
+    };
+    FloatArgumentType.prototype.getTooBigError = function () {
+        return __1.CommandSyntaxError.FLOAT_TOO_BIG;
+    };
+    return FloatArgumentType;
+}(__1.NumberArgumentType));
+exports.FloatArgumentType = FloatArgumentType;

package/dist/arguments/IntegerArgumentType.d.ts

@@ -0,0 +1,7 @@
+import { StringReader, NumberArgumentType } from "..";
+export declare class IntegerArgumentType extends NumberArgumentType {
+    constructor(minimum?: number, maximum?: number);
+    readNumber(reader: StringReader): number;
+    getTooSmallError(): import("..").CommandErrorType;
+    getTooBigError(): import("..").CommandErrorType;
+}

package/dist/arguments/IntegerArgumentType.js

@@ -0,0 +1,38 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerArgumentType = void 0;
+var __1 = require("..");
+var IntegerArgumentType = /** @class */ (function (_super) {
+    __extends(IntegerArgumentType, _super);
+    function IntegerArgumentType(minimum, maximum) {
+        if (minimum === void 0) { minimum = -2147483648; }
+        if (maximum === void 0) { maximum = 2147483647; }
+        return _super.call(this, minimum, maximum) || this;
+    }
+    IntegerArgumentType.prototype.readNumber = function (reader) {
+        return reader.readInt();
+    };
+    IntegerArgumentType.prototype.getTooSmallError = function () {
+        return __1.CommandSyntaxError.INTEGER_TOO_SMALL;
+    };
+    IntegerArgumentType.prototype.getTooBigError = function () {
+        return __1.CommandSyntaxError.INTEGER_TOO_BIG;
+    };
+    return IntegerArgumentType;
+}(__1.NumberArgumentType));
+exports.IntegerArgumentType = IntegerArgumentType;

package/dist/arguments/LongArgumentType.d.ts

@@ -0,0 +1,9 @@
+import { StringReader, NumberArgumentType } from "..";
+export declare class LongArgumentType extends NumberArgumentType<BigInt> {
+    private static readonly MIN;
+    private static readonly MAX;
+    constructor(minimum?: bigint, maximum?: bigint);
+    readNumber(reader: StringReader): BigInt;
+    getTooSmallError(): import("..").CommandErrorType;
+    getTooBigError(): import("..").CommandErrorType;
+}

package/dist/arguments/LongArgumentType.js

@@ -0,0 +1,40 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LongArgumentType = void 0;
+var __1 = require("..");
+var LongArgumentType = /** @class */ (function (_super) {
+    __extends(LongArgumentType, _super);
+    function LongArgumentType(minimum, maximum) {
+        if (minimum === void 0) { minimum = LongArgumentType.MIN; }
+        if (maximum === void 0) { maximum = LongArgumentType.MAX; }
+        return _super.call(this, minimum, maximum) || this;
+    }
+    LongArgumentType.prototype.readNumber = function (reader) {
+        return reader.readLong();
+    };
+    LongArgumentType.prototype.getTooSmallError = function () {
+        return __1.CommandSyntaxError.LONG_TOO_SMALL;
+    };
+    LongArgumentType.prototype.getTooBigError = function () {
+        return __1.CommandSyntaxError.LONG_TOO_BIG;
+    };
+    LongArgumentType.MIN = BigInt("-9223372036854775808");
+    LongArgumentType.MAX = BigInt("9223372036854775807");
+    return LongArgumentType;
+}(__1.NumberArgumentType));
+exports.LongArgumentType = LongArgumentType;

package/dist/arguments/NumberArgumentType.d.ts

@@ -0,0 +1,12 @@
+import { ArgumentType, StringReader, CommandErrorType } from "..";
+export declare abstract class NumberArgumentType<N extends number | BigInt = number> extends ArgumentType<N> {
+    private minimum;
+    private maximum;
+    constructor(minimum: N, maximum: N);
+    getMinimum(): N;
+    getMaximum(): N;
+    parse(reader: StringReader): N;
+    abstract readNumber(reader: StringReader): N;
+    abstract getTooSmallError(): CommandErrorType;
+    abstract getTooBigError(): CommandErrorType;
+}

package/dist/arguments/NumberArgumentType.js

@@ -0,0 +1,49 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberArgumentType = void 0;
+var __1 = require("..");
+var NumberArgumentType = /** @class */ (function (_super) {
+    __extends(NumberArgumentType, _super);
+    function NumberArgumentType(minimum, maximum) {
+        var _this = _super.call(this) || this;
+        _this.minimum = minimum;
+        _this.maximum = maximum;
+        return _this;
+    }
+    NumberArgumentType.prototype.getMinimum = function () {
+        return this.minimum;
+    };
+    NumberArgumentType.prototype.getMaximum = function () {
+        return this.maximum;
+    };
+    NumberArgumentType.prototype.parse = function (reader) {
+        var start = reader.getCursor();
+        var result = this.readNumber(reader);
+        if (result < this.minimum) {
+            reader.setCursor(start);
+            throw this.getTooSmallError().createWithContext(reader, result, this.minimum);
+        }
+        else if (result > this.maximum) {
+            reader.setCursor(start);
+            throw this.getTooBigError().createWithContext(reader, result, this.maximum);
+        }
+        return result;
+    };
+    return NumberArgumentType;
+}(__1.ArgumentType));
+exports.NumberArgumentType = NumberArgumentType;

package/dist/arguments/StringArgumentType.d.ts

@@ -0,0 +1,12 @@
+import { ArgumentType, StringReader } from "..";
+type StringType = "single_word" | "quotable_phrase" | "greedy_phrase";
+export declare class StringArgumentType extends ArgumentType<string> {
+    private type;
+    constructor(type: StringType);
+    getType(): StringType;
+    parse(reader: StringReader): string;
+}
+export declare function word(): StringArgumentType;
+export declare function string(): StringArgumentType;
+export declare function greedyString(): StringArgumentType;
+export {};

package/dist/arguments/StringArgumentType.js

@@ -0,0 +1,57 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringArgumentType = void 0;
+exports.word = word;
+exports.string = string;
+exports.greedyString = greedyString;
+var __1 = require("..");
+var StringArgumentType = /** @class */ (function (_super) {
+    __extends(StringArgumentType, _super);
+    function StringArgumentType(type) {
+        var _this = _super.call(this) || this;
+        _this.type = type;
+        return _this;
+    }
+    StringArgumentType.prototype.getType = function () {
+        return this.type;
+    };
+    StringArgumentType.prototype.parse = function (reader) {
+        if (this.type === "greedy_phrase") {
+            var text = reader.getRemaining();
+            reader.setCursor(reader.getTotalLength());
+            return text;
+        }
+        else if (this.type === "single_word") {
+            return reader.readUnquotedString();
+        }
+        else {
+            return reader.readString();
+        }
+    };
+    return StringArgumentType;
+}(__1.ArgumentType));
+exports.StringArgumentType = StringArgumentType;
+function word() {
+    return new StringArgumentType("single_word");
+}
+function string() {
+    return new StringArgumentType("quotable_phrase");
+}
+function greedyString() {
+    return new StringArgumentType("greedy_phrase");
+}

package/dist/builder/ArgumentBuilder.d.ts

@@ -0,0 +1,25 @@
+import { CommandNode, Command, Predicate, CommandContext } from "..";
+export type RedirectModifier<S> = (context: CommandContext<S>) => S | S[];
+export declare abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
+    private arguments;
+    private command;
+    private requirement;
+    private target;
+    private modifier;
+    private forks;
+    constructor();
+    abstract getThis(): T;
+    then(argument: ArgumentBuilder<S, any> | CommandNode<S>): T;
+    executes(command: Command<S>): T;
+    requires(requirement: Predicate<S>): T;
+    redirect(target: CommandNode<S>, modifier?: RedirectModifier<S>): T;
+    fork(target: CommandNode<S>, modifier: RedirectModifier<S>): T;
+    forward(target: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean): T;
+    getArguments(): CommandNode<S>[];
+    getCommand(): Command<S>;
+    getRequirement(): Predicate<S>;
+    getRedirect(): CommandNode<S>;
+    getRedirectModifier(): RedirectModifier<S>;
+    isFork(): boolean;
+    abstract build(): CommandNode<S>;
+}