@dbml/parse 7.1.2 → 8.0.0-alpha.10

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

@@ -0,0 +1,8 @@
+import { default as Compiler } from '../../../compiler';
+import { UseSpecifierNode } from '../../types/nodes';
+import { UseSymbol } from '../../types/symbol';
+import { GlobalModule } from '../types';
+export declare const useUtils: {
+    visibleName(compiler: Compiler, nodeOrSymbol: UseSpecifierNode | UseSymbol): string[] | undefined;
+};
+export declare const useModule: GlobalModule;

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

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../../compiler';
+import { RelationCardinality } from '../types';
+import { PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { NodeSymbol } from '../types/symbol';
+export declare function shouldInterpretNode(compiler: Compiler, node: SyntaxNode): boolean;
+export declare function getNodeMemberSymbols(compiler: Compiler, node: SyntaxNode): Report<NodeSymbol[]>;
+export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
+    variables: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+    tupleElements: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+}[];
+export declare function nodeRefereeOfLeftExpression(compiler: Compiler, node: SyntaxNode): NodeSymbol | undefined;
+export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;

package/dist/src/core/local_modules/checks/index.d.ts

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

package/dist/src/core/local_modules/checks/validate.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 ChecksValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateFieldSetting;
+    private validateSubElements;
+}

package/dist/src/core/local_modules/custom/index.d.ts

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

package/dist/src/core/local_modules/custom/validate.d.ts

@@ -0,0 +1,14 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
+export default class CustomValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+}

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

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

package/dist/src/core/local_modules/diagramView/validate.d.ts

@@ -0,0 +1,24 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError, CompileWarning } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
+export default class DiagramViewValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+    private validateSubBlock;
+    validateSubBlockFields(sub: ElementDeclarationNode): CompileError[];
+}

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

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

package/dist/src/core/local_modules/enum/validate.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 EnumValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateFieldSettings;
+    private validateSubElements;
+}

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

@@ -0,0 +1,10 @@
+import { default as Compiler } from '../../compiler';
+import { Unhandled } from '../types/module';
+import { SyntaxNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { LocalModule, Settings } from './types';
+export declare const modules: LocalModule[];
+export declare function validateNode(this: Compiler, node: SyntaxNode): Report<void> | Report<Unhandled>;
+export declare function nodeSettings(this: Compiler, node: SyntaxNode): Report<Settings> | Report<Unhandled>;
+export declare function nodeFullname(this: Compiler, node: SyntaxNode): Report<string[] | undefined> | Report<Unhandled>;
+export declare function nodeAlias(this: Compiler, node: SyntaxNode): Report<string | undefined> | Report<Unhandled>;

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

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

package/dist/src/core/local_modules/indexes/validate.d.ts

@@ -0,0 +1,18 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode, SyntaxNode } from '../../types/nodes';
+export default class IndexesValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateFieldSetting;
+    private validateSubElements;
+}
+export declare function isValidIndexesType(value?: SyntaxNode): boolean;

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

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

package/dist/src/core/local_modules/note/validate.d.ts

@@ -0,0 +1,16 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
+export default class NoteValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+}

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

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

package/dist/src/core/local_modules/program/validate.d.ts

@@ -0,0 +1,9 @@
+import { default as Compiler } from '../../../compiler';
+import { ProgramNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+export default class ProgramValidator {
+    private ast;
+    private compiler;
+    constructor(compiler: Compiler, ast: ProgramNode);
+    validate(): Report<ProgramNode>;
+}

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

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

package/dist/src/core/local_modules/project/validate.d.ts

@@ -0,0 +1,15 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class ProjectValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateSubElements;
+}

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

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

package/dist/src/core/local_modules/records/validate.d.ts

@@ -0,0 +1,20 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
+export default class RecordsValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateTopLevelName;
+    private validateInsideTableName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    private validateDataRows;
+    private validateDataRow;
+    private isValidRecordValue;
+    private validateSubElements;
+}

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

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

package/dist/src/core/local_modules/ref/validate.d.ts

@@ -0,0 +1,20 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Settings } from '../../utils/validate';
+export default class RefValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    validateFieldSettings(settings: ListExpressionNode): CompileError[];
+    private validateSubElements;
+}
+export declare function validateFieldSettings(settings: ListExpressionNode): Report<Settings>;

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

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

package/dist/src/core/local_modules/table/validate.d.ts

@@ -0,0 +1,21 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode, ExpressionNode, ListExpressionNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Settings } from '../../utils/validate';
+export default class TableValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateFieldSetting;
+    private validateSubElements;
+}
+export declare function validateTableSettings(settingList?: ListExpressionNode): Report<Settings>;
+export declare function validateFieldSetting(parts: ExpressionNode[]): Report<Settings>;

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

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

package/dist/src/core/local_modules/tableGroup/validate.d.ts

