@dineug/erd-editor 3.10.0 → 4.1.0

package/dist/utils/map-columns/toMapColumnsActions.d.ts

@@ -0,0 +1,10 @@
+import { AnyAction } from '@dineug/r-html';
+import { RootState } from '../../engine/state';
+import { MapColumnsDraft } from './mapping';
+/**
+ * The one batch a confirmed mapping writes, for a draft validateMapping passes:
+ * the new foreign key columns its New rows add, the data type changes the sync
+ * makes, then the relationship it adds or the columns it changes.
+ */
+export declare function toMapColumnsActions(state: RootState, draft: MapColumnsDraft, createId: () => string): AnyAction[];
+//# sourceMappingURL=toMapColumnsActions.d.ts.map

package/dist/utils/map-columns/validate.d.ts

@@ -0,0 +1,45 @@
+import { RootState } from '../../engine/state';
+import { Relationship } from '../../internal-types';
+import { MapColumnsDraft } from './mapping';
+/**
+ * What keeps one row from being written: a place its stored lists cannot pair,
+ * a parent or picked child column gone from its table, no pick yet, or a child
+ * an earlier row already holds.
+ */
+export type MappingRowIssue = 'invalid' | 'removedParent' | 'unpicked' | 'removedChild' | 'inUse';
+/**
+ * What keeps the mapping as a whole from being written: rows that cover no key
+ * of the parent as it stands, every row on its own column, another relationship
+ * linking the same columns, or a mapping the relationship already holds.
+ */
+export type MappingSetIssue = 'noKey' | 'selfOnly' | 'duplicate' | 'unchanged';
+export type MappingIssues = {
+    rows: Array<MappingRowIssue | null>;
+    set: MappingSetIssue[];
+};
+type MappingState = Pick<RootState, 'doc' | 'collections' | 'settings'>;
+type DraftEnds = {
+    startTableId: string;
+    endTableId: string;
+    relationship?: Relationship;
+};
+/** The tables a draft maps between, read from the relationship it edits. */
+export declare function getDraftEnds({ collections }: Pick<RootState, 'collections'>, draft: MapColumnsDraft): DraftEnds | null;
+/**
+ * The issues of each row and of the mapping as a whole, read against the state
+ * as it stands, which the dialog shows and the write checks again on landing.
+ * A row past the first issue it has reports that one.
+ */
+export declare function validateMapping(state: MappingState, draft: MapColumnsDraft): MappingIssues;
+/** Whether any issue but the set issues given stands in the way. */
+export declare const hasMappingIssues: ({ rows, set }: MappingIssues, ignore?: MappingSetIssue[]) => boolean;
+/** Whether the tables a draft maps between, and the relationship it edits, are all still there. */
+export declare function hasMappingTargets(state: Pick<RootState, 'doc' | 'collections'>, draft: MapColumnsDraft): boolean;
+/**
+ * Whether the state already holds what the draft would write: every row on a
+ * live column it already pairs, in the relationship it edits, or in one from
+ * the same parent to the same child a peer or an agent made first.
+ */
+export declare function isSameResult(state: Pick<RootState, 'doc' | 'collections'>, draft: MapColumnsDraft): boolean;
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/dist/utils/memo.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../engine/state';
+/** Whether the document shows its memos, which Show.hideMemo hides while set, as View Option's Memos does. */
+export declare const isMemoShown: ({ settings }: RootState) => boolean;
+//# sourceMappingURL=memo.d.ts.map

package/dist/utils/schema-aml-parser/types.d.ts

@@ -58,6 +58,8 @@ export type AMLEntity = {
     name: string;
     alias: string;
     comment: string;
+    /** The color property as a hex: a name as its own, a hex as written; '' otherwise. */
+    color: string;
     attributes: AMLAttribute[];
 };
 /** A struct and a custom type carry neither field, which is what stops a lookup. */

package/dist/utils/schema-dbml-parser/tokenizer.d.ts

@@ -12,6 +12,8 @@ export type Token = {
     kind: number;
     value: string;
     line: number;
+    /** The token's start in the source, which tells touching tokens from spaced ones. */
+    offset: number;
 };
 export declare function tokenize(source: string): Token[];
 //# sourceMappingURL=tokenizer.d.ts.map

package/dist/utils/schema-dbml-parser/types.d.ts

@@ -38,6 +38,8 @@ export type DBMLTable = {
     name: string;
     alias: string;
     comment: string;
+    /** headercolor as written when it is #rgb or #rrggbb; '' otherwise. */
+    color: string;
     columns: DBMLColumn[];
     indexes: DBMLIndex[];
 };
@@ -49,9 +51,18 @@ export type DBMLRef = {
     onDelete: string;
     onUpdate: string;
 };
+export type DBMLTableName = Pick<DBMLEndpoint, 'schemaName' | 'tableName'>;
+export type DBMLTableGroup = {
+    name: string;
+    /** color as written when it is #rgb or #rrggbb; '' otherwise. */
+    color: string;
+    /** One per member line, as written; resolving them is convert.ts's concern. */
+    tables: DBMLTableName[];
+};
 export type DBMLModel = {
     tables: DBMLTable[];
     refs: DBMLRef[];
+    tableGroups: DBMLTableGroup[];
     /** Keyed by the qualified name, so s.status and status stay apart. */
     enums: Record<string, string[]>;
     skipped: string[];

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

@@ -1,11 +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,7 @@
 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.
@@ -8,4 +9,15 @@ export declare function formatTable(state: RootState, { buffer, table }: FormatT
  */
 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,11 +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;
+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 }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+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,11 +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;
+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({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): 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,11 +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;
+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 }: FormatTableOptions): void;
-export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
+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,6 +1,21 @@
 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

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,13 +101,51 @@ 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 = {
@@ -72,4 +166,9 @@ export declare function referentialActionSupport(database: number): ReferentialA
  */
 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/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/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