@dbml/parse 7.1.2 → 8.0.0-alpha.10

package/dist/src/core/global_modules/diagramView/bind.d.ts

@@ -0,0 +1,18 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+export default class DiagramViewBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    });
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
+    private bindTableReferences;
+    private bindNoteReferences;
+    private bindTableGroupReferences;
+    private bindSchemaReferences;
+}

package/dist/src/core/global_modules/diagramView/index.d.ts

@@ -0,0 +1,8 @@
+import { SyntaxNode } from '../../types/nodes';
+import { GlobalModule } from '../types';
+import { CompileError } from '../../types';
+export declare const diagramViewUtils: {
+    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
+    getFieldDuplicateError(name: string, elementKind: string, errorNode: SyntaxNode): CompileError;
+};
+export declare const diagramViewModule: GlobalModule;

package/dist/src/core/global_modules/diagramView/interpret.d.ts

@@ -0,0 +1,37 @@
+import { default as Compiler } from '../../../compiler';
+import { Filepath } from '../../types/filepath';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { DiagramView } from '../../types';
+import { default as Report } from '../../types/report';
+import { DiagramViewSymbol } from '../../types/symbol';
+export declare class DiagramViewInterpreter {
+    private compiler;
+    private declarationNode;
+    private symbol;
+    private filepath;
+    private diagramView;
+    private diagramViewWildcards;
+    private diagramViewExplicitlySet;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode, symbol: DiagramViewSymbol, filepath: Filepath);
+    interpret(): Report<DiagramView>;
+    private interpretBody;
+    private interpretSubBlock;
+    /**
+     * Expand explicit wildcard ([]) for tableGroups in DiagramView visibleEntities
+     * to the concrete list of table group names.
+     *
+     * Expands when:
+     * 1. The user wrote `TableGroups { * }` (tracked via diagramViewWildcards)
+     * 2. NOT a body-level `{ * }` - body-level wildcard sets ALL dims to [] simultaneously,
+     *    which is a different semantic (show everything) that doesn't need expansion.
+     *    We detect body-level by checking if all four dims are in the wildcards set.
+     *
+     * Why only TableGroups needs expansion:
+     * - Tables: * -> [] means "show all tables" (every table is a table, no indirection)
+     * - Schemas: * -> [] means "show all schemas" (every table belongs to a schema)
+     * - TableGroups: * needs concrete names because some tables DON'T belong to any group.
+     *   The frontend does name-based lookup; [] would produce an empty name map -> no groups matched.
+     */
+    expandDiagramViewWildcards(): void;
+    private getAllTableGroupNames;
+}

package/dist/src/core/global_modules/enum/bind.d.ts

@@ -0,0 +1,11 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class EnumBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/enum/index.d.ts

@@ -0,0 +1,8 @@
+import { CompileError } from '../../types/errors';
+import { SyntaxNode } from '../../types/nodes';
+import { GlobalModule } from '../types';
+export declare const enumUtils: {
+    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
+    getFieldDuplicateError(name: string, errorNode: SyntaxNode): CompileError;
+};
+export declare const enumModule: GlobalModule;

package/dist/src/core/global_modules/enum/interpret.d.ts

@@ -0,0 +1,15 @@
+import { Enum } from '../../types/schemaJson';
+import { EnumSymbol, Filepath } from '../../types';
+import { default as Compiler } from '../../../compiler';
+import { default as Report } from '../../types/report';
+export declare class EnumInterpreter {
+    private compiler;
+    private symbol;
+    private declarationNode;
+    private enum;
+    private filepath;
+    constructor(compiler: Compiler, symbol: EnumSymbol, filepath: Filepath);
+    interpret(): Report<Enum>;
+    private interpretName;
+    private interpretBody;
+}

