@xdbml/parse 0.1.0-poc.1

package/dist/ast.d.ts

@@ -0,0 +1,565 @@
+/**
+ * xDBML AST node types.
+ *
+ * The AST is intentionally narrow: each node carries only what's needed
+ * to round-trip xDBML source and to feed a downstream lowering pass
+ * (DDL emitters, JSON Schema emitters, etc.). Generic open-vocabulary
+ * settings are kept as Setting nodes rather than promoted to typed
+ * fields, because the spec leaves the settings vocabulary open.
+ */
+export interface Position {
+    /** 1-indexed line number */
+    line: number;
+    /** 1-indexed column number */
+    column: number;
+    /** 0-indexed byte offset into the source */
+    offset: number;
+}
+export interface Span {
+    start: Position;
+    end: Position;
+}
+export interface XDbmlDocument {
+    kind: 'XDbmlDocument';
+    /** Present when the document opens with `xdbml: 0.1`. DBML-compat documents have this undefined. */
+    version?: VersionDeclaration;
+    experimental?: ExperimentalDeclaration;
+    statements: TopLevelStatement[];
+    span: Span;
+}
+export interface VersionDeclaration {
+    kind: 'VersionDeclaration';
+    /** The literal source text, e.g. "0.1" or "0.1.0". Semver shape validated at parse. */
+    version: string;
+    span: Span;
+}
+export interface ExperimentalDeclaration {
+    kind: 'ExperimentalDeclaration';
+    features: string[];
+    span: Span;
+}
+export type TopLevelStatement = ProjectDeclaration | ContainerDeclaration | EntityDeclaration | TypeDeclaration | EdgeDeclaration | ViewDeclaration | EnumDeclaration | RefDeclaration | TablePartialDeclaration | TableGroupDeclaration | NoteDeclaration | TopLevelRecordsDeclaration | ModuleImportDirective;
+export interface ProjectDeclaration {
+    kind: 'ProjectDeclaration';
+    name: string;
+    body: ProjectBodyItem[];
+    span: Span;
+}
+export type ProjectBodyItem = Setting | NoteBlock;
+export interface ContainerDeclaration {
+    kind: 'ContainerDeclaration';
+    keyword: ContainerKeyword;
+    name: string;
+    settings: Setting[];
+    body: ContainerBodyItem[];
+    span: Span;
+}
+export type ContainerKeyword = 'Container' | 'Schema' | 'Database' | 'Keyspace' | 'Namespace' | 'Dataset' | 'Bucket';
+export type ContainerBodyItem = EntityDeclaration | EdgeDeclaration | ViewDeclaration | EnumDeclaration | NoteBlock | ModuleImportDirective;
+export interface EntityDeclaration {
+    kind: 'EntityDeclaration';
+    keyword: EntityKeyword;
+    /** May be `container.entity` form when declared schema-qualified */
+    name: string;
+    /** Optional `as Alias` */
+    alias?: string;
+    settings: Setting[];
+    body: EntityBodyItem[];
+    span: Span;
+}
+export type EntityKeyword = 'Table' | 'Entity' | 'Collection' | 'Record';
+export type EntityBodyItem = FieldDeclaration | IndexesBlock | ChecksBlock | NoteBlock | PartialInjection | RecordsBlock;
+export interface FieldDeclaration {
+    kind: 'FieldDeclaration';
+    name: string;
+    /** True when the name came from a quoted identifier ("first name") */
+    nameQuoted: boolean;
+    type: TypeExpression;
+    settings: Setting[];
+    span: Span;
+}
+export type TypeExpression = ScalarType | ObjectType | ArrayType | TupleType | MapType | SetType | UnionType | OneOfType | AnyOfType | AllOfType | JsonType | NamedTypeReference;
+export interface ScalarType {
+    kind: 'ScalarType';
+    /** The base name: `int`, `varchar`, `decimal`, `objectId`, `Decimal128`, etc. */
+    name: string;
+    /** `(p, s)` parameters, e.g. for `decimal(19, 4)`. Numbers preserved as strings to keep round-trip fidelity. */
+    params?: string[];
+    span: Span;
+}
+export interface NamedTypeReference {
+    kind: 'NamedTypeReference';
+    name: string;
+    span: Span;
+}
+export interface ObjectType {
+    kind: 'ObjectType';
+    /** Captures whether the source used `object`, `struct`, or `record` */
+    keyword: 'object' | 'struct' | 'record';
+    fields: (FieldDeclaration | NoteBlock | PartialInjection)[];
+    span: Span;
+}
+export interface ArrayType {
+    kind: 'ArrayType';
+    keyword: 'array' | 'list';
+    /** The element type when the array is homogeneous (`array [varchar]`). */
+    elementType?: TypeExpression;
+    /** When the array body uses `name type` form, e.g. `array [line_item object {...}]`, this carries the element name. */
+    elementName?: string;
+    /** Optional settings applied to the element type itself (rare). */
+    elementSettings?: Setting[];
+    span: Span;
+}
+export interface TupleType {
+    kind: 'TupleType';
+    /** Positional elements with `[N] name type` */
+    elements: TupleElement[];
+    span: Span;
+}
+export interface TupleElement {
+    kind: 'TupleElement';
+    position: number;
+    name: string;
+    type: TypeExpression;
+    settings: Setting[];
+    span: Span;
+}
+export interface MapType {
+    kind: 'MapType';
+    keyword: 'map' | 'dict' | 'dictionary';
+    keyType: TypeExpression;
+    valueType: TypeExpression;
+    span: Span;
+}
+export interface SetType {
+    kind: 'SetType';
+    elementType: TypeExpression;
+    span: Span;
+}
+export interface UnionType {
+    kind: 'UnionType';
+    members: (ScalarType | NamedTypeReference | NullTypeLiteral)[];
+    span: Span;
+}
+export interface NullTypeLiteral {
+    kind: 'NullTypeLiteral';
+    span: Span;
+}
+export interface OneOfType {
+    kind: 'OneOfType';
+    alternatives: PolymorphicAlternative[];
+    settings: Setting[];
+    span: Span;
+}
+export interface AnyOfType {
+    kind: 'AnyOfType';
+    alternatives: PolymorphicAlternative[];
+    settings: Setting[];
+    span: Span;
+}
+export interface AllOfType {
+    kind: 'AllOfType';
+    alternatives: PolymorphicAlternative[];
+    settings: Setting[];
+    span: Span;
+}
+export interface PolymorphicAlternative {
+    kind: 'PolymorphicAlternative';
+    name: string;
+    type: TypeExpression;
+    settings: Setting[];
+    span: Span;
+}
+export interface JsonType {
+    kind: 'JsonType';
+    /** `json`, `jsonb`, or `variant` */
+    keyword: 'json' | 'jsonb' | 'variant';
+    /** Optional schema block; absence = opaque JSON column */
+    fields?: (FieldDeclaration | NoteBlock | PartialInjection)[];
+    span: Span;
+}
+export interface TypeDeclaration {
+    kind: 'TypeDeclaration';
+    name: string;
+    /**
+     * v0.2 scalar form (spec §14.7): when present, this Type is an alias
+     * for the given type expression rather than an object-shaped record.
+     * Examples:
+     *
+     *     Type Email varchar [pattern: '...', tags: ['pii']]
+     *     Type Percentage decimal(5,2) [minimum: 0, maximum: 100]
+     *
+     * When `scalarBase` is set, `body` is empty and `settings` carries the
+     * full field-level validation surface (pattern, length bounds, range
+     * bounds, AI-readiness tags, notes, x_* custom properties).
+     *
+     * When `scalarBase` is undefined, the Type uses the v0.1 object form
+     * (`Type Name { ...fields }`) and `body` carries the field declarations.
+     *
+     * Both forms can be used in the same file. Consumers that care about
+     * which form was used look at this field.
+     */
+    scalarBase?: TypeExpression;
+    settings: Setting[];
+    body: (FieldDeclaration | NoteBlock | PartialInjection)[];
+    span: Span;
+}
+export interface EdgeDeclaration {
+    kind: 'EdgeDeclaration';
+    name: string;
+    settings: Setting[];
+    body: EntityBodyItem[];
+    span: Span;
+}
+export interface ViewDeclaration {
+    kind: 'ViewDeclaration';
+    name: string;
+    settings: Setting[];
+    body: ViewBodyItem[];
+    span: Span;
+}
+export type ViewBodyItem = FieldDeclaration | NoteBlock | SourceQueryItem;
+export interface SourceQueryItem {
+    kind: 'SourceQueryItem';
+    /** The raw query string. Opaque to the parser. */
+    query: string;
+    span: Span;
+}
+export interface EnumDeclaration {
+    kind: 'EnumDeclaration';
+    /** Source casing of `enum` or `Enum`; both are valid. */
+    keywordCasing: string;
+    name: string;
+    values: EnumValue[];
+    span: Span;
+}
+export interface EnumValue {
+    kind: 'EnumValue';
+    name: string;
+    nameQuoted: boolean;
+    settings: Setting[];
+    span: Span;
+}
+export interface RefDeclaration {
+    kind: 'RefDeclaration';
+    /** Optional named ref */
+    name?: string;
+    spec: RefSpec;
+    settings: Setting[];
+    span: Span;
+}
+export interface RefSpec {
+    kind: 'RefSpec';
+    source: RefEndpoint;
+    operator: CardinalityOperator;
+    target: RefEndpoint;
+    span: Span;
+}
+export type CardinalityOperator = '<' | '>' | '-' | '<>';
+export interface RefEndpoint {
+    kind: 'RefEndpoint';
+    /**
+     * The dotted path. Composite FK form `customers.(id, country_code)` is
+     * captured by `compositeFields` being non-empty.
+     */
+    path: PathSegment[];
+    compositeFields?: string[];
+    span: Span;
+}
+export type PathSegment = PathField | PathArrayIndex | PathArrayWildcard | PathMapKey;
+export interface PathField {
+    kind: 'PathField';
+    name: string;
+    /** True for `.alternative_name` selectors through polymorphism */
+    isAlternativeSelector?: boolean;
+    span: Span;
+}
+export interface PathArrayIndex {
+    kind: 'PathArrayIndex';
+    index: number;
+    span: Span;
+}
+export interface PathArrayWildcard {
+    kind: 'PathArrayWildcard';
+    span: Span;
+}
+export interface PathMapKey {
+    kind: 'PathMapKey';
+    key: string;
+    span: Span;
+}
+export interface IndexesBlock {
+    kind: 'IndexesBlock';
+    entries: IndexEntry[];
+    span: Span;
+}
+export interface IndexEntry {
+    kind: 'IndexEntry';
+    /** When this is a composite index, multiple components; otherwise one. */
+    components: IndexComponent[];
+    settings: Setting[];
+    span: Span;
+}
+export type IndexComponent = IndexPathComponent | IndexExpressionComponent;
+export interface IndexPathComponent {
+    kind: 'IndexPathComponent';
+    path: PathSegment[];
+    span: Span;
+}
+export interface IndexExpressionComponent {
+    kind: 'IndexExpressionComponent';
+    /** Source text inside the backticks, no surrounding backticks */
+    expression: string;
+    span: Span;
+}
+export interface ChecksBlock {
+    kind: 'ChecksBlock';
+    entries: CheckEntry[];
+    span: Span;
+}
+export interface CheckEntry {
+    kind: 'CheckEntry';
+    /** Source text inside the backticks, no surrounding backticks. */
+    expression: string;
+    /** Optional settings -- typically `name:` and/or `note:`. */
+    settings: Setting[];
+    span: Span;
+}
+export interface TablePartialDeclaration {
+    kind: 'TablePartialDeclaration';
+    name: string;
+    settings: Setting[];
+    body: EntityBodyItem[];
+    span: Span;
+}
+export interface TableGroupDeclaration {
+    kind: 'TableGroupDeclaration';
+    name: string;
+    settings: Setting[];
+    members: string[];
+    span: Span;
+}
+export interface PartialInjection {
+    kind: 'PartialInjection';
+    /** Identifier after the `~`. */
+    partialName: string;
+    span: Span;
+}
+export interface RecordsBlock {
+    kind: 'RecordsBlock';
+    rows: RecordRow[];
+    span: Span;
+}
+export interface RecordRow {
+    kind: 'RecordRow';
+    values: SettingValue[];
+    span: Span;
+}
+export interface TopLevelRecordsDeclaration {
+    kind: 'TopLevelRecordsDeclaration';
+    /**
+     * The entity being populated. Dotted form for cross-container references
+     * such as `core.users`. Stored as the source-text dotted path; no
+     * resolution is performed at parse time.
+     */
+    entityRef: string;
+    /** The explicit column list. Required for the top-level form. */
+    columns: string[];
+    rows: RecordRow[];
+    span: Span;
+}
+export interface NoteDeclaration {
+    kind: 'NoteDeclaration';
+    name?: string;
+    body: string;
+    span: Span;
+}
+/** Inline `Note: '...'` or `Note { '''...''' }` form */
+export interface NoteBlock {
+    kind: 'NoteBlock';
+    body: string;
+    span: Span;
+}
+export interface ModuleImportDirective {
+    kind: 'ModuleImportDirective';
+    /**
+     * Directive mode:
+     *   - `'reuse'`: transitive (visible to files that further import this file).
+     *     The recommended default per spec §26.4.
+     *   - `'use'`: non-transitive (private to this file).
+     */
+    mode: 'use' | 'reuse';
+    /** What to import: everything (`*`) or a selective list. */
+    spec: ImportSpec;
+    /**
+     * The relative path string from the `from` clause, with quotes stripped.
+     * Stored as-is; path resolution happens at name-resolution time (P5+).
+     */
+    from: string;
+    /**
+     * Optional metadata settings appearing between `from '...'` and the
+     * clone block. In v0.2 phase 1, only `cloned_at` is defined; the parser
+     * is permissive and stores any settings here.
+     */
+    settings: Setting[];
+    /**
+     * The embedded clone block. When present, this is the authoritative
+     * content for the import. When absent (reference-only directive), the
+     * parser must resolve the `from` path at parse time (P5+).
+     */
+    clone?: CloneBlock;
+    span: Span;
+}
+/** Selective vs import-all distinction. */
+export type ImportSpec = {
+    kind: 'ImportAll';
+} | {
+    kind: 'ImportList';
+    items: ImportItem[];
+};
+/**
+ * A single import item in a selective `{ ... }` list:
+ *
+ *     entity core.dim_customer
+ *     type Email as PII_Email
+ *     field core.dim_customer.email
+ *
+ * The element type is one of the keywords from §26.3 (table, entity,
+ * collection, record, enum, tablepartial, note, schema, container,
+ * tablegroup, type, edge, view, diagramview, field). Stored lowercased.
+ *
+ * The source path follows xDBML's standard dotted form. Container.Entity
+ * for an entity inside a Container; Container.Entity.Field for a field.
+ */
+export interface ImportItem {
+    kind: 'ImportItem';
+    /** Lowercased element type keyword. */
+    elementType: string;
+    /** Dotted source path. */
+    sourcePath: string;
+    /** Optional rename in the current file's namespace. */
+    alias?: string;
+    span: Span;
+}
+/**
+ * A clone block embedding the imported declarations directly. For non-field
+ * imports the clone contains TopLevelStatement nodes (the natural shape of
+ * an entity, type, container, etc. clone). Field imports are not supported
+ * in P4 -- when they land, this type may grow to a wider union.
+ *
+ * Per spec §26.6, the clone contains exactly the imported declaration(s),
+ * without surrounding wrappers from the source file. For an entity clone
+ * the content is the EntityDeclaration alone (no container wrapper); for a
+ * container clone the content is the ContainerDeclaration including its
+ * intrinsic entities.
+ */
+export interface CloneBlock {
+    kind: 'CloneBlock';
+    /**
+     * Statements that the importing file pulls in from the source. Most are
+     * top-level shapes (Entity, Type, Enum, Container, etc.). The one
+     * exception is `FieldDeclaration`: when the parent directive imports
+     * one or more fields via `field <path>` items (spec §26.8), each field
+     * appears here as a bare FieldDeclaration with no entity wrapper.
+     * The `flatten()` pass lifts each bare field into a synthetic
+     * TypeDeclaration at file scope so downstream consumers see a normal
+     * Named Type.
+     */
+    statements: (TopLevelStatement | FieldDeclaration)[];
+    span: Span;
+}
+export interface Setting {
+    kind: 'Setting';
+    /** Setting name, lowercased for canonical comparison. Source casing is preserved in `nameSource`. */
+    name: string;
+    nameSource: string;
+    /** Value, if any. A pure flag like `pk` has `value: null`. */
+    value: SettingValue | null;
+    span: Span;
+}
+export type SettingValue = StringValue | NumberValue | BooleanValue | NullValue | IdentifierValue | ExpressionValue | ListValue | RefValue;
+export interface StringValue {
+    kind: 'StringValue';
+    /** The string content with surrounding quotes already stripped */
+    value: string;
+    /** Triple-quoted multi-line string */
+    multiline: boolean;
+    span: Span;
+}
+export interface NumberValue {
+    kind: 'NumberValue';
+    value: string;
+    span: Span;
+}
+export interface BooleanValue {
+    kind: 'BooleanValue';
+    value: boolean;
+    span: Span;
+}
+export interface NullValue {
+    kind: 'NullValue';
+    span: Span;
+}
+export interface IdentifierValue {
+    kind: 'IdentifierValue';
+    /** A bare or dotted identifier used as a value, e.g. `Oracle`, `cascade`, `set null`. */
+    value: string;
+    span: Span;
+}
+export interface ExpressionValue {
+    kind: 'ExpressionValue';
+    /** Source text inside backticks, no surrounding backticks */
+    expression: string;
+    span: Span;
+}
+export interface ListValue {
+    kind: 'ListValue';
+    items: SettingValue[];
+    span: Span;
+}
+/** An inline `ref: > target.field` setting carries a small ref spec. */
+export interface RefValue {
+    kind: 'RefValue';
+    operator: CardinalityOperator;
+    target: RefEndpoint;
+    span: Span;
+}
+export interface ParseOptions {
+    /**
+     * The absolute or canonical path of the file being parsed. Used as the
+     * base directory for relative `from './...'` paths in `use`/`reuse`
+     * directives. If undefined, relative paths in directives can only be
+     * resolved when they're already absolute (rare). For files loaded via
+     * `readFile`, the parser passes the resolved path automatically.
+     */
+    filePath?: string;
+    /**
+     * Synchronous file reader. Called by the parser when it needs to resolve
+     * a reference-only module directive. The argument is a resolved, stable
+     * key: an absolute path for local sources, or a normalized `https://` URL
+     * for remote (v0.3) sources (when a directive's `from` is a URL, or a
+     * relative reference inside a remote module resolves to one). The function
+     * should return the source text for that key, or throw if it is missing
+     * or unreadable.
+     *
+     * Because this reader is synchronous, a host that supports remote sources
+     * must return the fetched text from a cache it populated beforehand. The
+     * network fetch, and its SSRF / redirect / size / timeout obligations
+     * (spec §26.14.5), live in the host's resolver, not in the parser.
+     *
+     * If absent, reference-only directives fall back to the P4 rejection
+     * with a clear "no resolver available" message. Clone-block-bearing
+     * directives still work without a resolver because their content is
+     * embedded in the importing file.
+     */
+    readFile?: (pathOrUrl: string) => string;
+    /**
+     * Maximum recursion depth when resolving directives. Each `from` traversal
+     * deepens the stack by one; circular imports trigger the cycle-detection
+     * path BEFORE this counter increases (cycles produce a parsed directive
+     * with an empty clone, not a depth-limit error). The default (8) is
+     * generous for realistic module graphs and small enough to keep the
+     * stack bounded under pathological inputs.
+     */
+    maxDepth?: number;
+}

