@dbml/parse 8.4.0-alpha.1 → 8.4.0-custom-metadata.0

package/dist/src/compiler/types.d.ts

@@ -11,5 +11,6 @@ export declare const enum ScopeKind {
     TABLEPARTIAL = 9,
     CHECKS = 10,
     RECORDS = 11,
-    DIAGRAMVIEW = 12
+    DIAGRAMVIEW = 12,
+    METADATA = 13
 }

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { default as Compiler } from '../../../compiler';
+import { Filepath } from '../../types';
+import { MetadataElementMetadata } from '../../types/symbol/metadata';
+import { default as Report } from '../../types/report';
+import { MetadataValues } from '../../types/schemaJson';
+export default class MetadataInterpreter {
+    private declarationNode;
+    private compiler;
+    private filepath;
+    private values;
+    constructor(compiler: Compiler, metadata: MetadataElementMetadata, filepath: Filepath);
+    interpret(): Report<MetadataValues>;
+    private interpretValues;
+}

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

@@ -0,0 +1,29 @@
+import { default as Compiler } from '../../../compiler/index';
+import { Filepath, SettingName } from '../../types';
+import { Column, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
+import { ElementDeclarationNode, SyntaxNode } from '../../types/nodes';
+import { NodeSymbol, SymbolKind, MetadataTargetKind } from '../../types/symbol';
+export type MetadataTarget = Table | TableGroup | Note | Column;
+/**
+  * Specs for builtin metadata (table's note, tablegroup's color, .etc) for different element types. Does 2 things:
+  * - `validate`: Validating if the metadata value is syntactically correct
+  * - `assign`: Write the metadata value to the element builtin props (e.g. write `table.note` instead of `table.metadata`)
+  */
+interface MetadataField<T extends MetadataTarget> {
+    /** Check if the metadata value is syntactically correct */
+    isValidBuiltinFieldValue(node?: SyntaxNode): boolean;
+    message: string;
+    /** Write the metadata value to the element builtin props (e.g. write to `table.note`) */
+    assignBuiltinField(element: Partial<T>, value: string, token: TokenPosition): void;
+}
+export type MetadataFieldRegistry<T extends MetadataTarget, K extends SettingName = SettingName> = Record<K, MetadataField<T>>;
+type NameWithSymbolKind = {
+    name: string;
+    symbolKind: SymbolKind;
+};
+/** @internal Exported for testing only. */
+export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: MetadataTargetKind): NameWithSymbolKind[];
+export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: ElementDeclarationNode): NodeSymbol | undefined;
+/** Merge every custom-metadata block, reachable from the current program, targeting element to it's `metadata` and other builtin (note/headercolor/...) fields */
+export declare function attachCustomMetadata<T extends MetadataTarget>(compiler: Compiler, targetElement: Partial<T>, targetSymbol: NodeSymbol, fieldsRegistry: MetadataFieldRegistry<T, any>, filepath: Filepath): void;
+export {};

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

@@ -1,7 +1,9 @@
 import { Note } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { Filepath, NoteSymbol } from '../../types';
+import { SettingName, Filepath, NoteSymbol } from '../../types';
 import { default as Report } from '../../types/report';