@@ -0,0 +1,19 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Settings } from '../../utils/validate';
+export default class TableGroupValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+}
+export declare function validateSettingList(settingList?: ListExpressionNode): Report<Settings>;

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

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

package/dist/src/core/local_modules/tablePartial/validate.d.ts

@@ -0,0 +1,21 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode, ExpressionNode, ListExpressionNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Settings } from '../../utils/validate';
+export default class TablePartialValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateFieldSetting;
+    private validateSubElements;
+}
+export declare function validateTablePartialSettings(settingList?: ListExpressionNode): Report<Settings>;
+export declare function validateFieldSetting(parts: ExpressionNode[]): Report<Settings>;

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

@@ -0,0 +1,12 @@
+import { default as Compiler } from '../../compiler';
+import { Module, PassThrough } from '../types/module';
+import { SyntaxNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { Settings } from '../utils/validate';
+export type { Settings };
+export interface LocalModule extends Module {
+    validateNode?(compiler: Compiler, node: SyntaxNode): Report<void> | Report<PassThrough>;
+    nodeFullname?(compiler: Compiler, node: SyntaxNode): Report<string[] | undefined> | Report<PassThrough>;
+    nodeAlias?(compiler: Compiler, node: SyntaxNode): Report<string | undefined> | Report<PassThrough>;
+    nodeSettings?(compiler: Compiler, node: SyntaxNode): Report<Settings> | Report<PassThrough>;
+}

package/dist/src/core/local_modules/use/index.d.ts

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

package/dist/src/core/local_modules/use/validate.d.ts

@@ -0,0 +1,12 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { UseDeclarationNode } from '../../types/nodes';
+export default class UseDeclarationValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: UseDeclarationNode);
+    validate(): CompileError[];
+    private validateContext;
+    private validateBody;
+    private validateSpecifier;
+}

package/dist/src/core/parser/parser.d.ts

@@ -9,6 +9,7 @@ export default class Parser {
     private contextStack;
     private nodeFactory;
     private source;
+    private filepath;
     constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath);
     private isAtEnd;
     private advance;
@@ -24,7 +25,13 @@ export default class Parser {
         ast: ProgramNode;
         tokens: SyntaxToken[];
     }>;
+    private assignParents;
     private program;
+    private useDeclaration;
+    private useSpecifierList;
+    private synchronizeUseSpecifierList;
+    private useSpecifier;
+    private synchronizeUseSpecifier;
     private synchronizeProgram;
     private elementDeclaration;
     private synchronizeElementDeclarationName;
@@ -39,6 +46,7 @@ export default class Parser {
     private leftExpression_bp;
     private extractOperand;
     private functionExpression;
+    private wildcardExpression;
     private blockExpression;
     private canBeField;
     private synchronizeBlock;

package/dist/src/core/parser/utils.d.ts

@@ -1,53 +1,6 @@
 import { default as NodeFactory } from './factory';
-import { CommaExpressionNode, ElementDeclarationNode, ExpressionNode, IdentiferStreamNode, InfixExpressionNode, LiteralNode, NormalExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
-import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
+import { CommaExpressionNode, ElementDeclarationNode, ExpressionNode, NormalExpressionNode, SyntaxNode } from '../types/nodes';
+import { SyntaxToken } from '../types/tokens';
 export declare function convertFuncAppToElem(_callee: ExpressionNode | CommaExpressionNode | undefined, _args: (NormalExpressionNode | CommaExpressionNode)[], factory: NodeFactory): ElementDeclarationNode | undefined;
-export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken & {
-    kind: SyntaxTokenKind.IDENTIFIER;
-    value: 'as';
-};
 export declare function markInvalid(nodeOrToken?: SyntaxNode | SyntaxToken): void;
-export declare function isInvalidToken(token?: SyntaxToken): boolean;
 export declare function getMemberChain(node: SyntaxNode): Readonly<(SyntaxNode | SyntaxToken)[]>;
-export declare function extractVariableNode(value?: unknown): SyntaxToken | undefined;
-export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
-    expression: VariableNode & {
-        variable: SyntaxToken & {
-            kind: SyntaxTokenKind.QUOTED_STRING;
-        };
-    };
-} | {
-    expression: LiteralNode & {
-        literal: SyntaxToken & {
-            kind: SyntaxTokenKind.STRING_LITERAL;
-        };
-    };
-});
-export declare function isExpressionAVariableNode(value?: unknown): value is PrimaryExpressionNode & {
-    expression: VariableNode & {
-        variable: SyntaxToken;
-    };
-};
-export declare function isWildcardExpression(node: SyntaxNode | undefined): boolean;
-export declare function isExpressionAnIdentifierNode(value?: unknown): value is PrimaryExpressionNode & {
-    expression: VariableNode & {
-        variable: {
-            kind: SyntaxTokenKind.IDENTIFIER;
-        };
-    };
-};
-type AccessExpression = InfixExpressionNode & {
-    leftExpression: SyntaxNode;
-    rightExpression: SyntaxNode;
-    op: SyntaxToken & {
-        value: '.';
-    };
-};
-type DotDelimitedIdentifier = PrimaryExpressionNode | (AccessExpression & {
-    rightExpression: AccessExpression | PrimaryExpressionNode;
-});
-export declare function isAccessExpression(node?: SyntaxNode): node is AccessExpression;
-export declare function isDotDelimitedIdentifier(node?: SyntaxNode): node is DotDelimitedIdentifier;
-export declare function extractStringFromIdentifierStream(stream?: IdentiferStreamNode): string | undefined;
-export declare function getElementNameString(element?: ElementDeclarationNode): string | undefined;
-export {};

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