package/dist/src/core/global_modules/index.d.ts

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../../compiler/index';
+import { Filepath } from '../types/filepath';
+import { Unhandled } from '../types/module';
+import { SyntaxNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { NodeMetadata } from '../types/symbol/metadata';
+import { SchemaElement } from '../types/schemaJson';
+import { NodeSymbol } from '../types/symbol';
+import { GlobalModule } from './types';
+export declare const modules: GlobalModule[];
+export declare function nodeSymbol(this: Compiler, node: SyntaxNode): Report<NodeSymbol> | Report<Unhandled>;
+export declare function symbolMembers(this: Compiler, symbol: NodeSymbol): Report<NodeSymbol[]> | Report<Unhandled>;
+export declare function nodeReferee(this: Compiler, node: SyntaxNode): Report<NodeSymbol | undefined> | Report<Unhandled>;
+export declare function bindNode(this: Compiler, node: SyntaxNode): Report<void> | Report<Unhandled>;
+export declare function nodeMetadata(this: Compiler, node: SyntaxNode): Report<NodeMetadata> | Report<Unhandled>;
+export declare function interpretSymbol(this: Compiler, symbol: NodeSymbol, filepath: Filepath): Report<SchemaElement | SchemaElement[] | undefined> | Report<Unhandled>;
+export declare function interpretMetadata(this: Compiler, metadata: NodeMetadata, filepath: Filepath): Report<SchemaElement | SchemaElement[] | undefined> | Report<Unhandled>;

package/dist/src/core/global_modules/indexes/bind.d.ts

@@ -0,0 +1,12 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class IndexesBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/indexes/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const indexesModule: GlobalModule;

package/dist/src/core/global_modules/indexes/interpret.d.ts

@@ -0,0 +1,10 @@
+import { default as Compiler } from '../../../compiler/index';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { SchemaElement } from '../../types/schemaJson';
+export default class IndexesInterpreter {
+    private compiler;
+    private node;
+    constructor(compiler: Compiler, node: ElementDeclarationNode);
+    interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
+}

package/dist/src/core/global_modules/note/bind.d.ts

@@ -0,0 +1,11 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class NoteBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/note/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const noteModule: GlobalModule;

package/dist/src/core/global_modules/note/interpret.d.ts

@@ -0,0 +1,17 @@
+import { Note } from '../../types/schemaJson';
+import { default as Compiler } from '../../../compiler';
+import { Filepath, NoteSymbol } from '../../types';
+import { default as Report } from '../../types/report';
+export declare class StickyNoteInterpreter {
+    private declarationNode;
+    private symbol;
+    private compiler;
+    private filepath;
+    private note;
+    constructor(compiler: Compiler, symbol: NoteSymbol, filepath: Filepath);
+    interpret(): Report<Note>;
+    private interpretName;
+    private interpretSettingList;
+    private interpretBody;
+    private interpretNote;
+}

package/dist/src/core/global_modules/program/bind.d.ts

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../../../compiler';
+import { ProgramNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+export default class Binder {
+    private ast;
+    private compiler;
+    constructor(ast: ProgramNode, compiler: Compiler);
+    resolve(): Report<void>;
+    private checkDuplicateRefs;
+    private checkStandaloneRefs;
+    private checkInlineRefs;
+    private checkTablePartialSelfRefs;
+    /**
+     * Check that no table appears in more than one TableGroup.
+     */
+    private checkTableGroups;
+}

package/dist/src/core/global_modules/program/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const programModule: GlobalModule;

package/dist/src/core/global_modules/program/interpret.d.ts

@@ -0,0 +1,23 @@
+import { default as Compiler } from '../../../compiler/index';
+import { Filepath } from '../../types/filepath';
+import { default as Report } from '../../types/report';
+import { SchemaElement } from '../../types/schemaJson';
+import { ProgramSymbol } from '../../types/symbol';
+export default class ProgramInterpreter {
+    private compiler;
+    private programSymbol;
+    private programNode;
+    private filepath;
+    private errors;
+    private warnings;
+    private db;
+    constructor(compiler: Compiler, symbol: ProgramSymbol, filepath: Filepath);
+    interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
+    private interpretAllSymbols;
+    private interpretUseSymbol;
+    private interpretAllMetadata;
+    private interpretAllAliases;
+    private validateRecords;
+    private collectPartialRefs;
+    private pushElement;
+}

package/dist/src/core/global_modules/program/utils.d.ts

@@ -0,0 +1,3 @@
+import { Database, ElementRef } from '../../types/schemaJson';
+import { NodeSymbol } from '../../types/symbol';
+export declare function pushExternal(db: Database, member: NodeSymbol, ref: ElementRef): void;

package/dist/src/core/global_modules/project/bind.d.ts

@@ -0,0 +1,11 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class ProjectBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/project/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const projectModule: GlobalModule;

package/dist/src/core/global_modules/project/interpret.d.ts

@@ -0,0 +1,16 @@
+import { default as Compiler } from '../../../compiler';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Project } from '../../types/schemaJson';
+import { Filepath } from '../../types/filepath';
+export declare class ProjectInterpreter {
+    private compiler;
+    private declarationNode;
+    private filepath;
+    private project;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode, filepath: Filepath);
+    interpret(): Report<Project>;
+    private interpretName;
+    private interpretSubElement;
+    private interpretBody;
+}

