@dineug/erd-editor 3.9.2 → 4.0.0

package/dist/utils/schema-sql/Databricks.d.ts

@@ -1,6 +1,16 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+import { SchemaSQLHeader } from './options';
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+/**
+ * A comment per column the diagram marks unique, after the table: UNIQUE is not
+ * one of the constraints Databricks accepts, so it is reported, never dropped.
+ */
+export declare function formatUnique({ collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+/** USE SCHEMA, after CREATE SCHEMA IF NOT EXISTS for createAndUse. */
+export declare function formatHeader(_: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;
+/** Each table written dropped, its foreign keys with it. */
+export declare function formatDropBlock(_: RootState, { tables }: WrittenObjects): string;
 //# sourceMappingURL=Databricks.d.ts.map

package/dist/utils/schema-sql/MSSQL.d.ts

@@ -1,6 +1,23 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
+import { SchemaSQLHeader } from './options';
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { written }?: CreateSchemaOptions): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+/**
+ * USE for use; for createAndUse, CREATE DATABASE first where DB_ID finds none.
+ * Each ends its batch with GO.
+ */
+export declare function formatHeader({ settings: { bracketType } }: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;
+/**
+ * One transaction that drops each foreign key a written table holds, found in
+ * its own database's catalog, then the tables, all rolled back on an error, so
+ * a key held from outside them still refuses; IF EXISTS needs SQL Server 2016.
+ */
+export declare function formatDropBlock({ settings: { bracketType } }: RootState, { tables }: WrittenObjects): string;
 //# sourceMappingURL=MSSQL.d.ts.map

package/dist/utils/schema-sql/MariaDB.d.ts

@@ -1,6 +1,12 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions } from './utils';
+export { formatDropBlock, formatHeader } from './MySQL';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames, statements }: FormatIndexOptions): void;
 //# sourceMappingURL=MariaDB.d.ts.map

package/dist/utils/schema-sql/MySQL.d.ts

@@ -1,6 +1,20 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+import { SchemaSQLHeader } from './options';
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function formatIndex(state: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+/** USE, after CREATE DATABASE IF NOT EXISTS for createAndUse; MariaDB's too. */
+export declare function formatHeader({ settings: { bracketType } }: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;
+/**
+ * Every table written dropped while the foreign key checks are off, so the
+ * order does not matter, and the checks back on before the tables are created;
+ * MariaDB's too.
+ */
+export declare function formatDropBlock({ settings: { bracketType } }: RootState, { tables }: WrittenObjects): string;
 //# sourceMappingURL=MySQL.d.ts.map

package/dist/utils/schema-sql/Oracle.d.ts

@@ -1,6 +1,25 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+import { SchemaSQLHeader } from './options';
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { written }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, written }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table, written }: FormatTableOptions): void;
+export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames, written }: FormatIndexOptions): void;
+/**
+ * The names an Oracle script of the document, or of the tables given, writes
+ * past the 30 bytes Oracle 12.1 and older allow.
+ */
+export declare function oracleLongNames(state: RootState, tableIds?: readonly string[]): string[];
+/** ALTER SESSION SET CURRENT_SCHEMA for use; Oracle creates no schema apart from a user. */
+export declare function formatHeader({ settings: { bracketType } }: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;
+/**
+ * Each table written dropped with its constraints, then each sequence, every one
+ * in a block that passes over ORA-00942 or ORA-02289, since Oracle has no DROP
+ * IF EXISTS before 23ai.
+ */
+export declare function formatDropBlock({ settings: { bracketType } }: RootState, { tables, sequences }: WrittenObjects): string;
 //# sourceMappingURL=Oracle.d.ts.map

package/dist/utils/schema-sql/PostgreSQL.d.ts

@@ -1,6 +1,18 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+import { SchemaSQLHeader } from './options';
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames, statements }: FormatIndexOptions): void;
+/**
+ * CREATE SCHEMA IF NOT EXISTS and a search_path that puts it first, for
+ * createAndUse; PostgreSQL has no USE, so use writes nothing.
+ */
+export declare function formatHeader({ settings: { bracketType } }: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;
+/**
+ * One DROP TABLE IF EXISTS naming every table written, which refuses to drop a
+ * table another one outside it references. Under the createAndUse header a
+ * table with no schema of its own is named in that schema, never public's.
+ */
+export declare function formatDropBlock({ settings: { bracketType } }: RootState, { tables }: WrittenObjects, header: SchemaSQLHeader, name: string): string;
 //# sourceMappingURL=PostgreSQL.d.ts.map

package/dist/utils/schema-sql/SQLite.d.ts

@@ -1,6 +1,18 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+/**
+ * An integer type name, with or without a width, which an AUTOINCREMENT key
+ * is written as INTEGER for; the rest keep their type and lose the keyword.
+ */
+export declare function isIntegerFamily(dataType: string): boolean;
+export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames, statements }: FormatIndexOptions): void;
+/** SQLite has no database or schema to create or select in a script. */
+export declare function formatHeader(): string;
+/**
+ * Foreign key enforcement off, which stays off for the connection, and then
+ * each table written dropped, so the order does not matter.
+ */
+export declare function formatDropBlock({ settings: { bracketType } }: RootState, { tables }: WrittenObjects): string;
 //# sourceMappingURL=SQLite.d.ts.map