package/dist/ast.js

@@ -0,0 +1,10 @@
+/**
+ * xDBML AST node types.
+ *
+ * The AST is intentionally narrow: each node carries only what's needed
+ * to round-trip xDBML source and to feed a downstream lowering pass
+ * (DDL emitters, JSON Schema emitters, etc.). Generic open-vocabulary
+ * settings are kept as Setting nodes rather than promoted to typed
+ * fields, because the spec leaves the settings vocabulary open.
+ */
+export {};

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @xdbml/parse -- proof-of-concept parser for xDBML v0.1 and v0.2.
+ *
+ * Public API:
+ *
+ *   parse(source, options?): XDbmlDocument
+ *     Parse an xDBML document. Returns a fully-typed AST. Passing
+ *     `options.readFile` enables cross-file `use`/`reuse` resolution
+ *     (see ParseOptions for details).
+ *
+ *   tokenize(source): Token[]
+ *     Tokenize the source without parsing. Useful for syntax highlighting.
+ *
+ *   flatten(doc): XDbmlDocument
+ *     Produce a flattened view of a document where ModuleImportDirective
+ *     nodes have been replaced by their clone-block content. Useful for
+ *     downstream consumers that don't care about module provenance.
+ *
+ *   resolveNames(doc): ResolutionResult
+ *     Run the name-resolution pass. Returns a symbol table for queries
+ *     and a list of diagnostics (unresolved references, name conflicts).
+ *     The AST is not mutated. Flattens the input internally.
+ *
+ * The parser is DBML-3.13.6 compatible: a document without an `xdbml: ...`
+ * version header still parses, and DBML constructs are preserved.
+ */
+export * from './ast.ts';
+export { tokenize, TokenKind, LexError } from './lexer.ts';
+export type { Token } from './lexer.ts';
+export { parse, Parser, ParseError } from './parser.ts';
+export { flatten } from './module-resolver.ts';
+export { classifyModuleSource, isUrlKey, ModuleSourceError, } from './module-resolver.ts';
+export type { ModuleSource } from './module-resolver.ts';
+export { resolveNames, SymbolTable } from './name-resolver.ts';
+export type { Diagnostic, DiagnosticCode, ResolutionResult, SymbolEntry, SymbolKind, } from './name-resolver.ts';
+export { xdbmlLanguageConfig, xdbmlMonarchTokensProvider, } from './monarch.ts';
+export type { XDbmlLanguageConfiguration, XDbmlMonarchLanguage, } from './monarch.ts';

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * @xdbml/parse -- proof-of-concept parser for xDBML v0.1 and v0.2.
+ *
+ * Public API:
+ *
+ *   parse(source, options?): XDbmlDocument
+ *     Parse an xDBML document. Returns a fully-typed AST. Passing
+ *     `options.readFile` enables cross-file `use`/`reuse` resolution
+ *     (see ParseOptions for details).
+ *
+ *   tokenize(source): Token[]
+ *     Tokenize the source without parsing. Useful for syntax highlighting.
+ *
+ *   flatten(doc): XDbmlDocument
+ *     Produce a flattened view of a document where ModuleImportDirective
+ *     nodes have been replaced by their clone-block content. Useful for
+ *     downstream consumers that don't care about module provenance.
+ *
+ *   resolveNames(doc): ResolutionResult
+ *     Run the name-resolution pass. Returns a symbol table for queries
+ *     and a list of diagnostics (unresolved references, name conflicts).
+ *     The AST is not mutated. Flattens the input internally.
+ *
+ * The parser is DBML-3.13.6 compatible: a document without an `xdbml: ...`
+ * version header still parses, and DBML constructs are preserved.
+ */
+export * from "./ast.js";
+export { tokenize, TokenKind, LexError } from "./lexer.js";
+export { parse, Parser, ParseError } from "./parser.js";
+export { flatten } from "./module-resolver.js";
+export { classifyModuleSource, isUrlKey, ModuleSourceError, } from "./module-resolver.js";
+export { resolveNames, SymbolTable } from "./name-resolver.js";
+export { xdbmlLanguageConfig, xdbmlMonarchTokensProvider, } from "./monarch.js";