package/dist/src/core/global_modules/records/bind.d.ts

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class RecordsBinder {
+    private compiler;
+    private declarationNode;
+    private boundColumns;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    bind(): CompileError[];
+    private bindRecordsName;
+    private bindTopLevelName;
+    private bindInsideTableName;
+    private bindBody;
+    private bindDataRows;
+    private bindDataRow;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/records/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const recordsModule: GlobalModule;

package/dist/src/core/global_modules/records/interpret.d.ts

@@ -0,0 +1,13 @@
+import { default as Compiler } from '../../../compiler/index';
+import { default as Report } from '../../types/report';
+import { TableRecord } from '../../types/schemaJson';
+import { Filepath } from '../../types/filepath';
+import { RecordsMetadata } from '../../types/symbol';
+export default class RecordsInterpreter {
+    private compiler;
+    private element;
+    private metadata;
+    private filepath;
+    constructor(compiler: Compiler, metadata: RecordsMetadata, filepath: Filepath);
+    interpret(): Report<TableRecord | undefined>;
+}

package/dist/src/core/global_modules/records/utils/constraints/fk.d.ts

@@ -0,0 +1,13 @@
+import { default as Compiler } from '../../../../../compiler/index';
+import { CompileWarning } from '../../../../types/errors';
+import { Filepath } from '../../../../types/filepath';
+import { SyntaxNode } from '../../../../types/nodes';
+import { Ref, TableRecord } from '../../../../types/schemaJson';
+import { TableSymbol } from '../../../../types/symbol';
+import { InternedNodeSymbol } from '../../../../types/symbol/symbols';
+export type TableInfo = {
+    tableSymbol: TableSymbol;
+    record: TableRecord | undefined;
+    recordBlock: SyntaxNode | undefined;
+};
+export declare function validateForeignKeys(compiler: Compiler, allRefs: Ref[], allRecords: Map<InternedNodeSymbol, TableInfo>, filepath: Filepath): CompileWarning[];

package/dist/src/core/global_modules/records/utils/constraints/helper.d.ts

@@ -0,0 +1,26 @@
+import { default as Compiler } from '../../../../../compiler/index';
+import { CompileWarning } from '../../../../types/errors';
+import { RecordValue, TableRecord } from '../../../../types/schemaJson';
+import { ColumnSymbol } from '../../../../types/symbol';
+export interface ColumnInfo {
+    name: string;
+    pk: boolean;
+    unique: boolean;
+    increment: boolean;
+    notNull: boolean;
+    dbdefault?: {
+        value: string | number;
+        type: string;
+    };
+    typeName: string;
+}
+export declare function columnInfoFromSymbol(col: ColumnSymbol, compiler: Compiler): ColumnInfo;
+export declare function toKeyedRows(record: TableRecord): Record<string, RecordValue>[];
+export declare function makeTableKey(schema: string | null, table: string): string;
+export declare function extractKeyValueWithDefault(row: Record<string, RecordValue>, columnNames: string[], columns?: (ColumnInfo | undefined)[]): string;
+export declare function hasNullWithoutDefaultInKey(row: Record<string, RecordValue>, columnNames: string[], columns?: (ColumnInfo | undefined)[]): boolean;
+export declare function isAutoIncrementColumn(column: ColumnInfo): boolean;
+export declare function formatFullColumnName(schemaName: string | null, tableName: string, columnName: string): string;
+export declare function formatFullColumnNames(schemaName: string | null, tableName: string, columnNames: string[]): string;
+export declare function formatValues(row: Record<string, RecordValue>, columnNames: string[]): string;
+export declare function createConstraintWarning(compiler: Compiler, recordValue: RecordValue, message: string): CompileWarning;

package/dist/src/core/global_modules/records/utils/constraints/pk.d.ts

@@ -0,0 +1,6 @@
+import { default as Compiler } from '../../../../../compiler/index';
+import { CompileWarning } from '../../../../types/errors';
+import { SyntaxNode } from '../../../../types/nodes';
+import { TableRecord } from '../../../../types/schemaJson';
+import { TableSymbol } from '../../../../types/symbol';
+export declare function validatePrimaryKey(compiler: Compiler, tableSymbol: TableSymbol, recordBlock: SyntaxNode, record: TableRecord): CompileWarning[];

package/dist/src/core/global_modules/records/utils/constraints/unique.d.ts

@@ -0,0 +1,5 @@
+import { default as Compiler } from '../../../../../compiler/index';
+import { CompileWarning } from '../../../../types/errors';
+import { TableRecord } from '../../../../types/schemaJson';
+import { TableSymbol } from '../../../../types/symbol';
+export declare function validateUnique(compiler: Compiler, tableSymbol: TableSymbol, record: TableRecord): CompileWarning[];

package/dist/src/core/{interpreter → global_modules}/records/utils/data/sqlTypes.d.ts

@@ -1,4 +1,3 @@
-import { ColumnSymbol } from '../../../../types/symbol/symbols';
 export type SqlDialect = 'mysql' | 'postgres' | 'mssql' | 'oracle' | 'snowflake';
 export declare function normalizeTypeName(type: string): string;
 export declare function isIntegerType(type: string, dialect?: SqlDialect): boolean;
@@ -9,11 +8,4 @@ export declare function isStringType(type: string, dialect?: SqlDialect): boolea
 export declare function isBinaryType(type: string, dialect?: SqlDialect): boolean;
 export declare function isDateTimeType(type: string, dialect?: SqlDialect): boolean;
 export declare function isSerialType(type: string, dialect?: SqlDialect): boolean;
-export declare function getNumericTypeParams(columnSymbol: ColumnSymbol): {
-    precision?: number;
-    scale?: number;
-};
-export declare function getLengthTypeParam(columnSymbol: ColumnSymbol): {
-    length?: number;
-};
 export declare function getRecordValueType(sqlType: string, isEnum: boolean): string;

package/dist/src/core/{interpreter → global_modules}/records/utils/data/values.d.ts

@@ -1,5 +1,5 @@
 import { FunctionExpressionNode, SyntaxNode } from '../../../../types/nodes';
-export { extractNumericLiteral, } from '../../../../analyzer/utils';
+export { extractNumericLiteral } from '../../../../utils/expression';
 export declare function isNullish(value: SyntaxNode): boolean;
 export declare function isEmptyStringLiteral(value: SyntaxNode): boolean;
 export declare function isFunctionExpression(value: SyntaxNode): value is FunctionExpressionNode;

package/dist/src/core/global_modules/ref/bind.d.ts

@@ -0,0 +1,15 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+export default class RefBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    });
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/ref/index.d.ts