package/dist/utils/schema-sql/Snowflake.d.ts

@@ -1,6 +1,11 @@
 import { RootState } from '../../engine/state';
-import { FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState): string;
-export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+import { SchemaSQLHeader } from './options';
+import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions } from './utils';
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
 export declare function formatIndex({ collections, settings: { bracketType } }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+/** USE SCHEMA, after CREATE SCHEMA IF NOT EXISTS for createAndUse. */
+export declare function formatHeader({ settings: { bracketType } }: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;
+/** Nothing: recreate writes CREATE OR REPLACE TABLE instead. */
+export declare function formatDropBlock(): string;
 //# sourceMappingURL=Snowflake.d.ts.map

package/dist/utils/schema-sql/index.d.ts

@@ -1,5 +1,25 @@
 import { RootState } from '../../engine/state';
 import { Table } from '../../internal-types';
-export declare function createSchemaSQL(state: RootState, database?: number): string;
+import { SchemaSQLOptions } from './options';
+export { HEADER_NAME_PATTERN, isSchemaSQLHeader, isSchemaSQLStatements, type ResolvedSchemaSQLOptions, resolveSchemaSQLOptions, SchemaSQLHeader, SchemaSQLHeaderList, type SchemaSQLOptions, SchemaSQLStatements, SchemaSQLStatementsList, schemaSQLSupport, } from './options';
+export { oracleLongNames } from './Oracle';
+/** The options a read passes, and whether the before and after scripts are written. */
+export type CreateSchemaSQLOptions = SchemaSQLOptions & {
+    /** Left out, the whole document's DDL writes them and that of some tables none. */
+    scripts?: boolean;
+};
+/**
+ * The DDL of the document in a database, the document's own by default: the
+ * header, the before script, the DROP block, the tables and the after script.
+ * Given table ids, only those tables, their indexes and foreign keys.
+ */
+export declare function createSchemaSQL(state: RootState, database?: number, tableIds?: readonly string[], options?: CreateSchemaSQLOptions): string;
+/** The names of the tables the DDL writes, all or those given, in its order. */
+export declare function schemaSQLTables(state: RootState, tableIds?: readonly string[]): string[];
+/**
+ * One table's DDL for the table properties Schema SQL tab: the table, the
+ * uniqueness its columns carry where the whole export writes it as its own
+ * statement, and the table's indexes.
+ */
 export declare function createSchemaSQLTable(state: RootState, table: Table): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/schema-sql/options.d.ts

@@ -0,0 +1,57 @@
+import { ValuesType } from '../../internal-types';
+export declare const SchemaSQLStatements: {
+    readonly create: "create";
+    readonly ifNotExists: "ifNotExists";
+    readonly recreate: "recreate";
+};
+export type SchemaSQLStatements = ValuesType<typeof SchemaSQLStatements>;
+export declare const SchemaSQLStatementsList: ReadonlyArray<SchemaSQLStatements>;
+export declare const SchemaSQLHeader: {
+    readonly none: "none";
+    readonly use: "use";
+    readonly createAndUse: "createAndUse";
+};
+export type SchemaSQLHeader = ValuesType<typeof SchemaSQLHeader>;
+export declare const SchemaSQLHeaderList: ReadonlyArray<SchemaSQLHeader>;
+/** What getSchemaSQL, an agent's SQL read and the Schema SQL tab pass: an intent, resolved per vendor. */
+export type SchemaSQLOptions = {
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    /** none when left out. */
+    header?: SchemaSQLHeader;
+};
+/** The name a header may write: a plain identifier, so no vendor needs it escaped. */
+export declare const HEADER_NAME_PATTERN: RegExp;
+export type HeaderName = 'valid' | 'empty' | 'invalid';
+export type ResolvedSchemaSQLOptions = {
+    /** What the vendor writes for the statements asked for. */
+    statements: SchemaSQLStatements;
+    /** What the vendor writes for the header asked for, before the name is read. */
+    header: SchemaSQLHeader;
+    /** Whether settings.databaseName can name that header. */
+    headerName: HeaderName;
+};
+export type SchemaSQLSupport = {
+    ifNotExists: boolean;
+    headers: ReadonlyArray<Exclude<SchemaSQLHeader, 'none'>>;
+};
+/**
+ * Whether a database writes CREATE ... IF NOT EXISTS and which headers it has;
+ * every one of them writes drop and re-create.
+ */
+export declare function schemaSQLSupport(database: number): SchemaSQLSupport;
+export declare function isSchemaSQLStatements(value: unknown): value is SchemaSQLStatements;
+export declare function isSchemaSQLHeader(value: unknown): value is SchemaSQLHeader;
+/**
+ * The statements and header a database writes for the ones asked for: one it
+ * lacks falls back to the nearest it has, so the choice outlives a change of
+ * database; an unknown value reads as create and none.
+ */
+export declare function resolveSchemaSQLOptions(database: number, options: SchemaSQLOptions | undefined, databaseName: string): ResolvedSchemaSQLOptions;
+/**
+ * A before or after script as the DDL writes it: line breaks as LF, without the
+ * blank lines ahead of it or the whitespace after it, and on SQL Server ended
+ * with GO; the empty string when nothing is left.
+ */
+export declare function formatScript(text: string, database: number): string;
+//# sourceMappingURL=options.d.ts.map

package/dist/utils/schema-sql/utils.d.ts

@@ -1,7 +1,27 @@
-import { Column, Index, Relationship, Table } from '../../internal-types';
+import { RootState } from '../../engine/state';
+import { Collections, Column, Index, IndexColumn, Relationship, Table } from '../../internal-types';
+import { SchemaSQLStatements } from './options';
+/** What a script's DROP block and the Oracle name check read off the body just written. */
+export interface WrittenObjects {
+    /** The tables in the order their CREATE TABLE is written. */
+    tables: Table[];
+    /** Oracle: each sequence name as written, its owner included. */
+    sequences: string[];
+    /** Oracle: each identifier written, unquoted, in the order written. */
+    identifiers: string[];
+}
+export declare function createWrittenObjects(): WrittenObjects;
+export interface CreateSchemaOptions {
+    /** Already what the database writes (resolveSchemaSQLOptions); create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
+}
 export interface FormatTableOptions {
     buffer: string[];
     table: Table;
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
 }
 export interface FormatColumnOptions {
     buffer: string[];
@@ -13,11 +33,17 @@ export interface FormatRelationOptions {
     buffer: string[];
     relationship: Relationship;
     fkNames: Name[];
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
 }
 export interface FormatIndexOptions {
     buffer: string[];
     index: Index;
     indexNames: Name[];
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
 }
 export interface FormatCommentOptions {
     buffer: string[];
@@ -31,6 +57,36 @@ export interface KeyColumn {
     start: Column[];
     end: Column[];
 }
+/** The columns of a foreign key, end[i] referencing start[i]. */
+export interface ForeignKeyPairs extends KeyColumn {
+    startTable: Table;
+    endTable: Table;
+}
+/**
+ * A relationship read pair by pair: a pair whose start or end column has left
+ * its table is dropped whole, and pairs that reference the whole primary key
+ * follow its declaration order; null when a table or every pair is gone.
+ */
+export declare function toForeignKeyPairs({ doc: { tableIds }, collections }: Pick<RootState, 'doc' | 'collections'>, { start, end }: Relationship): ForeignKeyPairs | null;
+/**
+ * The columns of an index its table still lists, in the index's order, each
+ * with the index column naming it: a column taken out of the table stays in
+ * the collection, but a saved file leaves it out of the index, as this does.
+ */
+export declare function selectIndexColumns(collections: Collections, table: Table, index: Index): Array<{
+    indexColumn: IndexColumn;
+    column: Column;
+}>;
+/**
+ * What one export writes: every table, relationship and index of the document,
+ * or the tables named, their indexes and the foreign keys they hold, whose
+ * parents stay in the document, so a reference out still shows; never an index of a removed table.
+ */
+export declare function toSchemaEntities({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, tableIds?: readonly string[]): {
+    tables: Table[];
+    relationships: Relationship[];
+    indexes: Index[];
+};
 export declare function formatNames<T extends {
     name: string;
 }>(list: T[], backtick?: string, backtick2?: string): string;
@@ -45,12 +101,74 @@ export declare function primaryKeyColumns(columns: Column[]): Column[];
 export declare function unique(columns: Column[]): boolean;
 export declare function uniqueColumns(columns: Column[]): Column[];
 export declare function getBracket(bracketType: number): string;
+/**
+ * The words a CREATE TABLE or CREATE INDEX writes after its object type, and
+ * MariaDB after UNIQUE and FOREIGN KEY, under ifNotExists; nothing otherwise.
+ */
+export declare function ifNotExists(statements?: SchemaSQLStatements): string;
+/**
+ * The parts of an unquoted name, split at each dot outside brackets or double
+ * quotes as SQL Server reads it, so [sales.v2].users is two parts.
+ */
+export declare function splitNameParts(name: string): string[];
+/** Whether a name part is written in one pair of brackets or double quotes. */
+export declare function isDelimitedPart(part: string): boolean;
+/** The name a part in brackets or double quotes holds; any other part as is. */
+export declare function unquoteNamePart(part: string): string;
+/**
+ * A table name split at its last dot outside brackets or double quotes into
+ * schema and table, both as written, where it is unquoted; quoted, the whole
+ * name is one identifier and the schema is empty.
+ */
+export declare function splitTableName(name: string, bracketType: number): [schema: string, table: string];
+/**
+ * The part of a table name that automatic constraint and index names take, one
+ * pair of brackets or quotes off where unquoted, so sales.users and
+ * [sales].[users] give PK_users, which every database reads as one identifier.
+ */
+export declare function tableNamePart(name: string, bracketType: number): string;
+/**
+ * Whether a database's DDL builds automatic names from tableNamePart: the six
+ * generators that read an unquoted dot as a schema do, while Databricks and
+ * Snowflake write the whole table name into them.
+ */
+export declare function splitsTableName(database: number): boolean;
 export declare function orderByNameASC<T extends {
     name: string;
-}>(a: T, b: T): 1 | -1 | 0;
+}>(a: T, b: T): 0 | 1 | -1;
 export declare function autoName<T extends {
     id: string;
     name: string;
 }>(list: T[], id: string, name: string, num?: number): string;
+/**
+ * autoName for an automatic foreign key or index name, also numbering a name
+ * equal to an earlier one but for case, quoted or not, since the databases fold
+ * an unquoted name and MySQL and MariaDB a quoted index name too.
+ */
+export declare function autoNameIgnoreCase(names: Name[], name: string): string;
 export declare function toOrderName(orderType: number): "" | "ASC" | "DESC";
+/** The actions a vendor accepts after ON DELETE and after ON UPDATE. */
+export type ReferentialActionSupport = {
+    onDelete: ReadonlyArray<number>;
+    onUpdate: ReadonlyArray<number>;
+};
+export declare const ALL_REFERENTIAL_ACTIONS: ReferentialActionSupport;
+/** Every action but the ones a vendor refuses, on both events. */
+export declare function withoutReferentialAction(...refused: number[]): ReferentialActionSupport;
+/**
+ * The actions the DDL of a database writes, which the code generators and the
+ * relationship menu follow too; an unknown database takes every one.
+ */
+export declare function referentialActionSupport(database: number): ReferentialActionSupport;
+/**
+ * ON DELETE, then ON UPDATE, each where the relationship sets one the vendor
+ * accepts; an action it would refuse is left out, so the default applies.
+ */
+export declare function formatReferentialActions({ onDelete, onUpdate }: Pick<Relationship, 'onDelete' | 'onUpdate'>, support: ReferentialActionSupport): string[];
+export declare function toStringLiteral(value: string): string;
+/**
+ * A column default as the DDL of a database writes it after DEFAULT: in
+ * parentheses where its grammar reads that expression only inside them.
+ */
+export declare function formatDefault(value: string, database: number, dataType?: string): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/schema-sql-parser/index.d.ts

@@ -1,4 +1,8 @@
 import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
 import { EngineContext } from '../../engine/context';
-export declare function schemaSQLParserToSchemaJson(sql: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3): string;
+/**
+ * The SQL as a document. The document's database, when given, names the vendor
+ * to the parser: a Databricks one reads string literals by Spark's escapes.
+ */
+export declare function schemaSQLParserToSchemaJson(sql: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3, database?: number): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/stageCursor.d.ts

@@ -0,0 +1,20 @@
+/** The closed hand a pan shows for as long as it holds the canvas. */
+export declare const CURSOR_GRABBING = "grabbing";
+/**
+ * Points a stage container at a cursor. A konva node carries none of its own,
+ * so the container wears the one its hover asks for; under a hold the cursor
+ * is only noted, for the release to write back.
+ *
+ * @example
+ * setStageCursor(stage.container(), 'pointer');
+ */
+export declare function setStageCursor(container: HTMLElement, cursor: string): void;
+/**
+ * Keeps a stage container on a cursor for a gesture, whatever the pointer runs
+ * over, and hands back the release that shows what the last hover asked for.
+ *
+ * @example
+ * drag$.subscribe(handleMove).add(holdStageCursor(container, CURSOR_GRABBING));
+ */
+export declare function holdStageCursor(container: HTMLElement, cursor: string): () => void;
+//# sourceMappingURL=stageCursor.d.ts.map

package/dist/utils/table-clipboard/payload.d.ts

@@ -58,6 +58,9 @@ export type ClipboardRelationshipPoint = {
 };
 export type ClipboardRelationship = {
     relationshipType: number;
+    /** Absent from a copy an editor made before the referential actions. */
+    onDelete?: number;
+    onUpdate?: number;
     start: ClipboardRelationshipPoint;
     end: ClipboardRelationshipPoint;
 };

package/dist/utils/table-clipboard/placement.d.ts

@@ -1,6 +1,8 @@
 import { Memo, Point, Settings, Table } from '../../internal-types';
 export type PlacementEntity = {
     sourceId: string;
+    /** A memo stacks over a table of the same z-index, as the scene paints them; a table if left out. */
+    kind?: 'table' | 'memo';
     ui: {
         x: number;
         y: number;

package/dist/utils/tableColor.d.ts

@@ -0,0 +1,29 @@
+/** The colors AML names, each the 500 shade of its Tailwind palette, in AML's order. */
+export declare const AML_COLORS: Readonly<Record<string, string>>;
+/** A DBML headercolor kept as written when it is #rgb or #rrggbb, else ''. */
+export declare function fromDBMLColor(value: string): string;
+/**
+ * One of AML's color names, in any letter case, as its hex; a #rgb, #rrggbb
+ * or #rrggbbaa as written; else ''.
+ */
+export declare function fromAMLColor(value: string): string;
+/**
+ * A table color as DBML's headercolor writes it, which takes #rgb or #rrggbb
+ * alone: a hex keeps its digits less any alpha, and an rgb() or hsl() becomes
+ * its hex. A color that reads as neither is null.
+ */
+export declare function toDBMLColor(color: string): string | null;
+/**
+ * The AML name of a table color, null for one it cannot read: gray under the
+ * gray chroma, else the other name nearest in OKLCH hue around the circle by
+ * its 500 shade, first in AML's order on a tie, so a named hex finds its name.
+ */
+export declare function toAMLColor(color: string): string | null;
+/**
+ * A color as an opaque lower-case #rrggbb, any alpha dropped: a hex of 3, 4, 6
+ * or 8 digits, an rgb(), rgba(), hsl() or hsla(); null for one it cannot read.
+ */
+export declare function toOpaqueHex(color: string): string | null;
+/** An sRGB channel of 0 to 255 as linear light of 0 to 1. */
+export declare function toLinear(channel: number): number;
+//# sourceMappingURL=tableColor.d.ts.map