package/dist/keywords.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared keyword vocabulary for xDBML tokenizers and highlighters.
+ *
+ * This module is the single source of truth for the keyword lists
+ * that drive syntax highlighting across multiple surfaces:
+ *
+ *   - parser/src/monarch.ts        the playground's in-editor highlighter
+ *   - tools/textmate/...           the TextMate grammar for VS Code,
+ *                                  Shiki (xdbml.org code blocks, Claude
+ *                                  chat code blocks, etc.), and GitHub
+ *
+ * The grammar in grammar/xDBML.g4 is the language's canonical
+ * specification; this file mirrors its keyword vocabulary in a form
+ * convenient for consumers. A keyword-consistency test (in
+ * parser/test/) asserts that every keyword listed here is recognized
+ * by the parser.
+ *
+ * When adding a keyword to xDBML:
+ *   1. Update the grammar in grammar/xDBML.g4
+ *   2. Update parser/src/parser.ts if the parser needs to recognize it
+ *   3. Add it to the right array below
+ *   4. Re-run the TextMate grammar build script
+ *      (tools/textmate/scripts/build.mjs)
+ *   5. Run `npm test` in the parser package to verify all three
+ *      consumers see the keyword
+ *
+ * All keywords here are case-insensitive in xDBML. Stored in
+ * lower-case as the canonical form; matchers should be case-insensitive.
+ */
+export declare const CONTAINER_KEYWORDS: readonly ["container", "schema", "database", "keyspace", "namespace", "dataset", "bucket"];
+export declare const ENTITY_KEYWORDS: readonly ["table", "entity", "collection", "record"];
+/**
+ * The full set of declaration keywords. Includes containers,
+ * entities, and other top-level constructs.
+ */
+export declare const DECLARATION_KEYWORDS: readonly ["project", "container", "schema", "database", "keyspace", "namespace", "dataset", "bucket", "table", "entity", "collection", "record", "type", "edge", "view", "enum", "ref", "note", "tablepartial", "tablegroup", "diagramview"];
+export declare const STRUCTURAL_TYPE_KEYWORDS: readonly ["object", "struct", "array", "list", "map", "dict", "dictionary", "set", "json", "jsonb", "variant"];
+export declare const POLYMORPHISM_KEYWORDS: readonly ["union", "oneof", "anyof", "allof"];
+export declare const SCALAR_TYPES: readonly ["tinyint", "smallint", "mediumint", "int", "integer", "bigint", "int32", "int64", "float", "double", "decimal", "dec", "numeric", "real", "bit", "bool", "boolean", "char", "varchar", "varchar2", "nvarchar", "nvarchar2", "nchar", "text", "mediumtext", "longtext", "string", "ntext", "binary", "varbinary", "blob", "mediumblob", "longblob", "tinyblob", "tinytext", "json", "jsonb", "variant", "xml", "date", "time", "datetime", "datetime2", "timestamp", "timestamptz", "year", "uuid", "inet6", "money", "smallmoney", "enum"];
+export declare const BSON_TYPES: readonly ["objectid", "decimal128", "bindata", "minkey", "maxkey", "symbol", "regex", "long", "double"];
+export declare const SETTING_FLAGS: readonly ["pk", "primary", "key", "unique", "null", "not", "required", "increment", "inactive"];
+export declare const SETTING_KEYS: readonly ["note", "default", "ref", "name", "color", "headercolor", "as", "check", "type", "target", "targets", "database_type", "source", "source_cardinality", "target_cardinality", "min_source", "max_source", "min_target", "max_target", "undirected", "discriminator", "source_query", "materialized", "refresh_schedule", "refresh_on", "source_database", "storage_options", "pattern", "format", "minlength", "maxlength", "minimum", "maximum", "exclusiveminimum", "exclusivemaximum", "multipleof", "minitems", "maxitems", "uniqueitems", "minproperties", "maxproperties", "synonyms", "business_term", "granularity", "tags", "delete", "update", "indexes", "checks", "replication", "location", "default_charset", "cloned_at"];
+export declare const GRANULARITY_VALUES: readonly ["year", "quarter", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"];
+export declare const DIRECTIVE_KEYWORDS: readonly ["xdbml", "experimental"];
+export declare const MODULE_KEYWORDS: readonly ["use", "reuse", "from", "as"];