@@ -0,0 +1,7 @@
+import { default as Compiler } from '../../../compiler/index';
+import { SyntaxNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { NodeSymbol } from '../../types/symbol';
+import { GlobalModule } from '../types';
+export declare const refModule: GlobalModule;
+export declare function nodeRefereeOfRefEndpoint(compiler: Compiler, globalSymbol: NodeSymbol, node: SyntaxNode): Report<NodeSymbol | undefined>;

package/dist/src/core/global_modules/ref/interpret.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from '../../types/schemaJson';
+import { RefMetadata, Filepath } from '../../types';
+import { default as Compiler } from '../../../compiler';
+import { default as Report } from '../../types/report';
+export declare class RefInterpreter {
+    private compiler;
+    private metadata;
+    private declarationNode;
+    private filepath;
+    private ref;
+    constructor(compiler: Compiler, metadata: RefMetadata, filepath: Filepath);
+    interpret(): Report<Ref>;
+    private interpretName;
+    private interpretBody;
+}

package/dist/src/core/global_modules/schema/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const schemaModule: GlobalModule;

package/dist/src/core/global_modules/table/bind.d.ts

@@ -0,0 +1,18 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+export default class TableBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    });
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private tryToBindColumnType;
+    private tryToBindEnumFieldRef;
+    private bindInlineRef;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/table/index.d.ts

@@ -0,0 +1,9 @@
+import { CompileError } from '../../types/errors';
+import { SyntaxNode } from '../../types/nodes';
+import { GlobalModule } from '../types';
+export declare const tableUtils: {
+    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
+    getColumnDuplicateError(name: string, errorNode: SyntaxNode): CompileError;
+    getPartialInjectionDuplicateError(name: string, errorNode: SyntaxNode): CompileError;
+};
+export declare const tableModule: GlobalModule;

package/dist/src/core/global_modules/table/interpret.d.ts

@@ -0,0 +1,26 @@
+import { default as Compiler } from '../../../compiler';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Table } from '../../types/schemaJson';
+import { Filepath } from '../../types/filepath';
+import { TableSymbol } from '../../types/symbol/symbols';
+export declare class TableInterpreter {
+    private declarationNode;
+    private compiler;
+    private symbol?;
+    private filepath;
+    private table;
+    private pkColumns;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode, symbol: TableSymbol, filepath: Filepath);
+    interpret(): Report<Table>;
+    private interpretName;
+    private interpretAlias;
+    private interpretSettingList;
+    private interpretBody;
+    private interpretSubElements;
+    private interpretInjection;
+    private interpretFields;
+    private interpretColumn;
+    private interpretIndexes;
+    private interpretChecks;
+}

package/dist/src/core/global_modules/table/utils.d.ts

