@manta-eu/datalog-parser 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1599 @@
+import { CstNode } from 'chevrotain';
+import { CstParser } from 'chevrotain';
+import { ICstVisitor } from 'chevrotain';
+import { ILexingResult } from 'chevrotain';
+import { IToken } from 'chevrotain';
+import { ParserMethod } from 'chevrotain';
+import { TokenType } from 'chevrotain';
+import { UpdateOperation } from '@traqula/rules-sparql-1-1';
+
+export declare type AdditiveExpressionCstChildren = {
+    multiplicativeExpression: MultiplicativeExpressionCstNode[];
+    PLUS?: IToken[];
+    MINUS?: IToken[];
+};
+
+export declare interface AdditiveExpressionCstNode extends CstNode {
+    name: "additiveExpression";
+    children: AdditiveExpressionCstChildren;
+}
+
+export declare const AGGREGATE: TokenType;
+
+export declare type AggregateBindCstChildren = {
+    BIND?: IToken[];
+    aggregateFunction?: AggregateFunctionCstNode[];
+    expression?: ExpressionCstNode[];
+    AS: IToken[];
+    VARIABLE?: IToken[];
+    groundedAsTarget?: GroundedAsTargetCstNode[];
+};
+
+export declare interface AggregateBindCstNode extends CstNode {
+    name: "aggregateBind";
+    children: AggregateBindCstChildren;
+}
+
+export declare type AggregateBinding = AggregateFunctionBinding | ExpressionAggregateBinding;
+
+export declare type AggregateBindingTarget = {
+    /** Target variable name without its `?`, or the value's text when `groundedTarget` is set. */
+    variable: string;
+    /** Set only when the expanded grammar read a value in `AS` position, as RDFox's grounded rules do. */
+    groundedTarget?: DatalogTerm;
+};
+
+export declare type AggregateCstChildren = {
+    AGGREGATE: IToken[];
+    LPAREN: IToken[];
+    atomList?: AtomListCstNode[];
+    onClause?: OnClauseCstNode[];
+    aggregateBind?: AggregateBindCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface AggregateCstNode extends CstNode {
+    name: "aggregate";
+    children: AggregateCstChildren;
+}
+
+export declare type AggregateFunction = UnaryAggregateFunction | BinaryAggregateFunction;
+
+export declare type AggregateFunction1CstChildren = {
+    COUNT_MIN?: IToken[];
+    COUNT_MAX?: IToken[];
+    COUNT?: IToken[];
+    MIN?: IToken[];
+    MAX?: IToken[];
+    SUM?: IToken[];
+    MUL?: IToken[];
+    AVG?: IToken[];
+    LPAREN: IToken[];
+    DISTINCT?: IToken[];
+    STAR?: IToken[];
+    expression?: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface AggregateFunction1CstNode extends CstNode {
+    name: "aggregateFunction1";
+    children: AggregateFunction1CstChildren;
+}
+
+export declare type AggregateFunction2CstChildren = {
+    MIN_ARGMIN?: IToken[];
+    MAX_ARGMIN?: IToken[];
+    MIN_ARGMAX?: IToken[];
+    MAX_ARGMAX?: IToken[];
+    LPAREN: IToken[];
+    DISTINCT?: IToken[];
+    firstExpr: ExpressionCstNode[];
+    COMMA: IToken[];
+    secondExpr: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface AggregateFunction2CstNode extends CstNode {
+    name: "aggregateFunction2";
+    children: AggregateFunction2CstChildren;
+}
+
+export declare type AggregateFunctionBinding = UnaryAggregateBinding | BinaryAggregateBinding;
+
+export declare type AggregateFunctionCstChildren = {
+    aggregateFunction1?: AggregateFunction1CstNode[];
+    aggregateFunction2?: AggregateFunction2CstNode[];
+};
+
+export declare interface AggregateFunctionCstNode extends CstNode {
+    name: "aggregateFunction";
+    children: AggregateFunctionCstChildren;
+}
+
+export declare const allTokens: TokenType[];
+
+export declare const AND: TokenType;
+
+/**
+ * Check if two rules are semantically equivalent (ignoring whitespace)
+ */
+export declare function areRulesEquivalent(rule1: string, rule2: string): boolean;
+
+export declare type ArgumentListCstChildren = {
+    expression: ExpressionCstNode[];
+    COMMA?: IToken[];
+};
+
+export declare interface ArgumentListCstNode extends CstNode {
+    name: "argumentList";
+    children: ArgumentListCstChildren;
+}
+
+export declare const AS: TokenType;
+
+export declare function assertNoGroundedTargets(body: DatalogBodyFormula[]): void;
+
+export declare function astBuilder(): DatalogAstBuilder;
+
+export declare const AT: TokenType;
+
+export declare type AtomCstChildren = {
+    tupleTableAtom?: TupleTableAtomCstNode[];
+    filterAtom?: FilterAtomCstNode[];
+    bindAtom?: BindAtomCstNode[];
+};
+
+export declare interface AtomCstNode extends CstNode {
+    name: "atom";
+    children: AtomCstChildren;
+}
+
+export declare type AtomListCstChildren = {
+    atom: AtomCstNode[];
+    COMMA?: IToken[];
+};
+
+export declare interface AtomListCstNode extends CstNode {
+    name: "atomList";
+    children: AtomListCstChildren;
+}
+
+export declare function atomToDatalogText(atom: DatalogAtom, options?: DatalogTextOptions): string;
+
+/** A rule AST that may be passed to SPARQL translators (excludes grounded ASTs). */
+export declare type AuthoredDatalogRule = DatalogRule & {
+    grounded?: false;
+};
+
+export declare const AVG: TokenType;
+
+export declare const BaseDatalogVisitor: new (...args: any[]) => ICstVisitor<any, any>;
+
+/**
+ * Begin a read-write transaction on a connection
+ */
+export declare function beginTransaction(params: RDFoxTransactionParams): Promise<void>;
+
+export declare type BinaryAggregateBinding = AggregateBindingTarget & {
+    function: BinaryAggregateFunction;
+    distinct?: boolean;
+    expression: DatalogExpression;
+    secondExpression: DatalogExpression;
+};
+
+export declare type BinaryAggregateFunction = "MIN_ARGMIN" | "MAX_ARGMIN" | "MIN_ARGMAX" | "MAX_ARGMAX";
+
+export declare type BinaryExpression = {
+    type: "binary";
+    operator: "||" | "&&" | "=" | "!=" | "<" | ">" | "<=" | ">=" | "+" | "-" | "*" | "/";
+    left: DatalogExpression;
+    right: DatalogExpression;
+};
+
+export declare function binaryOperandNeedsParentheses(operand: DatalogExpression, parentOperator: BinaryExpression["operator"], side: "left" | "right"): boolean;
+
+export declare const BIND: TokenType;
+
+export declare type BindAtomCstChildren = {
+    BIND: IToken[];
+    LPAREN: IToken[];
+    expression: ExpressionCstNode[];
+    AS: IToken[];
+    VARIABLE?: IToken[];
+    groundedAsTarget?: GroundedAsTargetCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface BindAtomCstNode extends CstNode {
+    name: "bindAtom";
+    children: BindAtomCstChildren;
+}
+
+export declare const BLANK_NODE: TokenType;
+
+export declare type BlankNodeTerm = {
+    type: "blank";
+    label: string;
+};
+
+export declare type BodyFormulaCstChildren = {
+    negation?: NegationCstNode[];
+    filterAtom?: FilterAtomCstNode[];
+    bindAtom?: BindAtomCstNode[];
+    aggregate?: AggregateCstNode[];
+    skolemAtom?: SkolemAtomCstNode[];
+    tupleTableAtom?: TupleTableAtomCstNode[];
+};
+
+export declare interface BodyFormulaCstNode extends CstNode {
+    name: "bodyFormula";
+    children: BodyFormulaCstChildren;
+}
+
+export declare type BodyFormulaListCstChildren = {
+    bodyFormula: BodyFormulaCstNode[];
+    COMMA?: IToken[];
+};
+
+export declare interface BodyFormulaListCstNode extends CstNode {
+    name: "bodyFormulaList";
+    children: BodyFormulaListCstChildren;
+}
+
+export declare type BooleanLiteralCstChildren = {
+    TRUE?: IToken[];
+    FALSE?: IToken[];
+};
+
+export declare interface BooleanLiteralCstNode extends CstNode {
+    name: "booleanLiteral";
+    children: BooleanLiteralCstChildren;
+}
+
+export declare const booleanLiteralTokenTypes: Set<TokenType>;
+
+export declare const builtinFunctionTokenTypes: Set<TokenType>;
+
+export declare type ClassAssertion = {
+    className: string;
+    instance: DatalogTerm;
+    graph?: DatalogTerm;
+};
+
+export declare function classAssertionFromAtom(atom: DatalogAtom): ClassAssertion | null;
+
+export declare type ClassAtom = {
+    type: "class";
+    className: string;
+    instance: DatalogTerm;
+    graph?: DatalogTerm;
+};
+
+export declare function collectVariableTypeEvidence(ast: DatalogRule): VariableTypeEvidence[];
+
+export declare const COLON: TokenType;
+
+export declare const COMMA: TokenType;
+
+export declare const COMMENT: TokenType;
+
+/**
+ * Commit a transaction on a connection
+ */
+export declare function commitTransaction(params: RDFoxTransactionParams): Promise<void>;
+
+export declare type ComparisonOperator = Extract<BinaryExpression["operator"], "=" | "!=" | "<" | ">" | "<=" | ">=">;
+
+export declare const CONCAT: TokenType;
+
+export declare type ConcatFunctionCstChildren = {
+    CONCAT: IToken[];
+    LPAREN: IToken[];
+    argumentList: ArgumentListCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface ConcatFunctionCstNode extends CstNode {
+    name: "concatFunction";
+    children: ConcatFunctionCstChildren;
+}
+
+export declare type ConditionalAndExpressionCstChildren = {
+    relationalExpression: RelationalExpressionCstNode[];
+    AND?: IToken[];
+};
+
+export declare interface ConditionalAndExpressionCstNode extends CstNode {
+    name: "conditionalAndExpression";
+    children: ConditionalAndExpressionCstChildren;
+}
+
+export declare type ConditionalOrExpressionCstChildren = {
+    conditionalAndExpression: ConditionalAndExpressionCstNode[];
+    OR?: IToken[];
+};
+
+export declare interface ConditionalOrExpressionCstNode extends CstNode {
+    name: "conditionalOrExpression";
+    children: ConditionalOrExpressionCstChildren;
+}
+
+export declare const COUNT: TokenType;
+
+export declare const COUNT_MAX: TokenType;
+
+export declare const COUNT_MIN: TokenType;
+
+/**
+ * Create a connection to a datastore
+ */
+export declare function createConnection(params: RDFoxConnectionParams): Promise<string>;
+
+export declare type DatalogAggregate = {
+    type: "aggregate";
+    atoms: DatalogAggregateAtom[];
+    /**
+     * Grouping keys from `ON …`. Entries are variable names without `?`, or the value's
+     * text when the expanded grammar read a substituted ON term (e.g. `":Company_42"`).
+     * Order is not source order: the visitor lists all variables, then all grounded
+     * targets. Do not feed grounded ASTs into SPARQL helpers that treat every entry as a
+     * variable name (`datalog-to-sparql-select`, `ast-utils`) — use authored/strict ASTs there.
+     */
+    onVars?: string[];
+    /** Set only when the expanded grammar read values in `ON` position, as RDFox's grounded rules do. */
+    groundedOnTargets?: DatalogTerm[];
+    bindings?: AggregateBinding[];
+};
+
+export declare type DatalogAggregateAtom = DatalogAtom | DatalogFilter | DatalogBind;
+
+export declare class DatalogAstBuilder extends BaseDatalogVisitor {
+    rule(children: RuleCstChildren): DatalogRuleAst;
+    ruleHead(children: RuleHeadCstChildren): DatalogAtom[];
+    ruleBody(children: RuleBodyCstChildren): DatalogBodyFormula[];
+    bodyFormula(children: BodyFormulaCstChildren): DatalogBodyFormula;
+    tupleTableAtom(children: TupleTableAtomCstChildren): DatalogAtom;
+    graphName(children: GraphNameCstChildren): DatalogTerm;
+    defaultGraphAtom(children: DefaultGraphAtomCstChildren): DatalogAtom;
+    generalAtom(children: GeneralAtomCstChildren): GeneralAtom;
+    term(children: TermCstChildren): DatalogTerm;
+    iri(children: IriCstChildren): IriTerm;
+    literal(children: LiteralCstChildren): LiteralTerm;
+    numericLiteral(children: NumericLiteralCstChildren): LiteralTerm;
+    booleanLiteral(children: BooleanLiteralCstChildren): LiteralTerm;
+    stringLiteral(children: StringLiteralCstChildren): LiteralTerm;
+    negation(children: NegationCstChildren): DatalogNegation;
+    existsClause(children: ExistsClauseCstChildren): string[];
+    atomList(children: AtomListCstChildren): DatalogAggregateAtom[];
+    atom(children: Record<string, CstNode[]>): DatalogAggregateAtom;
+    bodyFormulaList(children: BodyFormulaListCstChildren): DatalogBodyFormula[];
+    filterAtom(children: FilterAtomCstChildren): DatalogFilter;
+    bindAtom(children: BindAtomCstChildren): DatalogBind;
+    asTarget(children: {
+        VARIABLE?: IToken[];
+        groundedAsTarget?: CstNode[];
+    }, missingMessage: string): {
+        variable: string;
+        groundedTarget?: DatalogTerm;
+    };
+    groundedAsTarget(children: GroundedAsTargetCstChildren): DatalogTerm;
+    skolemAtom(children: SkolemAtomCstChildren): DatalogSkolem;
+    aggregate(children: AggregateCstChildren): DatalogAggregate;
+    onClause(children: OnClauseCstChildren): {
+        onVars: string[];
+        groundedOnTargets?: DatalogTerm[];
+    };
+    aggregateBind(children: AggregateBindCstChildren): AggregateBinding;
+    aggregateFunction(children: AggregateFunctionCstChildren): Omit<UnaryAggregateBinding, "variable" | "groundedTarget"> | Omit<BinaryAggregateBinding, "variable" | "groundedTarget">;
+    aggregateFunction1(children: AggregateFunction1CstChildren): Omit<UnaryAggregateBinding, "variable" | "groundedTarget">;
+    aggregateFunction2(children: AggregateFunction2CstChildren): Omit<BinaryAggregateBinding, "variable" | "groundedTarget">;
+    expression(children: ExpressionCstChildren): DatalogExpression;
+    conditionalOrExpression(children: ConditionalOrExpressionCstChildren): DatalogExpression;
+    conditionalAndExpression(children: ConditionalAndExpressionCstChildren): DatalogExpression;
+    relationalExpression(children: RelationalExpressionCstChildren): DatalogExpression;
+    additiveExpression(children: AdditiveExpressionCstChildren): DatalogExpression;
+    multiplicativeExpression(children: MultiplicativeExpressionCstChildren): DatalogExpression;
+    unaryExpression(children: UnaryExpressionCstChildren): DatalogExpression;
+    functionCall(children: FunctionCallCstChildren): DatalogExpression;
+    concatFunction(children: ConcatFunctionCstChildren): DatalogExpression;
+    strFunction(children: StrFunctionCstChildren): DatalogExpression;
+    ifFunction(children: IfFunctionCstChildren): DatalogExpression;
+    iriFunction(children: IriFunctionCstChildren): DatalogExpression;
+    skolemFunction(children: SkolemFunctionCstChildren): DatalogExpression;
+    roundFunction(children: RoundFunctionCstChildren): DatalogExpression;
+    regexFunction(children: RegexFunctionCstChildren): DatalogExpression;
+    argumentList(children: ArgumentListCstChildren): DatalogExpression[];
+    primaryExpression(children: PrimaryExpressionCstChildren): DatalogExpression;
+    private extractIriValue;
+    private numericTokenLiteral;
+    private unquoteString;
+    private unquoteTripleString;
+}
+
+export declare type DatalogAtom = TripleAtom | PropertyAtom | ClassAtom | GeneralAtom;
+
+export declare type DatalogBind = {
+    type: "bind";
+    expression: DatalogExpression;
+    /** Target variable name without its `?`, or the value's text when `groundedTarget` is set. */
+    variable: string;
+    /** Set only when the expanded grammar read a value in `AS` position, as RDFox's grounded rules do. */
+    groundedTarget?: DatalogTerm;
+};
+
+export declare type DatalogBodyFormula = DatalogAtom | DatalogNegation | DatalogAggregate | DatalogFilter | DatalogBind | DatalogSkolem;
+
+export declare function datalogBodyToSparqlSelect(bodyFormulas: DatalogBodyFormula[], prefixes?: Record<string, string>): SparqlSelectResult;
+
+export declare type DatalogExpression = BinaryExpression | UnaryExpression | TermExpression | FunctionCallExpression | InExpression;
+
+export declare type DatalogFilter = {
+    type: "filter";
+    expression: DatalogExpression;
+};
+
+export declare type DatalogNegation = {
+    type: "negation";
+    formulas: DatalogBodyFormula[];
+    existentialVars?: string[];
+};
+
+export declare type DatalogParseIssue = {
+    message: string;
+    line?: number;
+    column?: number;
+    offset?: number;
+    endOffset?: number;
+};
+
+export declare class DatalogParser extends CstParser {
+    constructor(config?: DatalogParserConfig);
+    get atEndOfInput(): boolean;
+    rule: ParserMethod<[], CstNode>;
+    private ruleHead;
+    private ruleBody;
+    private bodyFormula;
+    private tupleTableAtom;
+    private graphName;
+    private defaultGraphAtom;
+    private generalAtom;
+    term: ParserMethod<[], CstNode>;
+    protected iri: ParserMethod<[], CstNode>;
+    protected literal: ParserMethod<[], CstNode>;
+    private numericLiteral;
+    private booleanLiteral;
+    private stringLiteral;
+    private negation;
+    private existsClause;
+    protected atomList: ParserMethod<[], CstNode>;
+    private atom;
+    private bodyFormulaList;
+    private filterAtom;
+    protected bindAtom: ParserMethod<[], CstNode>;
+    private skolemAtom;
+    private aggregate;
+    protected onClause: ParserMethod<[], CstNode>;
+    protected aggregateBind: ParserMethod<[], CstNode>;
+    protected aggregateFunction: ParserMethod<[], CstNode>;
+    protected aggregateFunction1: ParserMethod<[], CstNode>;
+    protected aggregateFunction2: ParserMethod<[], CstNode>;
+    protected expression: ParserMethod<[], CstNode>;
+    private conditionalOrExpression;
+    private conditionalAndExpression;
+    private relationalExpression;
+    private additiveExpression;
+    private multiplicativeExpression;
+    private unaryExpression;
+    protected functionCall: ParserMethod<[], CstNode>;
+    private concatFunction;
+    private strFunction;
+    private ifFunction;
+    private iriFunction;
+    private skolemFunction;
+    private roundFunction;
+    private regexFunction;
+    private argumentList;
+    protected primaryExpression: ParserMethod<[], CstNode>;
+}
+
+export declare type DatalogParserConfig = {
+    selfAnalysis?: boolean;
+};
+
+export declare type DatalogParseResult = {
+    ok: true;
+    rule: DatalogRule;
+} | {
+    ok: false;
+    issues: DatalogParseIssue[];
+};
+
+export declare type DatalogRule = DatalogRuleAst & {
+    raw: string;
+};
+
+export declare type DatalogRuleAst = {
+    head: DatalogAtom[];
+    body: DatalogBodyFormula[];
+};
+
+export declare type DatalogSkolem = {
+    type: "skolem";
+    args: DatalogExpression[];
+};
+
+export declare type DatalogTerm = VariableTerm | IriTerm | LiteralTerm | BlankNodeTerm;
+
+export declare type DatalogTextOptions = {
+    stripSimpleLiteralDatatypes?: boolean;
+};
+
+export declare type DatalogTextPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "variable";
+    name: string;
+} | {
+    type: "literal";
+    literal: LiteralTerm;
+    text: string;
+};
+
+export declare type DatalogToken = IToken;
+
+export declare type DataManipulationSubType = "insertdata" | "deletedata" | "modify";
+
+export declare function datatypeToTermText(datatype: string): string;
+
+export declare const DECIMAL: TokenType;
+
+export declare const DEFAULT_NS_IRI: TokenType;
+
+export declare type DefaultGraphAtomCstChildren = {
+    LBRACKET?: IToken[];
+    subject?: TermCstNode[];
+    COMMA?: IToken[];
+    predicate?: TermCstNode[];
+    object?: TermCstNode[];
+    RBRACKET?: IToken[];
+    predicateOrClass?: IriCstNode[];
+    firstTerm?: TermCstNode[];
+    secondTerm?: TermCstNode[];
+};
+
+export declare interface DefaultGraphAtomCstNode extends CstNode {
+    name: "defaultGraphAtom";
+    children: DefaultGraphAtomCstChildren;
+}
+
+/**
+ * Delete a connection
+ */
+export declare function deleteConnection(params: RDFoxTransactionParams): Promise<void>;
+
+export declare const delimiterTokenTypes: Set<TokenType>;
+
+export declare const DISTINCT: TokenType;
+
+export declare const DOT: TokenType;
+
+export declare const DOUBLE: TokenType;
+
+export declare const EQUALS: TokenType;
+
+export declare const EXCLAMATION: TokenType;
+
+export declare const EXISTS: TokenType;
+
+export declare type ExistsClauseCstChildren = {
+    EXISTS: IToken[];
+    VARIABLE: IToken[];
+    COMMA?: IToken[];
+    IN: IToken[];
+};
+
+export declare interface ExistsClauseCstNode extends CstNode {
+    name: "existsClause";
+    children: ExistsClauseCstChildren;
+}
+
+/**
+ * Grammar variant for the grounded rules RDFox returns.
+ *
+ * Grounding substitutes an `AS` target with the value it computed, so
+ * `BIND(?spend > 500 AS ?highSpend)` comes back as `BIND(901.22 > 500 AS true)`.
+ * It also emits atom-free aggregates (`AGGREGATE(AVG(9.0) AS 9.0)`) and
+ * expression-only bindings (`AGGREGATE(13 / 100 AS 0.13)`). That is not valid
+ * authored Datalog, and rules written by hand or by the agent must keep being
+ * rejected, so the permissive grammar lives here rather than relaxing the strict one.
+ */
+export declare class ExpandedDatalogParser extends DatalogParser {
+    constructor();
+    protected groundedAsTarget: ParserMethod<[], CstNode>;
+    protected variableOrGroundedTarget(): void;
+    protected expandedOnClause: ParserMethod<[], CstNode>;
+    protected expandedBindAtom: ParserMethod<[], CstNode>;
+    protected expandedAggregate: ParserMethod<[], CstNode>;
+    protected expandedAggregateBind: ParserMethod<[], CstNode>;
+    protected expandedPrimaryExpression: ParserMethod<[], CstNode>;
+}
+
+export declare function expandedParserInstance(): ExpandedDatalogParser;
+
+/**
+ * Generate meaningful error messages for inference verification failures
+ */
+export declare function explainInferenceFailure(result: InferenceVerificationResult): string;
+
+export declare type ExpressionAggregateBinding = AggregateBindingTarget & {
+    function?: never;
+    distinct?: never;
+    expression: DatalogExpression;
+    secondExpression?: never;
+};
+
+export declare type ExpressionCstChildren = {
+    conditionalOrExpression: ConditionalOrExpressionCstNode[];
+};
+
+export declare interface ExpressionCstNode extends CstNode {
+    name: "expression";
+    children: ExpressionCstChildren;
+}
+
+export declare function expressionToDatalogParts(expression: DatalogExpression, options?: DatalogTextOptions): DatalogTextPart[];
+
+export declare function expressionToDatalogText(expression: DatalogExpression, options?: DatalogTextOptions): string;
+
+export declare function extractRuleVocabulary(ruleText: string): RuleVocabularyExtractionResult;
+
+export declare function extractRuleVocabularyFromAst(rule: DatalogRuleAst): RuleVocabulary;
+
+export declare function extractRuleVocabularyFromAtom(atom: DatalogAtom): RuleVocabularyPosition;
+
+export declare function extractVariables(rule: DatalogRule): string[];
+
+export declare const FALSE: TokenType;
+
+export declare const FILTER: TokenType;
+
+export declare type FilterAtomCstChildren = {
+    FILTER: IToken[];
+    LPAREN: IToken[];
+    expression: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface FilterAtomCstNode extends CstNode {
+    name: "filterAtom";
+    children: FilterAtomCstChildren;
+}
+
+export declare function formulaContainsSkolem(formula: DatalogBodyFormula): boolean;
+
+export declare type FunctionCallCstChildren = {
+    concatFunction?: ConcatFunctionCstNode[];
+    strFunction?: StrFunctionCstNode[];
+    ifFunction?: IfFunctionCstNode[];
+    iriFunction?: IriFunctionCstNode[];
+    skolemFunction?: SkolemFunctionCstNode[];
+    roundFunction?: RoundFunctionCstNode[];
+    regexFunction?: RegexFunctionCstNode[];
+    iri?: IriCstNode[];
+    LPAREN?: IToken[];
+    argumentList?: ArgumentListCstNode[];
+    RPAREN?: IToken[];
+};
+
+export declare interface FunctionCallCstNode extends CstNode {
+    name: "functionCall";
+    children: FunctionCallCstChildren;
+}
+
+export declare type FunctionCallExpression = {
+    type: "function";
+    name: string;
+    args: DatalogExpression[];
+};
+
+export declare type GeneralAtom = {
+    type: "general";
+    tableName: string;
+    terms: DatalogTerm[];
+};
+
+export declare type GeneralAtomCstChildren = {
+    IDENTIFIER?: IToken[];
+    STRING_LITERAL?: IToken[];
+    LPAREN: IToken[];
+    term: TermCstNode[];
+    COMMA?: IToken[];
+    RPAREN: IToken[];
+};
+
+export declare interface GeneralAtomCstNode extends CstNode {
+    name: "generalAtom";
+    children: GeneralAtomCstChildren;
+}
+
+export declare const getAggregateFunction: (binding: AggregateBinding) => AggregateBinding["function"];
+
+export declare const getAtomType: (atom: DatalogAtom) => string;
+
+export declare const getExpressionType: (expr: DatalogExpression) => string;
+
+export declare function getRelatedVariables(rule: DatalogRule, targetVariableName: string): Set<string>;
+
+export declare const getTermType: (term: DatalogTerm) => string;
+
+export declare const getVariablesFromAtom: (atom: DatalogAtom) => VariableTerm[];
+
+export declare const getVariablesFromAtomIncludingGraph: (atom: DatalogAtom) => VariableTerm[];
+
+export declare type GraphNameCstChildren = {
+    VARIABLE?: IToken[];
+    iri?: IriCstNode[];
+};
+
+export declare interface GraphNameCstNode extends CstNode {
+    name: "graphName";
+    children: GraphNameCstChildren;
+}
+
+export declare const GREATER_THAN: TokenType;
+
+export declare const GREATER_THAN_OR_EQUAL: TokenType;
+
+export declare type GroundedAsTargetCstChildren = {
+    iri?: IriCstNode[];
+    literal?: LiteralCstNode[];
+    BLANK_NODE?: IToken[];
+};
+
+export declare interface GroundedAsTargetCstNode extends CstNode {
+    name: "groundedAsTarget";
+    children: GroundedAsTargetCstChildren;
+}
+
+/** A rule AST produced by `parseGroundedDatalogRule` — not safe for SPARQL translation. */
+export declare type GroundedDatalogRule = DatalogRule & {
+    readonly grounded: true;
+};
+
+export declare const HAT: TokenType;
+
+export declare interface ICstNodeVisitor<IN, OUT> extends ICstVisitor<IN, OUT> {
+    rule(children: RuleCstChildren, param?: IN): OUT;
+    ruleHead(children: RuleHeadCstChildren, param?: IN): OUT;
+    ruleBody(children: RuleBodyCstChildren, param?: IN): OUT;
+    bodyFormula(children: BodyFormulaCstChildren, param?: IN): OUT;
+    tupleTableAtom(children: TupleTableAtomCstChildren, param?: IN): OUT;
+    graphName(children: GraphNameCstChildren, param?: IN): OUT;
+    defaultGraphAtom(children: DefaultGraphAtomCstChildren, param?: IN): OUT;
+    generalAtom(children: GeneralAtomCstChildren, param?: IN): OUT;
+    term(children: TermCstChildren, param?: IN): OUT;
+    iri(children: IriCstChildren, param?: IN): OUT;
+    literal(children: LiteralCstChildren, param?: IN): OUT;
+    numericLiteral(children: NumericLiteralCstChildren, param?: IN): OUT;
+    booleanLiteral(children: BooleanLiteralCstChildren, param?: IN): OUT;
+    stringLiteral(children: StringLiteralCstChildren, param?: IN): OUT;
+    negation(children: NegationCstChildren, param?: IN): OUT;
+    existsClause(children: ExistsClauseCstChildren, param?: IN): OUT;
+    atomList(children: AtomListCstChildren, param?: IN): OUT;
+    atom(children: AtomCstChildren, param?: IN): OUT;
+    bodyFormulaList(children: BodyFormulaListCstChildren, param?: IN): OUT;
+    filterAtom(children: FilterAtomCstChildren, param?: IN): OUT;
+    bindAtom(children: BindAtomCstChildren, param?: IN): OUT;
+    skolemAtom(children: SkolemAtomCstChildren, param?: IN): OUT;
+    aggregate(children: AggregateCstChildren, param?: IN): OUT;
+    onClause(children: OnClauseCstChildren, param?: IN): OUT;
+    aggregateBind(children: AggregateBindCstChildren, param?: IN): OUT;
+    aggregateFunction(children: AggregateFunctionCstChildren, param?: IN): OUT;
+    aggregateFunction1(children: AggregateFunction1CstChildren, param?: IN): OUT;
+    aggregateFunction2(children: AggregateFunction2CstChildren, param?: IN): OUT;
+    expression(children: ExpressionCstChildren, param?: IN): OUT;
+    conditionalOrExpression(children: ConditionalOrExpressionCstChildren, param?: IN): OUT;
+    conditionalAndExpression(children: ConditionalAndExpressionCstChildren, param?: IN): OUT;
+    relationalExpression(children: RelationalExpressionCstChildren, param?: IN): OUT;
+    additiveExpression(children: AdditiveExpressionCstChildren, param?: IN): OUT;
+    multiplicativeExpression(children: MultiplicativeExpressionCstChildren, param?: IN): OUT;
+    unaryExpression(children: UnaryExpressionCstChildren, param?: IN): OUT;
+    functionCall(children: FunctionCallCstChildren, param?: IN): OUT;
+    concatFunction(children: ConcatFunctionCstChildren, param?: IN): OUT;
+    strFunction(children: StrFunctionCstChildren, param?: IN): OUT;
+    ifFunction(children: IfFunctionCstChildren, param?: IN): OUT;
+    iriFunction(children: IriFunctionCstChildren, param?: IN): OUT;
+    skolemFunction(children: SkolemFunctionCstChildren, param?: IN): OUT;
+    roundFunction(children: RoundFunctionCstChildren, param?: IN): OUT;
+    regexFunction(children: RegexFunctionCstChildren, param?: IN): OUT;
+    argumentList(children: ArgumentListCstChildren, param?: IN): OUT;
+    primaryExpression(children: PrimaryExpressionCstChildren, param?: IN): OUT;
+    groundedAsTarget(children: GroundedAsTargetCstChildren, param?: IN): OUT;
+}
+
+export declare const IDENTIFIER: TokenType;
+
+export declare const IF: TokenType;
+
+export declare type IfFunctionCstChildren = {
+    IF: IToken[];
+    LPAREN: IToken[];
+    condition: ExpressionCstNode[];
+    COMMA: IToken[];
+    thenExpr: ExpressionCstNode[];
+    elseExpr: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface IfFunctionCstNode extends CstNode {
+    name: "ifFunction";
+    children: IfFunctionCstChildren;
+}
+
+export declare const IN: TokenType;
+
+export declare type InExpression = {
+    type: "in";
+    negated: boolean;
+    expression: DatalogExpression;
+    list: DatalogExpression[];
+};
+
+export declare type InferenceVerificationResult = {
+    verified: boolean;
+    testTriple?: {
+        subject: string;
+        predicate: string;
+        object: string;
+    };
+    sparqlQuery?: string;
+    candidateQuery?: string;
+    error?: string;
+};
+
+export declare const INTEGER: TokenType;
+
+export declare const INTERNAL_FUNCTION: TokenType;
+
+export declare function invertComparisonOperator(operator: ComparisonOperator): ComparisonOperator;
+
+export declare const IRI: TokenType;
+
+export declare const IRI_REF: TokenType;
+
+export declare const iriBodyCharClass = "[^\\s<>\"{}|^`\\\\]";
+
+export declare type IriCstChildren = {
+    IRI_REF?: IToken[];
+    INTERNAL_FUNCTION?: IToken[];
+    PREFIXED_NAME?: IToken[];
+    DEFAULT_NS_IRI?: IToken[];
+    PREFIX_ONLY?: IToken[];
+    IDENTIFIER?: IToken[];
+};
+
+export declare interface IriCstNode extends CstNode {
+    name: "iri";
+    children: IriCstChildren;
+}
+
+export declare type IriFunctionCstChildren = {
+    IRI: IToken[];
+    LPAREN: IToken[];
+    iriExpr: ExpressionCstNode[];
+    COMMA?: IToken[];
+    baseIri?: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface IriFunctionCstNode extends CstNode {
+    name: "iriFunction";
+    children: IriFunctionCstChildren;
+}
+
+export declare type IriTerm = {
+    type: "iri";
+    value: string;
+    prefixed: boolean;
+};
+
+export declare const iriTokenTypes: Set<TokenType>;
+
+export declare const isAggregateFormula: (formula: DatalogBodyFormula) => formula is DatalogAggregate;
+
+export declare function isBareNumericLiteral(literal: LiteralTerm): boolean;
+
+export declare const isBinaryExpression: (expr: DatalogExpression) => expr is BinaryExpression;
+
+export declare const isBindFormula: (formula: DatalogBodyFormula) => formula is DatalogBind;
+
+export declare const isBlankNodeTerm: (term: DatalogTerm) => term is BlankNodeTerm;
+
+export declare function isBooleanLiteral(literal: LiteralTerm): boolean;
+
+export declare const isClassAtom: (atom: DatalogAtom) => atom is ClassAtom;
+
+export declare function isComparisonOperator(operator: BinaryExpression["operator"]): operator is ComparisonOperator;
+
+export declare function isDatalogAtom(formula: DatalogBodyFormula): formula is DatalogAtom;
+
+export declare function isDateLiteral(literal: LiteralTerm): boolean;
+
+export declare function isDateTimeLiteral(literal: LiteralTerm): boolean;
+
+export declare const isFilterFormula: (formula: DatalogBodyFormula) => formula is DatalogFilter;
+
+export declare function isFullIri(value: string): boolean;
+
+export declare const isFunctionCallExpression: (expr: DatalogExpression) => expr is FunctionCallExpression;
+
+export declare const isGeneralAtom: (atom: DatalogAtom) => atom is GeneralAtom;
+
+export declare const isIriTerm: (term: DatalogTerm) => term is IriTerm;
+
+export declare const isLiteralTerm: (term: DatalogTerm) => term is LiteralTerm;
+
+export declare const isLogicalOperator: (operator: BinaryExpression["operator"]) => boolean;
+
+export declare const isNegationFormula: (formula: DatalogBodyFormula) => formula is DatalogNegation;
+
+export declare function isNumericLiteral(literal: LiteralTerm): boolean;
+
+export declare function isNumericLiteralTerm(term: DatalogTerm): term is LiteralTerm;
+
+export declare const isNumericOperator: (operator: BinaryExpression["operator"]) => boolean;
+
+export declare function isNumericRdfValue(value: string): boolean;
+
+export declare const isPropertyAtom: (atom: DatalogAtom) => atom is PropertyAtom;
+
+export declare function isQueryableTermIri(iri: string): boolean;
+
+export declare function isReadOnlySparqlQuery(query: string): {
+    allowed: boolean;
+    error?: string;
+    queryType?: SparqlQueryType;
+};
+
+export declare const isSkolemFormula: (formula: DatalogBodyFormula) => formula is DatalogSkolem;
+
+export declare const isTermExpression: (expr: DatalogExpression) => expr is TermExpression;
+
+export declare const isTripleAtom: (atom: DatalogAtom) => atom is TripleAtom;
+
+export declare const isUnaryExpression: (expr: DatalogExpression) => expr is UnaryExpression;
+
+export declare const isVariableTerm: (term: DatalogTerm) => term is VariableTerm;
+
+export declare function isXsdDatatype(datatype: string | undefined, localName: XsdDatatypeLocalName): boolean;
+
+export declare const keywordTokenTypes: Set<TokenType>;
+
+export declare const LANGTAG: TokenType;
+
+export declare const LBRACKET: TokenType;
+
+export declare const LESS_THAN: TokenType;
+
+export declare const LESS_THAN_OR_EQUAL: TokenType;
+
+export declare type LiteralCstChildren = {
+    numericLiteral?: NumericLiteralCstNode[];
+    booleanLiteral?: BooleanLiteralCstNode[];
+    stringLiteral?: StringLiteralCstNode[];
+};
+
+export declare interface LiteralCstNode extends CstNode {
+    name: "literal";
+    children: LiteralCstChildren;
+}
+
+export declare type LiteralSetComparison = {
+    subject: DatalogTerm;
+    literals: LiteralTerm[];
+    negated: boolean;
+};
+
+export declare function literalSetComparisonFromExpression(expression: DatalogExpression): LiteralSetComparison | null;
+
+export declare type LiteralTerm = {
+    type: "literal";
+    value: string;
+    datatype?: string;
+    language?: string;
+    termSpan?: SourceSpan;
+    valueSpan?: SourceSpan;
+};
+
+export declare function literalToDisplayText(literal: LiteralTerm): string;
+
+export declare const LPAREN: TokenType;
+
+export declare const MAX: TokenType;
+
+export declare const MAX_ARGMAX: TokenType;
+
+export declare const MAX_ARGMIN: TokenType;
+
+export declare const MIN: TokenType;
+
+export declare const MIN_ARGMAX: TokenType;
+
+export declare const MIN_ARGMIN: TokenType;
+
+export declare const MINUS: TokenType;
+
+export declare const MUL: TokenType;
+
+export declare type MultiplicativeExpressionCstChildren = {
+    unaryExpression: UnaryExpressionCstNode[];
+    STAR?: IToken[];
+    SLASH?: IToken[];
+};
+
+export declare interface MultiplicativeExpressionCstNode extends CstNode {
+    name: "multiplicativeExpression";
+    children: MultiplicativeExpressionCstChildren;
+}
+
+export declare type NegationCstChildren = {
+    NOT: IToken[];
+    existsClause?: ExistsClauseCstNode[];
+    LPAREN?: IToken[];
+    bodyFormulaList?: BodyFormulaListCstNode[];
+    RPAREN?: IToken[];
+    tupleTableAtom?: TupleTableAtomCstNode[];
+};
+
+export declare interface NegationCstNode extends CstNode {
+    name: "negation";
+    children: NegationCstChildren;
+}
+
+export declare const NOT: TokenType;
+
+export declare const NOT_EQUALS: TokenType;
+
+export declare type NumericLiteralCstChildren = {
+    DOUBLE?: IToken[];
+    DECIMAL?: IToken[];
+    INTEGER?: IToken[];
+};
+
+export declare interface NumericLiteralCstNode extends CstNode {
+    name: "numericLiteral";
+    children: NumericLiteralCstChildren;
+}
+
+export declare const numericLiteralTokenTypes: Set<TokenType>;
+
+export declare const ON: TokenType;
+
+export declare type OnClauseCstChildren = {
+    ON: IToken[];
+    VARIABLE?: IToken[];
+    groundedAsTarget?: GroundedAsTargetCstNode[];
+};
+
+export declare interface OnClauseCstNode extends CstNode {
+    name: "onClause";
+    children: OnClauseCstChildren;
+}
+
+export declare const operatorTokenTypes: Set<TokenType>;
+
+export declare const OR: TokenType;
+
+export declare function parseBooleanLiteral(value: string): boolean | undefined;
+
+/**
+ * Parse a Datalog rule string into a type-safe AST
+ */
+export declare function parseDatalogRule(ruleText: string): DatalogRule;
+
+/**
+ * Parse a Datalog rule string, returning structured issues with source
+ * positions instead of throwing on invalid input
+ */
+export declare function parseDatalogRuleWithIssues(ruleText: string): DatalogParseResult;
+
+/**
+ * Parse a single Datalog term (IRI, literal, blank node, or variable) from its
+ * text form.
+ *
+ * Fact values reach the UI as Datalog term text rather than bare strings, so
+ * rendering one means recovering its structure first: a literal carries quotes
+ * and an optional datatype or language suffix around the value to display,
+ * while an IRI denotes an entity and is rendered as a chip instead. Literal
+ * source spans are relative to the input text.
+ *
+ * Returns undefined when the text is not exactly one term.
+ */
+export declare function parseDatalogTermText(termText: string): DatalogTerm | undefined;
+
+/**
+ * Parse a grounded rule returned by RDFox, where `AS` targets have been
+ * substituted with the values they evaluated to. Authored rules must go through
+ * `parseDatalogRule` so that those substitutions stay invalid.
+ */
+export declare function parseGroundedDatalogRule(ruleText: string): GroundedDatalogRule;
+
+/**
+ * Parse a grounded rule and return its CST, accepting values in `AS` target
+ * position. Use `parseRule` for anything a human or the agent authored.
+ */
+export declare function parseGroundedRule(text: string): CstNode;
+
+export declare function parserInstance(): DatalogParser;
+
+export declare function parseRule(text: string): CstNode;
+
+/** Lex and parse `text` with the given parser instance (strict or expanded). */
+export declare function parseRuleWith(parser: DatalogParser, text: string): CstNode;
+
+export declare function plainDecimalText(value: string): string;
+
+export declare const PLUS: TokenType;
+
+export declare function positiveBodyContainsSkolem(body: DatalogBodyFormula[]): boolean;
+
+export declare type PredicateEvidence = {
+    term: string;
+    position: PredicatePosition;
+};
+
+export declare type PredicatePosition = "domain" | "range";
+
+export declare const PREFIX_ONLY: TokenType;
+
+export declare const PREFIXED_NAME: TokenType;
+
+export declare type PrimaryExpressionCstChildren = {
+    LPAREN?: IToken[];
+    expression?: ExpressionCstNode[];
+    RPAREN?: IToken[];
+    functionCall?: FunctionCallCstNode[];
+    literal?: LiteralCstNode[];
+    VARIABLE?: IToken[];
+    BLANK_NODE?: IToken[];
+    iri?: IriCstNode[];
+};
+
+export declare interface PrimaryExpressionCstNode extends CstNode {
+    name: "primaryExpression";
+    children: PrimaryExpressionCstChildren;
+}
+
+export declare type PropertyAssertion = {
+    predicate: string;
+    subject: DatalogTerm;
+    object: DatalogTerm;
+    graph?: DatalogTerm;
+};
+
+export declare function propertyAssertionFromAtom(atom: DatalogAtom): PropertyAssertion | null;
+
+export declare type PropertyAtom = {
+    type: "property";
+    predicate: string;
+    subject: DatalogTerm;
+    object: DatalogTerm;
+    graph?: DatalogTerm;
+};
+
+export declare const RBRACKET: TokenType;
+
+/**
+ * RDFox Transaction Management Library
+ *
+ * This module provides side-effecty functions for managing RDFox connections and transactions
+ * via the RESTful API. It follows RDFox's connection-based transaction model where transactions
+ * are associated with data store connections.
+ *
+ * @see https://docs.oxfordsemantic.tech/apis.html#transactions-in-the-restful-api
+ */
+export declare type RDFoxConnectionParams = {
+    rdfoxUrl: string;
+    datastoreName: string;
+    authorization: string;
+};
+
+export declare type RDFoxTransactionParams = RDFoxConnectionParams & {
+    connectionId: string;
+};
+
+export declare const REGEX: TokenType;
+
+export declare type RegexFunctionCstChildren = {
+    REGEX: IToken[];
+    LPAREN: IToken[];
+    textExpr: ExpressionCstNode[];
+    COMMA: IToken[];
+    patternExpr: ExpressionCstNode[];
+    flagsExpr?: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface RegexFunctionCstNode extends CstNode {
+    name: "regexFunction";
+    children: RegexFunctionCstChildren;
+}
+
+export declare type RelationalExpressionCstChildren = {
+    additiveExpression: AdditiveExpressionCstNode[];
+    EQUALS?: IToken[];
+    NOT_EQUALS?: IToken[];
+    LESS_THAN?: IToken[];
+    GREATER_THAN?: IToken[];
+    LESS_THAN_OR_EQUAL?: IToken[];
+    GREATER_THAN_OR_EQUAL?: IToken[];
+    IN?: IToken[];
+    LPAREN?: IToken[];
+    argumentList?: ArgumentListCstNode[];
+    RPAREN?: IToken[];
+    NOT?: IToken[];
+};
+
+export declare interface RelationalExpressionCstNode extends CstNode {
+    name: "relationalExpression";
+    children: RelationalExpressionCstChildren;
+}
+
+export declare type ResolvableTerm = {
+    domainIncludes: string[];
+    rangeIncludes: string[];
+};
+
+export declare function resolveVariableTypes(evidence: VariableTypeEvidence[], lookupTerm: (term: string) => ResolvableTerm | undefined): VariableType[];
+
+/**
+ * Rollback a transaction on a connection
+ */
+export declare function rollbackTransaction(params: RDFoxTransactionParams): Promise<void>;
+
+export declare const ROUND: TokenType;
+
+export declare type RoundFunctionCstChildren = {
+    ROUND: IToken[];
+    LPAREN: IToken[];
+    expression: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface RoundFunctionCstNode extends CstNode {
+    name: "roundFunction";
+    children: RoundFunctionCstChildren;
+}
+
+export declare const RPAREN: TokenType;
+
+export declare const RULE_ARROW: TokenType;
+
+export declare type RuleBodyCstChildren = {
+    bodyFormula: BodyFormulaCstNode[];
+    COMMA?: IToken[];
+};
+
+export declare interface RuleBodyCstNode extends CstNode {
+    name: "ruleBody";
+    children: RuleBodyCstChildren;
+}
+
+export declare type RuleCstChildren = {
+    ruleHead: RuleHeadCstNode[];
+    RULE_ARROW: IToken[];
+    ruleBody?: RuleBodyCstNode[];
+    DOT: IToken[];
+};
+
+export declare interface RuleCstNode extends CstNode {
+    name: "rule";
+    children: RuleCstChildren;
+}
+
+export declare type RuleHeadCstChildren = {
+    tupleTableAtom: TupleTableAtomCstNode[];
+    COMMA?: IToken[];
+};
+
+export declare interface RuleHeadCstNode extends CstNode {
+    name: "ruleHead";
+    children: RuleHeadCstChildren;
+}
+
+export declare type RuleVocabulary = {
+    head: RuleVocabularyPosition;
+    body: RuleVocabularyPosition;
+};
+
+export declare type RuleVocabularyExtractionResult = {
+    ok: true;
+    vocabulary: RuleVocabulary;
+} | {
+    ok: false;
+    issues: DatalogParseIssue[];
+};
+
+export declare type RuleVocabularyPosition = {
+    classes: RuleVocabularyReference[];
+    predicates: RuleVocabularyReference[];
+};
+
+export declare type RuleVocabularyReference = {
+    term: string;
+    graph?: DatalogTerm;
+};
+
+export declare type SimpleComparison = {
+    variableName: string;
+    operator: ComparisonOperator;
+    literal: LiteralTerm;
+};
+
+export declare function simpleComparisonFromExpression(expression: DatalogExpression): SimpleComparison | null;
+
+export declare function simpleComparisonFromFilter(filter: DatalogFilter): SimpleComparison | null;
+
+export declare const SKOLEM: TokenType;
+
+export declare type SkolemAtomCstChildren = {
+    SKOLEM: IToken[];
+    LPAREN: IToken[];
+    argumentList: ArgumentListCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface SkolemAtomCstNode extends CstNode {
+    name: "skolemAtom";
+    children: SkolemAtomCstChildren;
+}
+
+export declare type SkolemFunctionCstChildren = {
+    SKOLEM: IToken[];
+    LPAREN: IToken[];
+    argumentList: ArgumentListCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface SkolemFunctionCstNode extends CstNode {
+    name: "skolemFunction";
+    children: SkolemFunctionCstChildren;
+}
+
+export declare function skolemMintedVariable(formula: DatalogBodyFormula): string | null;
+
+export declare const SLASH: TokenType;
+
+export declare type SourceSpan = {
+    start: number;
+    end: number;
+};
+
+export declare type SparqlQueryType = "select" | "construct" | "describe" | "ask" | "update";
+
+export declare interface SparqlSelectResult {
+    query: string;
+    variables: string[];
+}
+
+export declare type SparqlUpdateValidationResult = {
+    allowed: true;
+    operationTypes: DataManipulationSubType[];
+} | {
+    allowed: false;
+    error: string;
+    blockedOperations?: UpdateSubType[];
+};
+
+export declare type SparqlValidationResult = {
+    valid: true;
+    queryType: SparqlQueryType;
+    isReadOnly: boolean;
+} | {
+    valid: false;
+    error: string;
+};
+
+export declare const STAR: TokenType;
+
+export declare const STR: TokenType;
+
+export declare type StrFunctionCstChildren = {
+    STR: IToken[];
+    LPAREN: IToken[];
+    expression: ExpressionCstNode[];
+    RPAREN: IToken[];
+};
+
+export declare interface StrFunctionCstNode extends CstNode {
+    name: "strFunction";
+    children: StrFunctionCstChildren;
+}
+
+export declare const STRING_LITERAL: TokenType;
+
+export declare const STRING_LITERAL_LONG: TokenType;
+
+export declare type StringLiteralCstChildren = {
+    STRING_LITERAL_LONG?: IToken[];
+    STRING_LITERAL?: IToken[];
+    LANGTAG?: IToken[];
+    HAT?: IToken[];
+    iri?: IriCstNode[];
+};
+
+export declare interface StringLiteralCstNode extends CstNode {
+    name: "stringLiteral";
+    children: StringLiteralCstChildren;
+}
+
+export declare const stringLiteralTokenTypes: Set<TokenType>;
+
+export declare const SUM: TokenType;
+
+export declare type TermCstChildren = {
+    VARIABLE?: IToken[];
+    iri?: IriCstNode[];
+    literal?: LiteralCstNode[];
+    BLANK_NODE?: IToken[];
+};
+
+export declare interface TermCstNode extends CstNode {
+    name: "term";
+    children: TermCstChildren;
+}
+
+export declare type TermExpression = {
+    type: "term";
+    term: DatalogTerm;
+};
+
+export declare function termsEqual(left: DatalogTerm, right: DatalogTerm): boolean;
+
+/**
+ * Compare two serialized terms by meaning rather than by text, so `1.2`,
+ * `"1.2"^^xsd:decimal` and `"1.2"^^<http://www.w3.org/2001/XMLSchema#decimal>`
+ * all count as the same value. Returns undefined when either side is not a
+ * single term, so callers can tell "different" apart from "not comparable".
+ * Prefixed and absolute IRIs are not resolved against each other - normalize
+ * IRIs to one form before calling.
+ */
+export declare function termTextsEqual(left: string, right: string): boolean | undefined;
+
+export declare function termToDatalogText(term: DatalogTerm, options?: DatalogTextOptions): string;
+
+export declare const termTokenTypes: Set<TokenType>;
+
+export declare function termToSparql(term: DatalogTerm): string;
+
+export declare function tokenizeDatalog(text: string): ILexingResult;
+
+export declare type TripleAtom = {
+    type: "triple";
+    subject: DatalogTerm;
+    predicate: DatalogTerm;
+    object: DatalogTerm;
+    graph?: DatalogTerm;
+};
+
+export declare const TRUE: TokenType;
+
+export declare type TupleTableAtomCstChildren = {
+    defaultGraphAtom?: DefaultGraphAtomCstNode[];
+    generalAtom?: GeneralAtomCstNode[];
+    graph?: GraphNameCstNode[];
+};
+
+export declare interface TupleTableAtomCstNode extends CstNode {
+    name: "tupleTableAtom";
+    children: TupleTableAtomCstChildren;
+}
+
+export declare type UnaryAggregateBinding = AggregateBindingTarget & {
+    function: UnaryAggregateFunction;
+    distinct?: boolean;
+    expression: DatalogExpression | "*";
+    secondExpression?: never;
+};
+
+export declare type UnaryAggregateFunction = "COUNT" | "MIN" | "MAX" | "SUM" | "MUL" | "AVG" | "COUNT_MIN" | "COUNT_MAX";
+
+export declare type UnaryExpression = {
+    type: "unary";
+    operator: "!" | "+" | "-";
+    operand: DatalogExpression;
+};
+
+export declare type UnaryExpressionCstChildren = {
+    EXCLAMATION?: IToken[];
+    PLUS?: IToken[];
+    MINUS?: IToken[];
+    primaryExpression: PrimaryExpressionCstNode[];
+};
+
+export declare interface UnaryExpressionCstNode extends CstNode {
+    name: "unaryExpression";
+    children: UnaryExpressionCstChildren;
+}
+
+export declare function unaryOperandNeedsParentheses(operand: DatalogExpression): boolean;
+
+export declare function unwrapTermExpression(expression: DatalogExpression): DatalogTerm | null;
+
+export declare type UpdateSubType = UpdateOperation["subType"];
+
+/**
+ * Validate Datalog rule syntax and that every required variable is bound.
+ */
+export declare function validateDatalogRule(ruleText: string): {
+    valid: boolean;
+    error?: string;
+};
+
+export declare function validateDataManipulationUpdate(update: string): SparqlUpdateValidationResult;
+
+export declare function validateRuleSyntax(text: string): {
+    valid: boolean;
+    error?: string;
+};
+
+export declare function validateSparqlQuery(query: string): SparqlValidationResult;
+
+export declare const VARIABLE: TokenType;
+
+export declare function variableNameFromTermExpression(expression: DatalogExpression): string | null;
+
+export declare function variableNamesFromAtom(atom: DatalogAtom): string[];
+
+export declare function variableNamesFromExpression(expression: DatalogExpression): string[];
+
+export declare type VariableTerm = {
+    type: "variable";
+    name: string;
+};
+
+export declare type VariableType = {
+    variable: string;
+    typeTerm: string;
+    source: VariableTypeSource;
+};
+
+export declare type VariableTypeEvidence = {
+    variable: string;
+    classTerm?: string;
+    bodyClassTerm?: string;
+    predicateEvidence: PredicateEvidence[];
+};
+
+export declare type VariableTypeSource = "class" | PredicatePosition;
+
+/**
+ * Verify that a rule produces the expected inference
+ */
+export declare function verifyRuleInference(rule: DatalogRule, rdfoxUrl: string, datastoreId: string, authorization: string, testTriple?: {
+    subject: string;
+    predicate: string;
+    object: string;
+}): Promise<InferenceVerificationResult>;
+
+export declare const WHITESPACE: TokenType;
+
+/**
+ * Execute a function within a transaction context, automatically handling commit/rollback
+ */
+export declare function withTransaction<T>(params: RDFoxConnectionParams, fn: (connectionId: string) => Promise<T>): Promise<T>;
+
+export declare type XsdDatatypeLocalName = keyof typeof xsdDatatypes;
+
+export declare const xsdDatatypes: {
+    readonly integer: "xsd:integer";
+    readonly decimal: "xsd:decimal";
+    readonly double: "xsd:double";
+    readonly boolean: "xsd:boolean";
+    readonly string: "xsd:string";
+    readonly date: "xsd:date";
+    readonly dateTime: "xsd:dateTime";
+};
+
+export { }