+import { MetadataFieldRegistry } from '../metadata/utils';
+export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, SettingName.Color>;
 export declare class StickyNoteInterpreter {
     private declarationNode;
     private symbol;

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

@@ -1,9 +1,11 @@
 import { default as Compiler } from '../../../compiler';
+import { SettingName } from '../../types/keywords';
 import { ElementDeclarationNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
-import { Table } from '../../types/schemaJson';
+import { Column, Table } from '../../types/schemaJson';
 import { Filepath } from '../../types/filepath';
 import { TableSymbol } from '../../types/symbol/symbols';
+import { MetadataFieldRegistry } from '../metadata/utils';
 export declare class TableInterpreter {
     private declarationNode;
     private compiler;
@@ -13,6 +15,7 @@ export declare class TableInterpreter {
     private pkColumns;
     constructor(compiler: Compiler, declarationNode: ElementDeclarationNode, symbol: TableSymbol, filepath: Filepath);
     interpret(): Report<Table>;
+    private attachTableAndColumnMetadata;
     private interpretName;
     private interpretAlias;
     private interpretSettingList;
@@ -24,3 +27,11 @@ export declare class TableInterpreter {
     private interpretIndexes;
     private interpretChecks;
 }
+/**
+  * Settings that are excluded from custom metadata for inline metadata for Column
+  * Different from what we extract from metadata block for Column because some settings value types are not supported yet, mostly boolean keys without values ([pk, not null])
+  * TODO: Catch these settings when we support more data types for custom metadata
+  */
+export declare const RECOGNIZED_COLUMN_SETTINGS: readonly SettingName[];
+export declare const TABLE_METADATA_FIELDS: MetadataFieldRegistry<Table, SettingName.Note | SettingName.HeaderColor>;
+export declare const COLUMN_METADATA_FIELDS: MetadataFieldRegistry<Column, SettingName.Note>;

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

@@ -1,7 +1,9 @@
 import { TableGroup } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { Filepath, TableGroupSymbol } from '../../types';
+import { SettingName, Filepath, TableGroupSymbol } from '../../types';
 import { default as Report } from '../../types/report';
+import { MetadataFieldRegistry } from '../metadata/utils';
+export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, SettingName.Note | SettingName.Color>;
 export declare class TableGroupInterpreter {
     private compiler;
     private symbol;

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

@@ -1,5 +1,5 @@
 import { default as Compiler } from '../../compiler';
-import { RelationCardinality } from '../types';
+import { Filepath, ProgramSymbol, RelationCardinality } from '../types';
 import { PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { NodeSymbol } from '../types/symbol';
@@ -15,3 +15,5 @@ export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
 }[];
 export declare function nodeRefereeOfLeftExpression(compiler: Compiler, node: SyntaxNode): NodeSymbol | undefined;
 export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;
+export declare function getDefaultSchemaSymbol(compiler: Compiler, globalSymbol: NodeSymbol): NodeSymbol | undefined;
+export declare function getProgramSymbol(compiler: Compiler, filepath: Filepath): ProgramSymbol | undefined;

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

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

package/dist/src/core/local_modules/metadata/utils.d.ts

@@ -0,0 +1,7 @@
+import { CompileError, CompileErrorCode, MetadataTargetKind } from '../../types';
+import { AttributeNode, ElementDeclarationNode } from '../../types/nodes';
+export declare function getMetadataTargetKind(node: ElementDeclarationNode): MetadataTargetKind | undefined;
+export declare function validateCustomInlineMetadata(name: string, attrs: AttributeNode[], errorCodes: {
+    duplicate: CompileErrorCode;
+    invalidValue: CompileErrorCode;
+}): CompileError[];

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

@@ -0,0 +1,14 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class MetadataValidator {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateTargetKind;
+    private validateTargetName;
+    private validateBody;
+    private validateFields;
+    private validateSubElements;
+}

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

@@ -113,7 +113,10 @@ export declare enum CompileErrorCode {
     SAME_ENDPOINT = 5002,
     UNEQUAL_FIELDS_BINARY_REF = 5003,
     CONFLICTING_SETTING = 5004,
-    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
+    TABLE_REAPPEAR_IN_TABLEGROUP = 5005,
+    INVALID_METADATA_TARGET_KIND = 5006,
+    INVALID_METADATA_FIELD = 5007,
+    DUPLICATE_METADATA_FIELD = 5008
 }
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;

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

@@ -13,7 +13,8 @@ export declare enum ElementKind {
     DiagramViewTables = "tables",
     DiagramViewNotes = "notes",
     DiagramViewTableGroups = "tablegroups",
-    DiagramViewSchemas = "schemas"
+    DiagramViewSchemas = "schemas",
+    Metadata = "metadata"
 }
 export declare enum SettingName {
     Color = "color",

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

@@ -110,14 +110,16 @@ export declare class UseSpecifierListNode extends SyntaxNode {
 }
 export declare class ElementDeclarationNode extends SyntaxNode {
     type?: SyntaxToken;
+    targetKind?: SyntaxToken;
     name?: NormalExpressionNode;
     as?: SyntaxToken;
     alias?: NormalExpressionNode;
     attributeList?: ListExpressionNode;
     bodyColon?: SyntaxToken;
     body?: FunctionApplicationNode | BlockExpressionNode;
-    constructor({ type, name, as, alias, attributeList, bodyColon, body, }: {
+    constructor({ type, targetKind, name, as, alias, attributeList, bodyColon, body, }: {
         type?: SyntaxToken;
+        targetKind?: SyntaxToken;
         name?: NormalExpressionNode;
         as?: SyntaxToken;
         alias?: NormalExpressionNode;
@@ -125,8 +127,17 @@ export declare class ElementDeclarationNode extends SyntaxNode {
         bodyColon?: SyntaxToken;
         body?: BlockExpressionNode | FunctionApplicationNode;
     }, id: SyntaxNodeId, filepath: Filepath);
-    isKind(...kinds: ElementKind[]): boolean;
-    getElementKind(): ElementKind | undefined;
+    isKind<T extends ElementKind>(...kinds: T[]): this is ElementDeclarationNode & {
+        type: {
+            value: T;
+        };
+    };
+    getElementKind<T extends ElementKind>(this: ElementDeclarationNode & {
+        type: {
+            value: T;
+        };
+    }): T;
+    getElementKind(this: ElementDeclarationNode): ElementKind | undefined;
 }
 export declare class IdentifierStreamNode extends SyntaxNode {
     identifiers: SyntaxToken[];

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

@@ -1,6 +1,7 @@
 import { NONE_COLOR } from '../../constants';
 import { Filepath } from './filepath';
 import { Position } from './position';
+export type CustomMetadata = Record<string, string>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"
@@ -85,12 +86,14 @@ export interface Table {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface Note {
     name: string;
     content: string;
     token: TokenPosition;
     color?: Color;
+    metadata?: CustomMetadata;
 }
 export interface ColumnType {
     schemaName: string | null;
@@ -123,6 +126,7 @@ export interface Column {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface Index {
     columns: {
@@ -195,6 +199,7 @@ export interface TableGroup {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface TableGroupField {
     name: string;
@@ -238,6 +243,10 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
+export type MetadataValues = Record<string, {
+    value: string;
+    token: TokenPosition;
+}>;
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -252,4 +261,4 @@ export type Project = Record<string, never> | {
     token: TokenPosition;
     [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
 };
-export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | Ref | RefEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue;
+export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | Ref | RefEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues;

package/dist/src/core/types/symbol/metadata.d.ts

@@ -1,6 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
-import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
+import { ColumnSymbol, NodeSymbol, ProgramSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 export declare enum MetadataKind {
     Ref = "ref",
@@ -8,7 +8,8 @@ export declare enum MetadataKind {
     TableChecks = "table checks",
     Indexes = "indexes",
     Records = "records",
-    Project = "project"
+    Project = "project",
+    MetadataElement = "metadata element"
 }
 declare const __nodeMetadataBrand: unique symbol;
 export type NodeMetadataId = number & {
@@ -26,6 +27,11 @@ export declare abstract class NodeMetadata implements Internable<InternedNodeMet
     constructor(declaration: SyntaxNode);
     intern(): InternedNodeMetadata;
     abstract owners(compiler: Compiler): NodeSymbol[];
+    /** Get programs (source files) that can both
+      * - reach this metadata's declaration file and
+      * - see all the given target symbols in their nested schema.
+      */
+    resolveOwnerPrograms(compiler: Compiler, targets: NodeSymbol[]): ProgramSymbol[];
 }
 export declare class RefMetadata extends NodeMetadata {
     declaration: ElementDeclarationNode | AttributeNode;
@@ -73,6 +79,13 @@ export declare class RecordsMetadata extends NodeMetadata {
     table(compiler: Compiler): TableSymbol | undefined;
     owners(compiler: Compiler): NodeSymbol[];
 }
+export declare class MetadataElementMetadata extends NodeMetadata {
+    declaration: ElementDeclarationNode;
+    readonly kind = MetadataKind.MetadataElement;
+    constructor(declaration: ElementDeclarationNode);
+    target(compiler: Compiler): NodeSymbol | undefined;
+    owners(compiler: Compiler): NodeSymbol[];
+}
 export declare class ProjectMetadata extends NodeMetadata {
     readonly kind = MetadataKind.Project;
     constructor(declaration: SyntaxNode);

package/dist/src/core/types/symbol/symbols.d.ts

@@ -24,6 +24,7 @@ export declare enum SymbolKind {
     DiagramViewTableGroup = "DiagramView tablegroup",
     DiagramViewNote = "DiagramView note",
     DiagramViewSchema = "DiagramView schema",
+    Metadata = "Metadata",
     Program = "Program"
 }
 export declare const ImportKind: {
@@ -35,6 +36,13 @@ export declare const ImportKind: {
     Schema: SymbolKind;
 };
 export type ImportKind = (typeof ImportKind)[keyof typeof ImportKind];
+/** Allowed target element types for a Metadata element header */
+export declare enum MetadataTargetKind {
+    Table = "Table",
+    Column = "Column",
+    TableGroup = "TableGroup",
+    Note = "Note"
+}
 declare const __nodeSymbolBrand: unique symbol;
 export type NodeSymbolId = number & {
     readonly [__nodeSymbolBrand]: true;

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

@@ -1,16 +1,26 @@
 import { default as Compiler } from '../../compiler';
-import { Color, ColumnType, TokenPosition } from '../types/schemaJson';
+import { Color, ColumnType, CustomMetadata, TokenPosition } from '../types/schemaJson';
 import { SyntaxNode } from '../types/nodes';
 import { default as Report } from '../types/report';
+import { Settings } from './validate';
+import { SettingName } from '../types';
 export declare function getTokenPosition(node: SyntaxNode): TokenPosition;
 export declare function normalizeNote(content: string): string;
 export declare function extractElementName(nameNode: SyntaxNode): {
     schemaName: string[];
     name: string;
 };
-export declare function extractColor(node: unknown): Color | undefined;
+export declare function extractColor(node?: SyntaxNode): Color | undefined;
 export declare function processDefaultValue(valueNode?: SyntaxNode): {
     type: 'number' | 'string' | 'boolean' | 'expression';
     value: string | number;
 } | undefined;
 export declare function processColumnType(compiler: Compiler, typeNode: SyntaxNode): Report<ColumnType>;
+/**
+  * Extract inline custom metadata from an aggregated setting list,
+  * excluding keys that are natively attached to the element (headercolor and note in `table`, color in `tablegroup`, .etc).
+  *
+  * NOTE: This is used during interpret phase, so no need to validate values, just extract them
+  */
+export declare function extractCustomInlineMetadata(settingMap: Settings, builtinSettings: readonly SettingName[]): CustomMetadata;
+export declare function extractMetadataValue(node?: SyntaxNode): string | Color | undefined;

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

@@ -6,6 +6,9 @@ export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken &
 export declare function isUseKeyword(token?: SyntaxToken): token is SyntaxToken & {
     kind: SyntaxTokenKind.IDENTIFIER;
 };
+export declare function isMetadataKeyword(token?: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+};
 export declare function isFromKeyword(token?: SyntaxToken): token is SyntaxToken & {
     kind: SyntaxTokenKind.IDENTIFIER;
 };

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

@@ -24,7 +24,14 @@ export declare function isValidPartialInjection(node?: SyntaxNode): node is Pref
     };
 };
 export declare function isRelationshipOp(op?: string): boolean;
-export declare function isValidColor(value?: SyntaxNode): boolean;
+export declare function isValidHexColor(value?: SyntaxNode): value is PrimaryExpressionNode & {
+    expression: LiteralNode & {
+        literal: {
+            kind: SyntaxTokenKind.COLOR_LITERAL;
+        };
+    };
+};
+export declare function isValidColorOrNone(value?: SyntaxNode): boolean;
 export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
 export type SignedNumberExpression = (PrimaryExpressionNode & {
     expression: LiteralNode & {
@@ -45,6 +52,7 @@ export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleEx
 };
 export declare function isValidColumnType(type: SyntaxNode): boolean;
 export type Settings = Record<SettingName | string, AttributeNode[]>;
+export declare function isValidMetadataValue(value?: SyntaxNode): boolean;
 export declare function aggregateSettingList(settingList?: ListExpressionNode): Report<Settings>;
 export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
     expression: VariableNode & {
@@ -84,7 +92,11 @@ type DotDelimitedIdentifier = PrimaryExpressionNode | (AccessExpression & {
 });
 export declare function isAccessExpression(node?: SyntaxNode): node is AccessExpression;
 export declare function isDotDelimitedIdentifier(node?: SyntaxNode): node is DotDelimitedIdentifier;
-export declare function isElementNode(node: SyntaxNode | undefined, kind: ElementKind): node is ElementDeclarationNode;
+export declare function isElementNode<T extends ElementKind>(node: SyntaxNode | undefined, kind: T): node is ElementDeclarationNode & {
+    type: {
+        value: T;
+    };
+};
 export declare function isUseDeclaration(node: SyntaxNode): node is UseDeclarationNode;
 export declare function isUseSpecifier(node: SyntaxNode, kind?: ImportKind): node is UseSpecifierNode;
 export declare function isWildcardSpecifier(node: SyntaxNode): node is WildcardNode;

package/dist/src/index.d.ts

@@ -10,7 +10,7 @@ export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from '.
 export { CompileError, CompileErrorCode, } from './core/types/errors';
 export type { Position, } from './core/types';
 export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
-export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type RelationCardinality, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, } from './core/types/schemaJson';
+export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type RelationCardinality, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, type CustomMetadata, } from './core/types/schemaJson';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
 export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
 export * from './compiler/projectLayout/layout';

package/dist/src/services/suggestions/provider.d.ts

@@ -1,5 +1,23 @@
 import { default as Compiler } from '../../compiler';
+import { SettingName } from '../../core/types/keywords';
 import { CompletionItemProvider, CompletionList, Position, TextModel } from '../types';
+export declare const COLUMN_TYPE_SUGGESTION_LABELS: readonly ["integer", "int", "tinyint", "smallint", "mediumint", "bigint", "bit", "bool", "binary", "varbinary", "logical", "char", "nchar", "varchar", "varchar2", "nvarchar", "nvarchar2", "binary_float", "binary_double", "float", "double", "decimal", "dec", "real", "money", "smallmoney", "enum", "tinyblob", "tinytext", "blob", "text", "mediumblob", "mediumtext", "longblob", "longtext", "ntext", "set", "inet6", "uuid", "image", "date", "time", "datetime", "datetime2", "timestamp", "year", "smalldatetime", "datetimeoffset", "XML", "sql_variant", "uniqueidentifier", "CURSOR", "BFILE", "CLOB", "NCLOB", "RAW"];
+export declare const TABLE_SETTING_SUGGESTION_LABELS: readonly [SettingName.HeaderColor, SettingName.Note];
+export declare const TABLE_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const COLUMN_SUGGESTION_LABELS: (SettingName.Note | SettingName.PK | SettingName.PrimaryKey | SettingName.Unique | SettingName.Ref | SettingName.NotNull | SettingName.Null | SettingName.Increment | SettingName.Default | SettingName.Check)[];
+export declare const COLUMN_SUGGESTION_TEXT_INSERTS: string[];
+export declare const INDEX_SETTING_SUGGESTION_LABELS: (SettingName.Note | SettingName.PK | SettingName.Unique | SettingName.Name | SettingName.Type)[];
+export declare const INDEX_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const REF_SETTING_SUGGESTION_LABELS: (SettingName.Color | SettingName.Update | SettingName.Delete | SettingName.Inactive)[];
+export declare const REF_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const ENUM_SETTING_SUGGESTION_LABELS: readonly [SettingName.Note];
+export declare const ENUM_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const CHECK_SETTING_SUGGESTION_LABELS: readonly [SettingName.Name];
+export declare const CHECK_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const REF_ACTION_VALUE_SUGGESTIONS: readonly ["cascade", "set default", "set null", "restrict"];
+export declare const INDEX_TYPE_VALUE_SUGGESTIONS: readonly ["btree", "hash"];
+export declare const TABLE_BODY_SUGGESTION_LABELS: ("indexes" | "checks" | "Note" | "Records")[];
+export declare const PROJECT_FIELD_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "Ref")[];
 export interface DBMLCompletionItemProviderOptions {
     triggerCharacters?: string[];
 }
@@ -9,3 +27,4 @@ export default class DBMLCompletionItemProvider implements CompletionItemProvide
     constructor(compiler: Compiler, options?: DBMLCompletionItemProviderOptions);
     provideCompletionItems(model: TextModel, position: Position): CompletionList;
 }
+export declare const TOP_LEVEL_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "DiagramView" | "Metadata" | "Ref" | "Project" | "Records")[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "8.4.0-alpha.1",
+  "version": "8.4.0-custom-metadata.0",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "a3615d8437f4a54a7d5ff5df96977c541394c203"
+  "gitHead": "9efcfd5f8e6981432397d7d242ddfe05b01aec09"
 }