@syncular/typegen 0.4.1 → 0.5.0

package/dist/syql-lexer.js

@@ -0,0 +1,367 @@
+/**
+ * Lossless lexer for the revision-1 SYQL frontend (`docs/SYQL.md` §2).
+ *
+ * The lexer owns the SQLite atomic-token boundary used by parsing, formatting,
+ * bind discovery, predicate expansion, and editor tooling. It never rewrites
+ * source text: concatenating every non-EOF token reproduces the input exactly.
+ */
+import { TypegenError } from './errors.js';
+/** A source-spanned, stable-code error shared by the lexer and parser. */
+export class SyqlFrontendError extends TypegenError {
+    code;
+    span;
+    sourceFile;
+    constructor(code, span, message) {
+        super(`${span.file}:${span.start.line}:${span.start.column}`, `${code}: ${message}`);
+        this.name = 'SyqlFrontendError';
+        this.code = code;
+        this.span = span;
+        this.sourceFile = span.file;
+    }
+}
+export function isSyqlTrivia(token) {
+    return (token.kind === 'whitespace' ||
+        token.kind === 'line-comment' ||
+        token.kind === 'block-comment');
+}
+function isAsciiDigit(code) {
+    return code >= 0x30 && code <= 0x39;
+}
+function isAsciiHex(code) {
+    return (isAsciiDigit(code) ||
+        (code >= 0x41 && code <= 0x46) ||
+        (code >= 0x61 && code <= 0x66));
+}
+function isAsciiLetter(code) {
+    return (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a);
+}
+function isIdentifierStart(code) {
+    // SQLite treats non-ASCII characters as alphabetic identifier characters.
+    return code === 0x5f || isAsciiLetter(code) || code >= 0x80;
+}
+function isIdentifierContinue(code) {
+    return isIdentifierStart(code) || isAsciiDigit(code);
+}
+function isAsciiWhitespace(code) {
+    return code === 0x20 || (code >= 0x09 && code <= 0x0d);
+}
+function isPunctuation(ch) {
+    return '(){}[],.;?'.includes(ch);
+}
+const THREE_CHAR_OPERATORS = new Set(['->>']);
+const TWO_CHAR_OPERATORS = new Set([
+    '->',
+    '||',
+    '<<',
+    '>>',
+    '<=',
+    '>=',
+    '==',
+    '!=',
+    '<>',
+]);
+function scanDigitRun(source, start, predicate) {
+    let i = start;
+    let consumed = false;
+    while (i < source.length) {
+        const code = source.charCodeAt(i);
+        if (predicate(code)) {
+            consumed = true;
+            i += 1;
+            continue;
+        }
+        // SQLite 3.46 permits one underscore between digits.
+        if (consumed &&
+            code === 0x5f &&
+            i + 1 < source.length &&
+            predicate(source.charCodeAt(i + 1))) {
+            i += 2;
+            consumed = true;
+            continue;
+        }
+        break;
+    }
+    return i;
+}
+class Lexer {
+    #source;
+    #file;
+    #tokens = [];
+    #offset = 0;
+    #line = 1;
+    #column = 1;
+    #braceDepth = 0;
+    #expectImportPath = false;
+    constructor(file, source) {
+        this.#file = file;
+        this.#source = source;
+    }
+    lex() {
+        while (this.#offset < this.#source.length)
+            this.#next();
+        const atEnd = this.#position();
+        this.#tokens.push({
+            kind: 'eof',
+            text: '',
+            span: { file: this.#file, start: atEnd, end: atEnd },
+        });
+        return this.#tokens;
+    }
+    #position() {
+        return {
+            offset: this.#offset,
+            line: this.#line,
+            column: this.#column,
+        };
+    }
+    #advanceTo(end) {
+        while (this.#offset < end) {
+            const code = this.#source.charCodeAt(this.#offset);
+            if (code === 0x0d) {
+                if (this.#offset + 1 < end &&
+                    this.#source.charCodeAt(this.#offset + 1) === 0x0a) {
+                    this.#offset += 2;
+                }
+                else {
+                    this.#offset += 1;
+                }
+                this.#line += 1;
+                this.#column = 1;
+            }
+            else if (code === 0x0a) {
+                this.#offset += 1;
+                this.#line += 1;
+                this.#column = 1;
+            }
+            else {
+                const point = this.#source.codePointAt(this.#offset);
+                this.#offset += point > 0xffff ? 2 : 1;
+                this.#column += 1;
+            }
+        }
+    }
+    #emit(kind, end) {
+        const start = this.#position();
+        const text = this.#source.slice(this.#offset, end);
+        this.#advanceTo(end);
+        const token = {
+            kind,
+            text,
+            span: { file: this.#file, start, end: this.#position() },
+        };
+        this.#tokens.push(token);
+        this.#afterSignificant(token);
+    }
+    #afterSignificant(token) {
+        if (isSyqlTrivia(token))
+            return;
+        if (token.kind === 'punctuation') {
+            if (token.text === '{')
+                this.#braceDepth += 1;
+            else if (token.text === '}')
+                this.#braceDepth = Math.max(0, this.#braceDepth - 1);
+        }
+        if (token.kind === 'identifier' &&
+            token.text === 'from' &&
+            this.#braceDepth === 0) {
+            this.#expectImportPath = true;
+            return;
+        }
+        if (this.#expectImportPath)
+            this.#expectImportPath = false;
+    }
+    #fail(code, start, end, message) {
+        this.#advanceTo(end);
+        throw new SyqlFrontendError(code, { file: this.#file, start, end: this.#position() }, message);
+    }
+    #next() {
+        const startOffset = this.#offset;
+        const code = this.#source.charCodeAt(startOffset);
+        const ch = this.#source[startOffset];
+        if (startOffset === 0 && code === 0xfeff) {
+            this.#emit('whitespace', startOffset + 1);
+            return;
+        }
+        if (isAsciiWhitespace(code)) {
+            let end = startOffset + 1;
+            while (end < this.#source.length &&
+                isAsciiWhitespace(this.#source.charCodeAt(end))) {
+                end += 1;
+            }
+            this.#emit('whitespace', end);
+            return;
+        }
+        if (this.#source.startsWith('--', startOffset)) {
+            let end = startOffset + 2;
+            while (end < this.#source.length) {
+                const current = this.#source.charCodeAt(end);
+                if (current === 0x0a || current === 0x0d)
+                    break;
+                end += 1;
+            }
+            this.#emit('line-comment', end);
+            return;
+        }
+        if (this.#source.startsWith('/*', startOffset)) {
+            const close = this.#source.indexOf('*/', startOffset + 2);
+            if (close === -1) {
+                this.#fail('SYQL1003_UNTERMINATED_COMMENT', this.#position(), this.#source.length, 'unterminated block comment');
+            }
+            this.#emit('block-comment', close + 2);
+            return;
+        }
+        if (this.#expectImportPath && ch === '"') {
+            this.#scanImportPath();
+            return;
+        }
+        if ((ch === 'x' || ch === 'X') && this.#source[startOffset + 1] === "'") {
+            this.#scanDelimited("'", 'blob', 'SYQL1001_UNTERMINATED_STRING');
+            return;
+        }
+        if (ch === "'") {
+            this.#scanDelimited("'", 'string', 'SYQL1001_UNTERMINATED_STRING');
+            return;
+        }
+        if (ch === '"' || ch === '`') {
+            this.#scanDelimited(ch, 'quoted-identifier', 'SYQL1002_UNTERMINATED_IDENTIFIER');
+            return;
+        }
+        if (ch === '[') {
+            const close = this.#source.indexOf(']', startOffset + 1);
+            if (close === -1) {
+                this.#fail('SYQL1002_UNTERMINATED_IDENTIFIER', this.#position(), this.#source.length, 'unterminated bracketed identifier');
+            }
+            this.#emit('quoted-identifier', close + 1);
+            return;
+        }
+        if (ch === ':') {
+            const next = this.#source.charCodeAt(startOffset + 1);
+            if (isIdentifierStart(next)) {
+                let end = startOffset + 2;
+                while (end < this.#source.length &&
+                    isIdentifierContinue(this.#source.charCodeAt(end))) {
+                    end += 1;
+                }
+                this.#emit('bind', end);
+            }
+            else {
+                this.#emit('operator', startOffset + 1);
+            }
+            return;
+        }
+        if (ch === '@') {
+            const next = this.#source.charCodeAt(startOffset + 1);
+            if (isIdentifierStart(next)) {
+                let end = startOffset + 2;
+                while (end < this.#source.length &&
+                    isIdentifierContinue(this.#source.charCodeAt(end))) {
+                    end += 1;
+                }
+                this.#emit('at-identifier', end);
+            }
+            else {
+                this.#emit('operator', startOffset + 1);
+            }
+            return;
+        }
+        if (isAsciiDigit(code) ||
+            (ch === '.' && isAsciiDigit(this.#source.charCodeAt(startOffset + 1)))) {
+            this.#emit('number', this.#scanNumber(startOffset));
+            return;
+        }
+        if (isIdentifierStart(code)) {
+            let end = startOffset + 1;
+            while (end < this.#source.length &&
+                isIdentifierContinue(this.#source.charCodeAt(end))) {
+                end += 1;
+            }
+            this.#emit('identifier', end);
+            return;
+        }
+        if (isPunctuation(ch)) {
+            this.#emit('punctuation', startOffset + 1);
+            return;
+        }
+        const three = this.#source.slice(startOffset, startOffset + 3);
+        if (THREE_CHAR_OPERATORS.has(three)) {
+            this.#emit('operator', startOffset + 3);
+            return;
+        }
+        const two = this.#source.slice(startOffset, startOffset + 2);
+        if (TWO_CHAR_OPERATORS.has(two)) {
+            this.#emit('operator', startOffset + 2);
+            return;
+        }
+        // Keep unknown SQLite punctuation lossless and let the parser/reference
+        // SQLite validator issue the contextual error later.
+        this.#emit('operator', startOffset + 1);
+    }
+    #scanDelimited(delimiter, kind, code) {
+        const start = this.#position();
+        const contentStart = kind === 'blob' ? this.#offset + 2 : this.#offset + 1;
+        let end = contentStart;
+        while (end < this.#source.length) {
+            if (this.#source[end] !== delimiter) {
+                end += 1;
+                continue;
+            }
+            if (this.#source[end + 1] === delimiter) {
+                end += 2;
+                continue;
+            }
+            this.#emit(kind, end + 1);
+            return;
+        }
+        this.#fail(code, start, this.#source.length, kind === 'string' || kind === 'blob'
+            ? 'unterminated SQL string literal'
+            : 'unterminated quoted identifier');
+    }
+    #scanImportPath() {
+        const start = this.#position();
+        let end = this.#offset + 1;
+        while (end < this.#source.length) {
+            const code = this.#source.charCodeAt(end);
+            if (code === 0x0a || code === 0x0d)
+                break;
+            if (code === 0x5c) {
+                end += 2;
+                continue;
+            }
+            if (code === 0x22) {
+                this.#emit('import-path', end + 1);
+                return;
+            }
+            end += 1;
+        }
+        this.#fail('SYQL1004_UNTERMINATED_IMPORT_PATH', start, Math.min(end, this.#source.length), 'unterminated JSON import path');
+    }
+    #scanNumber(start) {
+        if (this.#source[start] === '0' &&
+            (this.#source[start + 1] === 'x' || this.#source[start + 1] === 'X') &&
+            isAsciiHex(this.#source.charCodeAt(start + 2))) {
+            return scanDigitRun(this.#source, start + 2, isAsciiHex);
+        }
+        let end = start;
+        if (this.#source[end] !== '.') {
+            end = scanDigitRun(this.#source, end, isAsciiDigit);
+        }
+        if (this.#source[end] === '.') {
+            end += 1;
+            end = scanDigitRun(this.#source, end, isAsciiDigit);
+        }
+        if (this.#source[end] === 'e' || this.#source[end] === 'E') {
+            let exponent = end + 1;
+            if (this.#source[exponent] === '+' || this.#source[exponent] === '-') {
+                exponent += 1;
+            }
+            const exponentEnd = scanDigitRun(this.#source, exponent, isAsciiDigit);
+            if (exponentEnd > exponent)
+                end = exponentEnd;
+        }
+        return end;
+    }
+}
+/** Lex one complete `.syql` source file, including trivia and an EOF token. */
+export function lexSyqlSource(file, source) {
+    return new Lexer(file, source).lex();
+}

package/dist/syql-modules.d.ts

@@ -0,0 +1,21 @@
+import { type SyqlImportDeclaration, type SyqlSyntaxFile } from './syql-parser.js';
+export type SyqlModuleErrorCode = 'SYQL4001_IMPORT_OUTSIDE_ROOT' | 'SYQL4002_MODULE_NOT_FOUND' | 'SYQL4003_IMPORT_CYCLE' | 'SYQL4004_UNKNOWN_PREDICATE' | 'SYQL4005_DUPLICATE_IMPORT_TARGET' | 'SYQL4006_DUPLICATE_QUERY';
+export type SyqlSourceLoader = (canonicalPath: string) => string | undefined;
+export interface SyqlImportEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly declaration: SyqlImportDeclaration;
+}
+export interface SyqlModuleGraph {
+    readonly root: string;
+    readonly entries: readonly string[];
+    /** Dependency-first deterministic module order. */
+    readonly modules: readonly SyqlSyntaxFile[];
+    readonly moduleByPath: ReadonlyMap<string, SyqlSyntaxFile>;
+    readonly edges: readonly SyqlImportEdge[];
+}
+/**
+ * Parse and resolve every module reachable from the configured entry files.
+ * Paths passed to `load` are absolute, normalized paths under `root`.
+ */
+export declare function buildSyqlModuleGraph(root: string, entries: readonly string[], load: SyqlSourceLoader): SyqlModuleGraph;

package/dist/syql-modules.js

@@ -0,0 +1,129 @@
+/** Revision-1 SYQL import graph and predicate-library resolver (§4). */
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { SyqlFrontendError, } from './syql-lexer.js';
+import { parseSyqlSyntaxFile, } from './syql-parser.js';
+function startPosition() {
+    return { offset: 0, line: 1, column: 1 };
+}
+function startSpan(file) {
+    const position = startPosition();
+    return { file, start: position, end: position };
+}
+function isWithinRoot(root, candidate) {
+    const path = relative(root, candidate);
+    return (path === '' ||
+        (!isAbsolute(path) && path !== '..' && !path.startsWith(`..${sep}`)));
+}
+function displayPath(root, file) {
+    const path = relative(root, file);
+    return path === '' ? '.' : path.split(sep).join('/');
+}
+class ModuleGraphBuilder {
+    #root;
+    #load;
+    #moduleByPath = new Map();
+    #edges = [];
+    #order = [];
+    #state = new Map();
+    #stack = [];
+    #queryNames = new Map();
+    constructor(root, load) {
+        this.#root = resolve(root);
+        this.#load = load;
+    }
+    build(entries) {
+        const canonicalEntries = entries.map((entry) => this.#entryPath(entry));
+        for (const entry of canonicalEntries)
+            this.#visit(entry);
+        this.#validateImports();
+        this.#validateGlobalQueryNames();
+        return {
+            root: this.#root,
+            entries: canonicalEntries,
+            modules: this.#order,
+            moduleByPath: this.#moduleByPath,
+            edges: this.#edges,
+        };
+    }
+    #entryPath(entry) {
+        const candidate = resolve(this.#root, entry);
+        if (!isWithinRoot(this.#root, candidate)) {
+            this.#fail('SYQL4001_IMPORT_OUTSIDE_ROOT', startSpan(candidate), `entry ${JSON.stringify(entry)} resolves outside the configured queries root`);
+        }
+        return candidate;
+    }
+    #visit(file, incoming) {
+        const state = this.#state.get(file);
+        if (state === 'complete')
+            return this.#moduleByPath.get(file);
+        if (state === 'active') {
+            const cycleStart = this.#stack.indexOf(file);
+            const cycle = [...this.#stack.slice(cycleStart), file]
+                .map((item) => displayPath(this.#root, item))
+                .join(' -> ');
+            this.#fail('SYQL4003_IMPORT_CYCLE', incoming?.span ?? startSpan(file), `SYQL import cycle: ${cycle}`);
+        }
+        const source = this.#load(file);
+        if (source === undefined) {
+            this.#fail('SYQL4002_MODULE_NOT_FOUND', incoming?.span ?? startSpan(file), `SYQL module not found: ${displayPath(this.#root, file)}`);
+        }
+        const module = parseSyqlSyntaxFile(file, source);
+        this.#moduleByPath.set(file, module);
+        this.#state.set(file, 'active');
+        this.#stack.push(file);
+        for (const declaration of module.imports) {
+            const target = resolve(dirname(file), declaration.path);
+            if (!isWithinRoot(this.#root, target)) {
+                this.#fail('SYQL4001_IMPORT_OUTSIDE_ROOT', declaration.span, `import ${JSON.stringify(declaration.path)} escapes the configured queries root`);
+            }
+            this.#edges.push({ from: file, to: target, declaration });
+            this.#visit(target, declaration);
+        }
+        this.#stack.pop();
+        this.#state.set(file, 'complete');
+        this.#order.push(module);
+        return module;
+    }
+    #validateImports() {
+        const importedTargetsByModule = new Map();
+        for (const edge of this.#edges) {
+            const target = this.#moduleByPath.get(edge.to);
+            const predicates = new Set(target.predicates.map((predicate) => predicate.name));
+            let targets = importedTargetsByModule.get(edge.from);
+            if (targets === undefined) {
+                targets = new Set();
+                importedTargetsByModule.set(edge.from, targets);
+            }
+            for (const item of edge.declaration.items) {
+                const key = `${edge.to}\0${item.imported}`;
+                if (targets.has(key)) {
+                    this.#fail('SYQL4005_DUPLICATE_IMPORT_TARGET', item.span, `predicate ${JSON.stringify(item.imported)} is imported more than once from ${displayPath(this.#root, edge.to)}`);
+                }
+                targets.add(key);
+                if (!predicates.has(item.imported)) {
+                    this.#fail('SYQL4004_UNKNOWN_PREDICATE', item.span, `${displayPath(this.#root, edge.to)} does not export predicate ${JSON.stringify(item.imported)}`);
+                }
+            }
+        }
+    }
+    #validateGlobalQueryNames() {
+        for (const module of this.#order) {
+            for (const query of module.queries) {
+                if (this.#queryNames.has(query.name)) {
+                    this.#fail('SYQL4006_DUPLICATE_QUERY', query.nameSpan, `duplicate query name ${JSON.stringify(query.name)} across the configured SYQL graph`);
+                }
+                this.#queryNames.set(query.name, query.nameSpan);
+            }
+        }
+    }
+    #fail(code, span, message) {
+        throw new SyqlFrontendError(code, span, message);
+    }
+}
+/**
+ * Parse and resolve every module reachable from the configured entry files.
+ * Paths passed to `load` are absolute, normalized paths under `root`.
+ */
+export function buildSyqlModuleGraph(root, entries, load) {
+    return new ModuleGraphBuilder(root, load).build(entries);
+}

package/dist/syql-parser.d.ts

@@ -0,0 +1,132 @@
+/** Revision-1 SYQL container parser (`docs/SYQL.md` §3). */
+import { type SyqlSourceSpan, type SyqlToken } from './syql-lexer.js';
+import { type SyqlEmbeddedTemplate } from './syql-template-parser.js';
+export type SyqlBaseType = 'string' | 'integer' | 'float' | 'boolean' | 'json' | 'bytes' | 'blob_ref' | 'crdt';
+export interface SyqlValueType {
+    readonly base: SyqlBaseType;
+    readonly nullable: boolean;
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlValueParameter {
+    readonly kind: 'value';
+    readonly name: string;
+    readonly optional: boolean;
+    readonly type?: SyqlValueType;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export interface SyqlSwitchParameter {
+    readonly kind: 'switch';
+    readonly name: string;
+    readonly optional: true;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export interface SyqlGroupMember {
+    readonly name: string;
+    readonly type?: SyqlValueType;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export interface SyqlGroupParameter {
+    readonly kind: 'group';
+    readonly name: string;
+    readonly optional: true;
+    readonly members: readonly SyqlGroupMember[];
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export type SyqlQueryParameter = SyqlValueParameter | SyqlSwitchParameter | SyqlGroupParameter;
+export interface SyqlPredicateParameter {
+    readonly name: string;
+    readonly type?: SyqlValueType;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+/** A lossless SQL token template between a pair of container braces. */
+export interface SyqlTemplate {
+    readonly text: string;
+    readonly tokens: readonly SyqlToken[];
+    /** Structurally parsed SYQL nodes embedded in the otherwise-lossless SQL. */
+    readonly tree: SyqlEmbeddedTemplate;
+    /** Span of the inner text, excluding braces. */
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlImportItem {
+    readonly imported: string;
+    readonly local: string;
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlImportDeclaration {
+    readonly kind: 'import';
+    readonly items: readonly SyqlImportItem[];
+    /** Decoded JSON path. */
+    readonly path: string;
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlPredicateDeclaration {
+    readonly kind: 'predicate';
+    readonly name: string;
+    readonly parameters: readonly SyqlPredicateParameter[];
+    readonly body: SyqlTemplate;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export interface SyqlSqlSection {
+    readonly kind: 'sql';
+    readonly body: SyqlTemplate;
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlSortProfile {
+    readonly name: string;
+    readonly order: SyqlTemplate;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export interface SyqlSortSection {
+    readonly kind: 'sort';
+    readonly control: string;
+    readonly defaultProfile: string;
+    readonly profiles: readonly SyqlSortProfile[];
+    readonly span: SyqlSourceSpan;
+    readonly controlSpan: SyqlSourceSpan;
+}
+export interface SyqlPageDeclaration {
+    readonly kind: 'page';
+    readonly control: string;
+    readonly defaultSize: number;
+    readonly maxSize: number;
+    readonly span: SyqlSourceSpan;
+    readonly controlSpan: SyqlSourceSpan;
+}
+export interface SyqlIdentityDeclaration {
+    readonly kind: 'identity';
+    readonly fields: readonly string[];
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlQueryDeclaration {
+    readonly kind: 'query';
+    readonly name: string;
+    readonly parameters: readonly SyqlQueryParameter[];
+    readonly sql: SyqlSqlSection;
+    readonly sort?: SyqlSortSection;
+    readonly page?: SyqlPageDeclaration;
+    readonly identity?: SyqlIdentityDeclaration;
+    readonly span: SyqlSourceSpan;
+    readonly nameSpan: SyqlSourceSpan;
+}
+export type SyqlDeclaration = SyqlPredicateDeclaration | SyqlQueryDeclaration;
+export interface SyqlSyntaxFile {
+    readonly kind: 'file';
+    readonly file: string;
+    readonly source: string;
+    readonly tokens: readonly SyqlToken[];
+    readonly imports: readonly SyqlImportDeclaration[];
+    readonly declarations: readonly SyqlDeclaration[];
+    readonly predicates: readonly SyqlPredicateDeclaration[];
+    readonly queries: readonly SyqlQueryDeclaration[];
+    readonly span: SyqlSourceSpan;
+}
+export type SyqlParseErrorCode = 'SYQL2001_EXPECTED_TOKEN' | 'SYQL2002_INVALID_NAME' | 'SYQL2003_RESERVED_NAME' | 'SYQL2004_DUPLICATE_NAME' | 'SYQL2005_INVALID_IMPORT' | 'SYQL2006_EMPTY_TEMPLATE' | 'SYQL2007_FORBIDDEN_SEMICOLON' | 'SYQL2008_INVALID_MEMBER' | 'SYQL2009_INVALID_INTEGER' | 'SYQL2010_INVALID_PAGE_RANGE' | 'SYQL2011_INVALID_PARAMETER';
+/** Parse one `.syql` file using the destructive revision-1 grammar. */
+export declare function parseSyqlSyntaxFile(file: string, source: string): SyqlSyntaxFile;