@@ -0,0 +1,4 @@
+import { SyntaxNode } from '../../types/nodes';
+import { ColumnType, InlineRef } from '../../types/schemaJson';
+export declare function interpretColumnType(typeNode?: SyntaxNode): ColumnType;
+export declare function interpretInlineRefs(refs: any[]): InlineRef[];

package/dist/src/core/global_modules/tableGroup/bind.d.ts

@@ -0,0 +1,15 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+export default class TableGroupBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    });
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/tableGroup/index.d.ts

@@ -0,0 +1,8 @@
+import { CompileError } from '../../types/errors';
+import { SyntaxNode } from '../../types/nodes';
+import { GlobalModule } from '../types';
+export declare const tableGroupUtils: {
+    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
+    getFieldDuplicateError(name: string, errorNode: SyntaxNode): CompileError;
+};
+export declare const tableGroupModule: GlobalModule;

package/dist/src/core/global_modules/tableGroup/interpret.d.ts

@@ -0,0 +1,18 @@
+import { TableGroup } from '../../types/schemaJson';
+import { default as Compiler } from '../../../compiler';
+import { Filepath, TableGroupSymbol } from '../../types';
+import { default as Report } from '../../types/report';
+export declare class TableGroupInterpreter {
+    private compiler;
+    private symbol;
+    private declarationNode;
+    private filepath;
+    private tableGroup;
+    constructor(compiler: Compiler, symbol: TableGroupSymbol, filepath: Filepath);
+    interpret(): Report<TableGroup>;
+    private interpretName;
+    private interpretBody;
+    private interpretSubElements;
+    private interpretFields;
+    private interpretSettingList;
+}

package/dist/src/core/global_modules/tablePartial/bind.d.ts

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+export default class TablePartialBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    });
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private tryToBindColumnType;
+    private bindInlineRef;
+    private bindSubElements;
+}

package/dist/src/core/global_modules/tablePartial/index.d.ts

@@ -0,0 +1,7 @@
+import { CompileError } from '../../types/errors';
+import { SyntaxNode } from '../../types/nodes';
+import { GlobalModule } from '../types';
+export declare const tablePartialUtils: {
+    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
+};
+export declare const tablePartialModule: GlobalModule;

package/dist/src/core/global_modules/tablePartial/interpret.d.ts

@@ -0,0 +1,23 @@
+import { default as Compiler } from '../../../compiler/index';
+import { default as Report } from '../../types/report';
+import { SchemaElement } from '../../types/schemaJson';
+import { Filepath } from '../../types/filepath';
+import { TablePartialSymbol } from '../../types/symbol/symbols';
+export declare class TablePartialInterpreter {
+    private declarationNode;
+    private compiler;
+    private symbol?;
+    private filepath;
+    private tablePartial;
+    private pkColumns;
+    constructor(compiler: Compiler, symbol: TablePartialSymbol, filepath: Filepath);
+    interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
+    private interpretName;
+    private interpretSettingList;
+    private interpretBody;
+    private interpretSubElements;
+    private interpretFields;
+    private interpretColumn;
+    private interpretIndexes;
+    private interpretChecks;
+}

package/dist/src/core/global_modules/types.d.ts

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../../compiler/index';
+import { Filepath } from '../types/filepath';
+import { NodeMetadata } from '../types/symbol/metadata';
+import { SyntaxNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { Module, PassThrough } from '../types/module';
+import { SchemaElement } from '../types/schemaJson';
+import { NodeSymbol } from '../types/symbol';
+export interface GlobalModule extends Module {
+    nodeSymbol?(compiler: Compiler, node: SyntaxNode): Report<NodeSymbol> | Report<PassThrough>;
+    symbolMembers?(compiler: Compiler, symbol: NodeSymbol): Report<NodeSymbol[]> | Report<PassThrough>;
+    nodeReferee?(compiler: Compiler, node: SyntaxNode): Report<NodeSymbol | undefined> | Report<PassThrough>;
+    nodeMetadata?(compiler: Compiler, node: SyntaxNode): Report<NodeMetadata> | Report<PassThrough>;
+    bindNode?(compiler: Compiler, node: SyntaxNode): Report<void> | Report<PassThrough>;
+    interpretSymbol?(compiler: Compiler, symbol: NodeSymbol, filepath: Filepath): Report<SchemaElement | SchemaElement[] | undefined> | Report<PassThrough>;
+    interpretMetadata?(compiler: Compiler, metadata: NodeMetadata, filepath: Filepath): Report<SchemaElement | SchemaElement[] | undefined> | Report<PassThrough>;
+}