@@ -1,6 +1,6 @@
+import { Filepath } from './filepath';
 import { SyntaxNode } from './nodes';
 import { SyntaxToken } from './tokens';
-import { Filepath } from './filepath';
 export declare enum CompileErrorCode {
     UNKNOWN_SYMBOL = 1000,
     UNEXPECTED_SYMBOL = 1001,
@@ -96,11 +96,15 @@ export declare enum CompileErrorCode {
     INVALID_RECORDS_FIELD = 3079,
     DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3080,
     DUPLICATE_RECORDS_FOR_TABLE = 3081,
-    INVALID_DIAGRAMVIEW_CONTEXT = 3082,
-    DUPLICATE_DIAGRAMVIEW_NAME = 3083,
-    INVALID_DIAGRAMVIEW_FIELD = 3084,
-    DUPLICATE_DIAGRAMVIEW_FIELD = 3085,
+    INVALID_USE_CONTEXT = 3082,
+    INVALID_USE_SPECIFIER_KIND = 3083,
+    INVALID_USE_SPECIFIER_NAME = 3084,
+    INVALID_DIAGRAMVIEW_CONTEXT = 3085,
+    DUPLICATE_DIAGRAMVIEW_NAME = 3086,
+    INVALID_DIAGRAMVIEW_FIELD = 3087,
+    DUPLICATE_DIAGRAMVIEW_FIELD = 3088,
     BINDING_ERROR = 4000,
+    NONEXISTENT_MODULE = 4001,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,
     SAME_ENDPOINT = 5002,

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

@@ -4,8 +4,11 @@ export type FilepathId = string & {
     [__filepathIdBrand]: true;
 };
 export declare class Filepath implements Internable<FilepathId> {
+    private readonly protocol?;
     private readonly path;
-    constructor(absolutePath: string);
+    constructor(absolutePath: string, options?: {
+        protocol?: string;
+    });
     intern(): FilepathId;
     static from(absolutePath: string): Filepath;
     static resolve(fromDir: string, relativePath: string): Filepath;
@@ -19,7 +22,10 @@ export declare class Filepath implements Internable<FilepathId> {
     relativeTo(baseDir: string): string;
     toString(): string;
     equals(other: Filepath): boolean;
-    toUri(): string;
+    isParentOf(other: Filepath): boolean;
+    toUri(options?: {
+        protocol?: string;
+    }): string;
     static isRelative(p: string): boolean;
 }
 export declare function resolveImportFilepath(currentFilepath: Filepath, relativePath: string): Filepath | undefined;

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

@@ -1,3 +1,4 @@
+export * from './module';
 export * from './errors';
 export * from './report';
 export * from './position';
@@ -5,3 +6,4 @@ export * from './filepath';
 export * from './internable';
 export * from './symbol';
 export * from './schemaJson';
+export * from './keywords';

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

@@ -6,15 +6,3 @@ export declare function intern<T extends Primitive, Id extends Primitive>(value:
 export declare function intern<Id extends Primitive>(value: Internable<Id>): Id;
 export declare function intern<T extends Primitive>(value: T): T;
 export declare function intern<T extends Primitive>(value: T[]): string;
-export declare class InternedMap<K extends Internable<P>, V, P extends Primitive = ReturnType<K['intern']>> {
-    private readonly map;
-    constructor();
-    get(key: K): V | undefined;
-    set(key: K, value: V): this;
-    has(key: K): boolean;
-    delete(key: K): boolean;
-    get size(): number;
-    entries(): IterableIterator<[P, V]>;
-    [Symbol.iterator](): IterableIterator<[P, V]>;
-    merge(other: InternedMap<K, V, P>): this;
-}

package/dist/src/core/{analyzer/types.d.ts → types/keywords.d.ts}

@@ -7,9 +7,13 @@ export declare enum ElementKind {
     Indexes = "indexes",
     TableGroup = "tablegroup",
     TablePartial = "tablepartial",
-    Check = "checks",
+    Checks = "checks",
     Records = "records",
-    DiagramView = "diagramview"
+    DiagramView = "diagramview",
+    DiagramViewTables = "tables",
+    DiagramViewNotes = "notes",
+    DiagramViewTableGroups = "tablegroups",
+    DiagramViewSchemas = "schemas"
 }
 export declare enum SettingName {
     Color = "color",