@irrelon/battlescript 3.2.4 → 4.0.0

package/dist/services/grammar/ts/language/BattleScriptParser.d.ts

@@ -15,182 +15,210 @@ export declare class BattleScriptParser extends Parser {
     static readonly PURE = 4;
     static readonly DECLARE = 5;
     static readonly IMPORT = 6;
-    static readonly EXPORT = 7;
-    static readonly USE = 8;
-    static readonly FROM = 9;
-    static readonly NAMESPACE = 10;
-    static readonly PROGRAM = 11;
-    static readonly EXPOSE = 12;
-    static readonly GROUP = 13;
-    static readonly DEFAULT = 14;
-    static readonly SWITCH = 15;
-    static readonly FUNCTION = 16;
-    static readonly INTERFACE = 17;
-    static readonly EXTENDS = 18;
-    static readonly STATE = 19;
-    static readonly MODULE = 20;
-    static readonly EVENT = 21;
-    static readonly IF = 22;
-    static readonly ELSE = 23;
-    static readonly RETURN = 24;
-    static readonly EVERY = 25;
-    static readonly LIMIT = 26;
-    static readonly AFTER = 27;
-    static readonly CANCEL = 28;
-    static readonly FOR = 29;
-    static readonly EVALUATE = 30;
-    static readonly CASE = 31;
-    static readonly BREAK = 32;
-    static readonly CONTINUE = 33;
-    static readonly FALLBACK = 34;
-    static readonly CATCH = 35;
-    static readonly AS = 36;
-    static readonly PROTOCOL = 37;
-    static readonly DEFINE = 38;
-    static readonly REQUIRE = 39;
-    static readonly STEP = 40;
-    static readonly ENUM = 41;
-    static readonly ANY = 42;
-    static readonly END = 43;
-    static readonly CONST = 44;
-    static readonly TYPE_OBJECT = 45;
-    static readonly TYPE_ARRAY = 46;
-    static readonly TYPE_STRING = 47;
-    static readonly TYPE_INT = 48;
-    static readonly TYPE_UINT = 49;
-    static readonly TYPE_FLOAT = 50;
-    static readonly TYPE_DOUBLE = 51;
-    static readonly TYPE_BOOLEAN = 52;
-    static readonly TYPE_NULL = 53;
-    static readonly TYPE_VOID = 54;
-    static readonly TYPE_UNDEFINED = 55;
-    static readonly NUMBER = 56;
-    static readonly BOOLEAN = 57;
-    static readonly STRING = 58;
-    static readonly COMMENT = 59;
-    static readonly ARROW_OPERATOR = 60;
-    static readonly INCREMENT = 61;
-    static readonly DECREMENT = 62;
-    static readonly PLUS = 63;
-    static readonly MINUS = 64;
-    static readonly DIVIDE = 65;
-    static readonly MULTIPLY = 66;
-    static readonly REMAINDER = 67;
-    static readonly ASSIGN = 68;
-    static readonly PLUS_ASSIGN = 69;
-    static readonly MINUS_ASSIGN = 70;
-    static readonly AND = 71;
-    static readonly OR = 72;
-    static readonly NOT = 73;
-    static readonly EQUALS = 74;
-    static readonly NOT_EQUALS = 75;
-    static readonly GT = 76;
-    static readonly LT = 77;
-    static readonly GTE = 78;
-    static readonly LTE = 79;
-    static readonly REST = 80;
-    static readonly PERIOD = 81;
-    static readonly COMMA = 82;
-    static readonly WILDCARD = 83;
-    static readonly PARENS_START = 84;
-    static readonly PARENS_END = 85;
-    static readonly BRACES_START = 86;
-    static readonly BRACES_END = 87;
-    static readonly BRACKETS_START = 88;
-    static readonly BRACKETS_END = 89;
-    static readonly DOUBLE_COLON = 90;
-    static readonly SEMI_COLON = 91;
-    static readonly COLON = 92;
-    static readonly IDENTIFIER = 93;
-    static readonly WS = 94;
+    static readonly INCLUDE = 7;
+    static readonly EXPORT = 8;
+    static readonly USE = 9;
+    static readonly FROM = 10;
+    static readonly NAMESPACE = 11;
+    static readonly PROGRAM = 12;
+    static readonly EXPOSE = 13;
+    static readonly GROUP = 14;
+    static readonly DEFAULT = 15;
+    static readonly SWITCH = 16;
+    static readonly FUNCTION = 17;
+    static readonly INTERFACE = 18;
+    static readonly EXTENDS = 19;
+    static readonly STATE = 20;
+    static readonly MODULE = 21;
+    static readonly EVENT = 22;
+    static readonly IF = 23;
+    static readonly ELSE = 24;
+    static readonly RETURN = 25;
+    static readonly EVERY = 26;
+    static readonly LIMIT = 27;
+    static readonly AFTER = 28;
+    static readonly CANCEL = 29;
+    static readonly FOR = 30;
+    static readonly EVALUATE = 31;
+    static readonly CASE = 32;
+    static readonly BREAK = 33;
+    static readonly CONTINUE = 34;
+    static readonly FALLBACK = 35;
+    static readonly CATCH = 36;
+    static readonly AS = 37;
+    static readonly ENUM = 38;
+    static readonly ANY = 39;
+    static readonly PROTOCOL = 40;
+    static readonly DEFINE = 41;
+    static readonly REQUIRE = 42;
+    static readonly TERMINATE = 43;
+    static readonly STEP = 44;
+    static readonly DECODE = 45;
+    static readonly ENCODE = 46;
+    static readonly END = 47;
+    static readonly FORWARD = 48;
+    static readonly REWIND = 49;
+    static readonly OFFSET = 50;
+    static readonly XOR = 51;
+    static readonly XNOR = 52;
+    static readonly BITS = 53;
+    static readonly BYTES = 54;
+    static readonly RULE = 55;
+    static readonly PARITY = 56;
+    static readonly CONST = 57;
+    static readonly TYPE_OBJECT = 58;
+    static readonly TYPE_ARRAY = 59;
+    static readonly TYPE_STRING = 60;
+    static readonly TYPE_INT = 61;
+    static readonly TYPE_UINT = 62;
+    static readonly TYPE_FLOAT = 63;
+    static readonly TYPE_DOUBLE = 64;
+    static readonly TYPE_BOOLEAN = 65;
+    static readonly TYPE_NULL = 66;
+    static readonly TYPE_VOID = 67;
+    static readonly TYPE_UNDEFINED = 68;
+    static readonly NUMBER = 69;
+    static readonly BOOLEAN = 70;
+    static readonly STRING = 71;
+    static readonly COMMENT = 72;
+    static readonly ARROW_OPERATOR = 73;
+    static readonly INCREMENT = 74;
+    static readonly DECREMENT = 75;
+    static readonly PLUS = 76;
+    static readonly MINUS = 77;
+    static readonly DIVIDE = 78;
+    static readonly MULTIPLY = 79;
+    static readonly REMAINDER = 80;
+    static readonly QUESTION_MARK = 81;
+    static readonly ASSIGN = 82;
+    static readonly PLUS_ASSIGN = 83;
+    static readonly MINUS_ASSIGN = 84;
+    static readonly AND = 85;
+    static readonly OR = 86;
+    static readonly NOT = 87;
+    static readonly EQUALS = 88;
+    static readonly NOT_EQUALS = 89;
+    static readonly GT = 90;
+    static readonly LT = 91;
+    static readonly GTE = 92;
+    static readonly LTE = 93;
+    static readonly REST = 94;
+    static readonly PERIOD = 95;
+    static readonly COMMA = 96;
+    static readonly WILDCARD = 97;
+    static readonly PARENS_START = 98;
+    static readonly PARENS_END = 99;
+    static readonly BRACES_START = 100;
+    static readonly BRACES_END = 101;
+    static readonly BRACKETS_START = 102;
+    static readonly BRACKETS_END = 103;
+    static readonly DOUBLE_COLON = 104;
+    static readonly SEMI_COLON = 105;
+    static readonly COLON = 106;
+    static readonly IDENTIFIER = 107;
+    static readonly WS = 108;
     static readonly RULE_root = 0;
     static readonly RULE_importDeclaration = 1;
-    static readonly RULE_importNative = 2;
-    static readonly RULE_importExternal = 3;
-    static readonly RULE_programDeclaration = 4;
-    static readonly RULE_programProperty = 5;
-    static readonly RULE_exposeDeclaration = 6;
-    static readonly RULE_groupDeclaration = 7;
-    static readonly RULE_configProperty = 8;
-    static readonly RULE_configPropertyBody = 9;
-    static readonly RULE_rootBody = 10;
-    static readonly RULE_interfaceDeclaration = 11;
-    static readonly RULE_interfaceProperty = 12;
-    static readonly RULE_statement = 13;
-    static readonly RULE_exportStatement = 14;
-    static readonly RULE_exportNamespace = 15;
-    static readonly RULE_exportIdentifier = 16;
-    static readonly RULE_expressionStatement = 17;
-    static readonly RULE_namespacedIdentifier = 18;
-    static readonly RULE_expression = 19;
-    static readonly RULE_primaryExpression = 20;
-    static readonly RULE_stateDeclaration = 21;
-    static readonly RULE_stateBody = 22;
-    static readonly RULE_stateModuleDeclaration = 23;
-    static readonly RULE_stateModuleBody = 24;
-    static readonly RULE_stateModuleEventDeclaration = 25;
-    static readonly RULE_afterDeclaration = 26;
-    static readonly RULE_everyDeclaration = 27;
-    static readonly RULE_limitClause = 28;
-    static readonly RULE_cancelStatement = 29;
-    static readonly RULE_breakStatement = 30;
-    static readonly RULE_continueStatement = 31;
-    static readonly RULE_functionNameIdentifier = 32;
-    static readonly RULE_functionDeclaration = 33;
-    static readonly RULE_functionDefinition = 34;
-    static readonly RULE_functionParameters = 35;
-    static readonly RULE_functionParameter = 36;
-    static readonly RULE_assignmentPattern = 37;
-    static readonly RULE_restElement = 38;
-    static readonly RULE_ifStatement = 39;
-    static readonly RULE_elseStatement = 40;
-    static readonly RULE_elseIfStatement = 41;
-    static readonly RULE_variableDeclaration = 42;
-    static readonly RULE_variableDeclarator = 43;
-    static readonly RULE_variableDeclaratorWithInit = 44;
-    static readonly RULE_catchStatement = 45;
-    static readonly RULE_catchAsStatement = 46;
-    static readonly RULE_comment = 47;
-    static readonly RULE_returnStatement = 48;
-    static readonly RULE_forStatement = 49;
-    static readonly RULE_evaluateCase = 50;
-    static readonly RULE_evaluateCaseTest = 51;
-    static readonly RULE_wildcard = 52;
-    static readonly RULE_evaluateFallback = 53;
-    static readonly RULE_evaluateBranch = 54;
-    static readonly RULE_evaluateArguments = 55;
-    static readonly RULE_evaluateStatement = 56;
-    static readonly RULE_callArguments = 57;
-    static readonly RULE_protocolDeclaration = 58;
-    static readonly RULE_protocolBody = 59;
-    static readonly RULE_protocolComparator = 60;
-    static readonly RULE_defineStatement = 61;
-    static readonly RULE_requireStatement = 62;
-    static readonly RULE_stepDeclaration = 63;
-    static readonly RULE_stepBody = 64;
-    static readonly RULE_endStatement = 65;
-    static readonly RULE_enumDeclaration = 66;
-    static readonly RULE_enumBody = 67;
-    static readonly RULE_enumAssignment = 68;
-    static readonly RULE_token = 69;
-    static readonly RULE_debuggerStatement = 70;
-    static readonly RULE_blockStatement = 71;
-    static readonly RULE_literal = 72;
-    static readonly RULE_valueInternal = 73;
-    static readonly RULE_lineEnd = 74;
-    static readonly RULE_customType = 75;
-    static readonly RULE_dataType = 76;
-    static readonly RULE_type = 77;
-    static readonly RULE_protocolType = 78;
-    static readonly RULE_arrayExpressionInternal = 79;
-    static readonly RULE_objectExpressionInternal = 80;
-    static readonly RULE_objectProperty = 81;
-    static readonly RULE_stringLiteral = 82;
-    static readonly RULE_numberLiteral = 83;
-    static readonly RULE_booleanLiteral = 84;
-    static readonly RULE_nullLiteral = 85;
-    static readonly RULE_undefinedLiteral = 86;
-    static readonly RULE_identifier = 87;
+    static readonly RULE_includeStatement = 2;
+    static readonly RULE_importNative = 3;
+    static readonly RULE_importExternal = 4;
+    static readonly RULE_importSpecifier = 5;
+    static readonly RULE_programDeclaration = 6;
+    static readonly RULE_programProperty = 7;
+    static readonly RULE_exposeDeclaration = 8;
+    static readonly RULE_groupDeclaration = 9;
+    static readonly RULE_configProperty = 10;
+    static readonly RULE_configPropertyBody = 11;
+    static readonly RULE_rootBody = 12;
+    static readonly RULE_interfaceDeclaration = 13;
+    static readonly RULE_interfaceProperty = 14;
+    static readonly RULE_statement = 15;
+    static readonly RULE_exportStatement = 16;
+    static readonly RULE_exportNamed = 17;
+    static readonly RULE_exportSpecifier = 18;
+    static readonly RULE_exportInline = 19;
+    static readonly RULE_exportReexport = 20;
+    static readonly RULE_expressionStatement = 21;
+    static readonly RULE_namespacedIdentifier = 22;
+    static readonly RULE_expression = 23;
+    static readonly RULE_primaryExpression = 24;
+    static readonly RULE_stateDeclaration = 25;
+    static readonly RULE_stateBody = 26;
+    static readonly RULE_stateModuleDeclaration = 27;
+    static readonly RULE_stateModuleBody = 28;
+    static readonly RULE_stateModuleEventDeclaration = 29;
+    static readonly RULE_afterDeclaration = 30;
+    static readonly RULE_everyDeclaration = 31;
+    static readonly RULE_limitClause = 32;
+    static readonly RULE_cancelStatement = 33;
+    static readonly RULE_breakStatement = 34;
+    static readonly RULE_continueStatement = 35;
+    static readonly RULE_functionNameIdentifier = 36;
+    static readonly RULE_functionDeclaration = 37;
+    static readonly RULE_functionDefinition = 38;
+    static readonly RULE_functionParameters = 39;
+    static readonly RULE_functionParameter = 40;
+    static readonly RULE_assignmentPattern = 41;
+    static readonly RULE_restElement = 42;
+    static readonly RULE_ifStatement = 43;
+    static readonly RULE_elseStatement = 44;
+    static readonly RULE_elseIfStatement = 45;
+    static readonly RULE_variableDeclaration = 46;
+    static readonly RULE_variableDeclarator = 47;
+    static readonly RULE_variableDeclaratorWithInit = 48;
+    static readonly RULE_catchStatement = 49;
+    static readonly RULE_catchAsStatement = 50;
+    static readonly RULE_comment = 51;
+    static readonly RULE_returnStatement = 52;
+    static readonly RULE_forStatement = 53;
+    static readonly RULE_evaluateCase = 54;
+    static readonly RULE_evaluateCaseTest = 55;
+    static readonly RULE_wildcard = 56;
+    static readonly RULE_evaluateFallback = 57;
+    static readonly RULE_evaluateBranch = 58;
+    static readonly RULE_evaluateArguments = 59;
+    static readonly RULE_evaluateStatement = 60;
+    static readonly RULE_callArguments = 61;
+    static readonly RULE_protocolDeclaration = 62;
+    static readonly RULE_protocolComparator = 63;
+    static readonly RULE_defineStatement = 64;
+    static readonly RULE_requireStatement = 65;
+    static readonly RULE_terminateFlag = 66;
+    static readonly RULE_protocolOpStatement = 67;
+    static readonly RULE_booleanOp = 68;
+    static readonly RULE_forwardStatement = 69;
+    static readonly RULE_offsetStatement = 70;
+    static readonly RULE_rewindStatement = 71;
+    static readonly RULE_stepDeclaration = 72;
+    static readonly RULE_protocolPhase = 73;
+    static readonly RULE_parityDeclaration = 74;
+    static readonly RULE_ruleStatement = 75;
+    static readonly RULE_protocolBody = 76;
+    static readonly RULE_stepBody = 77;
+    static readonly RULE_endStatement = 78;
+    static readonly RULE_enumDeclaration = 79;
+    static readonly RULE_enumBody = 80;
+    static readonly RULE_enumAssignment = 81;
+    static readonly RULE_token = 82;
+    static readonly RULE_debuggerStatement = 83;
+    static readonly RULE_blockStatement = 84;
+    static readonly RULE_literal = 85;
+    static readonly RULE_valueInternal = 86;
+    static readonly RULE_lineEnd = 87;
+    static readonly RULE_customType = 88;
+    static readonly RULE_dataType = 89;
+    static readonly RULE_type = 90;
+    static readonly RULE_protocolType = 91;
+    static readonly RULE_protocolReadType = 92;
+    static readonly RULE_arrayExpressionInternal = 93;
+    static readonly RULE_objectExpressionInternal = 94;
+    static readonly RULE_objectProperty = 95;
+    static readonly RULE_stringLiteral = 96;
+    static readonly RULE_numberLiteral = 97;
+    static readonly RULE_booleanLiteral = 98;
+    static readonly RULE_nullLiteral = 99;
+    static readonly RULE_undefinedLiteral = 100;
+    static readonly RULE_identifier = 101;
     static readonly ruleNames: string[];
     private static readonly _LITERAL_NAMES;
     private static readonly _SYMBOLIC_NAMES;
@@ -203,8 +231,10 @@ export declare class BattleScriptParser extends Parser {
     constructor(input: TokenStream);
     root(): RootContext;
     importDeclaration(): ImportDeclarationContext;
+    includeStatement(): IncludeStatementContext;
     importNative(): ImportNativeContext;
     importExternal(): ImportExternalContext;
+    importSpecifier(): ImportSpecifierContext;
     programDeclaration(): ProgramDeclarationContext;
     programProperty(): ProgramPropertyContext;
     exposeDeclaration(): ExposeDeclarationContext;
@@ -216,8 +246,10 @@ export declare class BattleScriptParser extends Parser {
     interfaceProperty(): InterfacePropertyContext;
     statement(): StatementContext;
     exportStatement(): ExportStatementContext;
-    exportNamespace(): ExportNamespaceContext;
-    exportIdentifier(): ExportIdentifierContext;
+    exportNamed(): ExportNamedContext;
+    exportSpecifier(): ExportSpecifierContext;
+    exportInline(): ExportInlineContext;
+    exportReexport(): ExportReexportContext;
     expressionStatement(): ExpressionStatementContext;
     namespacedIdentifier(): NamespacedIdentifierContext;
     expression(): ExpressionContext;
@@ -261,11 +293,20 @@ export declare class BattleScriptParser extends Parser {
     evaluateStatement(): EvaluateStatementContext;
     callArguments(): CallArgumentsContext;
     protocolDeclaration(): ProtocolDeclarationContext;
-    protocolBody(): ProtocolBodyContext;
     protocolComparator(): ProtocolComparatorContext;
     defineStatement(): DefineStatementContext;
     requireStatement(): RequireStatementContext;
+    terminateFlag(): TerminateFlagContext;
+    protocolOpStatement(): ProtocolOpStatementContext;
+    booleanOp(): BooleanOpContext;
+    forwardStatement(): ForwardStatementContext;
+    offsetStatement(): OffsetStatementContext;
+    rewindStatement(): RewindStatementContext;
     stepDeclaration(): StepDeclarationContext;
+    protocolPhase(): ProtocolPhaseContext;
+    parityDeclaration(): ParityDeclarationContext;
+    ruleStatement(): RuleStatementContext;
+    protocolBody(): ProtocolBodyContext;
     stepBody(): StepBodyContext;
     endStatement(): EndStatementContext;
     enumDeclaration(): EnumDeclarationContext;
@@ -283,6 +324,7 @@ export declare class BattleScriptParser extends Parser {
     dataType(_p: number): DataTypeContext;
     type(): TypeContext;
     protocolType(): ProtocolTypeContext;
+    protocolReadType(): ProtocolReadTypeContext;
     arrayExpressionInternal(): ArrayExpressionInternalContext;
     objectExpressionInternal(): ObjectExpressionInternalContext;
     objectProperty(): ObjectPropertyContext;
@@ -322,6 +364,16 @@ export declare class ImportDeclarationContext extends ParserRuleContext {
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
+export declare class IncludeStatementContext extends ParserRuleContext {
+    INCLUDE(): TerminalNode;
+    stringLiteral(): StringLiteralContext;
+    lineEnd(): LineEndContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
 export declare class ImportNativeContext extends ParserRuleContext {
     IMPORT(): TerminalNode;
     identifier(): IdentifierContext[];
@@ -339,10 +391,11 @@ export declare class ImportExternalContext extends ParserRuleContext {
     NAMESPACE(): TerminalNode | undefined;
     stringLiteral(): StringLiteralContext;
     lineEnd(): LineEndContext;
-    identifier(): IdentifierContext[];
-    identifier(i: number): IdentifierContext;
+    identifier(): IdentifierContext | undefined;
     FROM(): TerminalNode | undefined;
     BRACES_START(): TerminalNode | undefined;
+    importSpecifier(): ImportSpecifierContext[];
+    importSpecifier(i: number): ImportSpecifierContext;
     BRACES_END(): TerminalNode | undefined;
     COMMA(): TerminalNode[];
     COMMA(i: number): TerminalNode;
@@ -352,6 +405,16 @@ export declare class ImportExternalContext extends ParserRuleContext {
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
+export declare class ImportSpecifierContext extends ParserRuleContext {
+    identifier(): IdentifierContext[];
+    identifier(i: number): IdentifierContext;
+    AS(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
 export declare class ProgramDeclarationContext extends ParserRuleContext {
     PROGRAM(): TerminalNode;
     BRACES_START(): TerminalNode;
@@ -430,6 +493,8 @@ export declare class ConfigPropertyBodyContext extends ParserRuleContext {
 }
 export declare class RootBodyContext extends ParserRuleContext {
     importDeclaration(): ImportDeclarationContext | undefined;
+    includeStatement(): IncludeStatementContext | undefined;
+    exportStatement(): ExportStatementContext | undefined;
     interfaceDeclaration(): InterfaceDeclarationContext | undefined;
     exposeDeclaration(): ExposeDeclarationContext | undefined;
     programDeclaration(): ProgramDeclarationContext | undefined;
@@ -484,7 +549,6 @@ export declare class StatementContext extends ParserRuleContext {
     catchStatement(): CatchStatementContext | undefined;
     forStatement(): ForStatementContext | undefined;
     evaluateStatement(): EvaluateStatementContext | undefined;
-    exportStatement(): ExportStatementContext | undefined;
     debuggerStatement(): DebuggerStatementContext | undefined;
     comment(): CommentContext | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
@@ -494,20 +558,20 @@ export declare class StatementContext extends ParserRuleContext {
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
 export declare class ExportStatementContext extends ParserRuleContext {
-    exportNamespace(): ExportNamespaceContext | undefined;
-    exportIdentifier(): ExportIdentifierContext | undefined;
+    exportNamed(): ExportNamedContext | undefined;
+    exportInline(): ExportInlineContext | undefined;
+    exportReexport(): ExportReexportContext | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: BattleScriptListener): void;
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
-export declare class ExportNamespaceContext extends ParserRuleContext {
+export declare class ExportNamedContext extends ParserRuleContext {
     EXPORT(): TerminalNode;
-    NAMESPACE(): TerminalNode;
-    identifier(): IdentifierContext[];
-    identifier(i: number): IdentifierContext;
     BRACES_START(): TerminalNode;
+    exportSpecifier(): ExportSpecifierContext[];
+    exportSpecifier(i: number): ExportSpecifierContext;
     BRACES_END(): TerminalNode;
     lineEnd(): LineEndContext;
     COMMA(): TerminalNode[];
@@ -518,10 +582,41 @@ export declare class ExportNamespaceContext extends ParserRuleContext {
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
-export declare class ExportIdentifierContext extends ParserRuleContext {
+export declare class ExportSpecifierContext extends ParserRuleContext {
+    identifier(): IdentifierContext[];
+    identifier(i: number): IdentifierContext;
+    AS(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class ExportInlineContext extends ParserRuleContext {
     EXPORT(): TerminalNode;
-    identifier(): IdentifierContext;
+    variableDeclaration(): VariableDeclarationContext | undefined;
+    functionDefinition(): FunctionDefinitionContext | undefined;
+    functionDeclaration(): FunctionDeclarationContext | undefined;
+    enumDeclaration(): EnumDeclarationContext | undefined;
+    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
+    stateDeclaration(): StateDeclarationContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class ExportReexportContext extends ParserRuleContext {
+    EXPORT(): TerminalNode;
+    BRACES_START(): TerminalNode;
+    exportSpecifier(): ExportSpecifierContext[];
+    exportSpecifier(i: number): ExportSpecifierContext;
+    BRACES_END(): TerminalNode;
+    FROM(): TerminalNode;
+    stringLiteral(): StringLiteralContext;
     lineEnd(): LineEndContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: BattleScriptListener): void;
@@ -1125,18 +1220,6 @@ export declare class ProtocolDeclarationContext extends ParserRuleContext {
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
-export declare class ProtocolBodyContext extends ParserRuleContext {
-    enumDeclaration(): EnumDeclarationContext | undefined;
-    defineStatement(): DefineStatementContext | undefined;
-    requireStatement(): RequireStatementContext | undefined;
-    stepDeclaration(): StepDeclarationContext | undefined;
-    comment(): CommentContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
-    get ruleIndex(): number;
-    enterRule(listener: BattleScriptListener): void;
-    exitRule(listener: BattleScriptListener): void;
-    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
-}
 export declare class ProtocolComparatorContext extends ParserRuleContext {
     EQUALS(): TerminalNode | undefined;
     NOT_EQUALS(): TerminalNode | undefined;
@@ -1164,6 +1247,65 @@ export declare class RequireStatementContext extends ParserRuleContext {
     protocolComparator(): ProtocolComparatorContext;
     expression(): ExpressionContext;
     lineEnd(): LineEndContext;
+    terminateFlag(): TerminateFlagContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class TerminateFlagContext extends ParserRuleContext {
+    TERMINATE(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class ProtocolOpStatementContext extends ParserRuleContext {
+    booleanOp(): BooleanOpContext;
+    protocolReadType(): ProtocolReadTypeContext;
+    stringLiteral(): StringLiteralContext;
+    lineEnd(): LineEndContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class BooleanOpContext extends ParserRuleContext {
+    XOR(): TerminalNode | undefined;
+    XNOR(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class ForwardStatementContext extends ParserRuleContext {
+    FORWARD(): TerminalNode;
+    numberLiteral(): NumberLiteralContext;
+    lineEnd(): LineEndContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class OffsetStatementContext extends ParserRuleContext {
+    OFFSET(): TerminalNode;
+    numberLiteral(): NumberLiteralContext;
+    lineEnd(): LineEndContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class RewindStatementContext extends ParserRuleContext {
+    REWIND(): TerminalNode;
+    numberLiteral(): NumberLiteralContext;
+    lineEnd(): LineEndContext;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: BattleScriptListener): void;
@@ -1174,6 +1316,7 @@ export declare class StepDeclarationContext extends ParserRuleContext {
     STEP(): TerminalNode;
     BRACES_START(): TerminalNode;
     BRACES_END(): TerminalNode;
+    protocolPhase(): ProtocolPhaseContext | undefined;
     stepBody(): StepBodyContext[];
     stepBody(i: number): StepBodyContext;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
@@ -1182,10 +1325,75 @@ export declare class StepDeclarationContext extends ParserRuleContext {
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
+export declare class ProtocolPhaseContext extends ParserRuleContext {
+    DECODE(): TerminalNode | undefined;
+    ENCODE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class ParityDeclarationContext extends ParserRuleContext {
+    PARITY(): TerminalNode;
+    BRACES_START(): TerminalNode;
+    BRACES_END(): TerminalNode;
+    protocolPhase(): ProtocolPhaseContext | undefined;
+    stepBody(): StepBodyContext[];
+    stepBody(i: number): StepBodyContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class RuleStatementContext extends ParserRuleContext {
+    RULE(): TerminalNode;
+    protocolType(): ProtocolTypeContext;
+    stringLiteral(): StringLiteralContext[];
+    stringLiteral(i: number): StringLiteralContext;
+    ASSIGN(): TerminalNode;
+    protocolComparator(): ProtocolComparatorContext;
+    numberLiteral(): NumberLiteralContext[];
+    numberLiteral(i: number): NumberLiteralContext;
+    QUESTION_MARK(): TerminalNode;
+    COLON(): TerminalNode;
+    lineEnd(): LineEndContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
+export declare class ProtocolBodyContext extends ParserRuleContext {
+    enumDeclaration(): EnumDeclarationContext | undefined;
+    defineStatement(): DefineStatementContext | undefined;
+    requireStatement(): RequireStatementContext | undefined;
+    protocolOpStatement(): ProtocolOpStatementContext | undefined;
+    forwardStatement(): ForwardStatementContext | undefined;
+    offsetStatement(): OffsetStatementContext | undefined;
+    rewindStatement(): RewindStatementContext | undefined;
+    parityDeclaration(): ParityDeclarationContext | undefined;
+    stepDeclaration(): StepDeclarationContext | undefined;
+    ruleStatement(): RuleStatementContext | undefined;
+    endStatement(): EndStatementContext | undefined;
+    comment(): CommentContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
 export declare class StepBodyContext extends ParserRuleContext {
     defineStatement(): DefineStatementContext | undefined;
     requireStatement(): RequireStatementContext | undefined;
+    protocolOpStatement(): ProtocolOpStatementContext | undefined;
+    forwardStatement(): ForwardStatementContext | undefined;
+    offsetStatement(): OffsetStatementContext | undefined;
+    rewindStatement(): RewindStatementContext | undefined;
+    ruleStatement(): RuleStatementContext | undefined;
     endStatement(): EndStatementContext | undefined;
+    statement(): StatementContext | undefined;
     comment(): CommentContext | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
@@ -1195,6 +1403,7 @@ export declare class StepBodyContext extends ParserRuleContext {
 }
 export declare class EndStatementContext extends ParserRuleContext {
     END(): TerminalNode;
+    booleanLiteral(): BooleanLiteralContext;
     lineEnd(): LineEndContext;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
@@ -1351,6 +1560,18 @@ export declare class ProtocolTypeContext extends ParserRuleContext {
     exitRule(listener: BattleScriptListener): void;
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
+export declare class ProtocolReadTypeContext extends ParserRuleContext {
+    BITS(): TerminalNode | undefined;
+    LT(): TerminalNode;
+    numberLiteral(): NumberLiteralContext;
+    GT(): TerminalNode;
+    BYTES(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: BattleScriptListener): void;
+    exitRule(listener: BattleScriptListener): void;
+    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
+}
 export declare class ArrayExpressionInternalContext extends ParserRuleContext {
     BRACKETS_START(): TerminalNode;
     BRACKETS_END(): TerminalNode;
@@ -1429,7 +1650,24 @@ export declare class UndefinedLiteralContext extends ParserRuleContext {
     accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
 }
 export declare class IdentifierContext extends ParserRuleContext {
-    IDENTIFIER(): TerminalNode;
+    IDENTIFIER(): TerminalNode | undefined;
+    PROTOCOL(): TerminalNode | undefined;
+    DEFINE(): TerminalNode | undefined;
+    REQUIRE(): TerminalNode | undefined;
+    TERMINATE(): TerminalNode | undefined;
+    STEP(): TerminalNode | undefined;
+    DECODE(): TerminalNode | undefined;
+    ENCODE(): TerminalNode | undefined;
+    END(): TerminalNode | undefined;
+    FORWARD(): TerminalNode | undefined;
+    REWIND(): TerminalNode | undefined;
+    OFFSET(): TerminalNode | undefined;
+    XOR(): TerminalNode | undefined;
+    XNOR(): TerminalNode | undefined;
+    BITS(): TerminalNode | undefined;
+    BYTES(): TerminalNode | undefined;
+    RULE(): TerminalNode | undefined;
+    PARITY(): TerminalNode | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: BattleScriptListener): void;