@dineug/erd-editor 3.10.0 → 4.0.0

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

@@ -0,0 +1,37 @@
+import { AnyAction } from '@dineug/r-html';
+import { RootState } from '../../engine/state';
+import { Column } from '../../internal-types';
+type AlignEnd = {
+    tableId: string;
+    columnIds: string[];
+};
+export type AlignTypesInput = {
+    /** The relationship whose columns change; a new one has none. */
+    relationshipId?: string;
+    start: AlignEnd;
+    end: AlignEnd;
+    /** The child columns the same batch adds, which already take the parent's type. */
+    newColumnIds: string[];
+};
+/**
+ * The data type changes that bring each existing child column of the mapping
+ * to its parent's, through the data type sync over the relationships as they
+ * will stand, while the sync is on; a column already at its value takes none.
+ */
+export declare function toAlignTypeActions(state: RootState, { relationshipId, start, end, newColumnIds }: AlignTypesInput): AnyAction[];
+/**
+ * What the dialog says under a row whose child column type differs from the
+ * one its parent's gives a foreign key: the type confirming writes there while
+ * the sync is on and the parent has one, else both types.
+ */
+export type TypeNote = {
+    kind: 'becomes';
+    dataType: string;
+} | {
+    kind: 'differ';
+    parentType: string;
+    childType: string;
+};
+export declare function getTypeNote({ settings: { relationshipDataTypeSync, database }, }: Pick<RootState, 'settings'>, parent: Column, child: Column): TypeNote | null;
+export {};
+//# sourceMappingURL=alignTypes.d.ts.map

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

@@ -0,0 +1,102 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { CandidateKey } from './candidateKeys';
+import { ColumnPick, MapColumnsDraft, MappingRow } from './mapping';
+import { MappingIssues } from './validate';
+/** The child column picked for each parent column, null where the reader emptied it. */
+export type MapColumnsPicks = Readonly<Record<string, ColumnPick | null>>;
+/** A Map Columns dialog opened while drawing a relationship between two tables. */
+export type CreateMapColumnsSession = {
+    mode: 'create';
+    startTableId: string;
+    endTableId: string;
+    relationshipType: number;
+    keyId: string | null;
+    picks: MapColumnsPicks;
+};
+/** The mapping and the keys a relationship had when the dialog opened on it. */
+export type MapColumnsBase = {
+    startColumnIds: string[];
+    endColumnIds: string[];
+    keyId: string;
+    keys: Readonly<Record<string, string[]>>;
+};
+/**
+ * A Map Columns dialog opened on a relationship. Until the reader changes a row
+ * or the key it follows the relationship as it stands; after, it keeps the key
+ * and the rows they changed, the others still following it.
+ */
+export type EditMapColumnsSession = {
+    mode: 'edit';
+    relationshipId: string;
+    base: MapColumnsBase;
+    touched: boolean;
+    keyId: string;
+    picks: MapColumnsPicks;
+};
+export type MapColumnsSession = CreateMapColumnsSession | EditMapColumnsSession;
+/**
+ * A row as the dialog shows it: whether its parent or picked child column has
+ * left its table, and the name a new foreign key column takes for it beside
+ * the other rows picking one.
+ */
+export type MappingRowView = MappingRow & {
+    removedParent: boolean;
+    removedChild: boolean;
+    newColumnName: string;
+};
+/** The line under a stored mapping no key covers, or one only a key can mend. */
+export type MapColumnsNotice = 'notAKey' | 'noKey' | 'fixMapping' | 'addKeyToFix';
+/** Why the dialog closes on its own: a table it maps between, or the relationship, is gone. */
+export type MapColumnsClosed = {
+    reason: 'tableRemoved';
+    tableId: string;
+} | {
+    reason: 'relationshipRemoved';
+};
+export type MapColumnsView = {
+    closed: null;
+    parentTable: Table;
+    childTable: Table;
+    relationshipType: number;
+    keys: CandidateKey[];
+    keyId: string | null;
+    showReferences: boolean;
+    rows: MappingRowView[];
+    notice: MapColumnsNotice | null;
+    changedRemotely: boolean;
+    draft: MapColumnsDraft;
+    issues: MappingIssues;
+    canConfirm: boolean;
+};
+export type MapColumnsClosedView = {
+    closed: MapColumnsClosed;
+};
+type MapState = Pick<RootState, 'doc' | 'collections' | 'settings'>;
+/**
+ * What the dialog shows for its session over the state as it stands, built
+ * again on every render, or why it closes: a table it maps between, or the
+ * relationship it edits, has left the document.
+ */
+export declare function buildMapColumns(state: MapState, session: MapColumnsSession): MapColumnsView | MapColumnsClosedView;
+/**
+ * A dialog opened to map the start table's key onto the end table's columns:
+ * on the primary key, or the first unique column without one, each row a
+ * column of the end table only one name match points at, or empty.
+ */
+export declare function openCreateSession(state: MapState, { startTableId, endTableId, relationshipType, }: Pick<CreateMapColumnsSession, 'startTableId' | 'endTableId' | 'relationshipType'>): CreateMapColumnsSession;
+/** A dialog opened on the relationship, remembering its mapping and the parent's keys. */
+export declare function openEditSession(state: MapState, relationshipId: string): EditMapColumnsSession;
+/**
+ * The session once the reader picks another key in References: a row for each
+ * of its columns keeps the child it had where that child is live, and an empty
+ * row takes the one column a name match points at, if any.
+ */
+export declare const changeMapColumnsKey: <S extends MapColumnsSession>(state: MapState, session: S, keyId: string) => S;
+/**
+ * The session once the reader picks a child column for a row, or empties it,
+ * on the key the dialog shows, which an edit keeps from then on.
+ */
+export declare const pickMapColumn: <S extends MapColumnsSession>(state: MapState, session: S, parentColumnId: string, pick: ColumnPick | null) => S;
+export {};
+//# sourceMappingURL=buildRows.d.ts.map

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

@@ -0,0 +1,24 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { ColumnKey } from '../tableKeys';
+/** The References choice that keeps a stored mapping no key of the parent covers. */
+export declare const CURRENT_KEY_ID = "current";
+/** A key a mapping can reference, or the stored columns kept as they are. */
+export type CandidateKey = {
+    id: string;
+    kind: ColumnKey['kind'] | 'current';
+    columnIds: string[];
+};
+type KeyState = Pick<RootState, 'collections' | 'settings'>;
+/**
+ * The keys a foreign key can reference on the table: its primary key, in
+ * column order, then each unique column; a unique column over the very columns
+ * of a key before it is left out, so a primary key also marked unique is one.
+ */
+export declare function getCandidateKeys(state: KeyState, table: Table): CandidateKey[];
+/** The key the table's columns declare under the id, as they declare it now. */
+export declare const findColumnKey: (state: KeyState, table: Table, keyId: string) => ColumnKey | undefined;
+/** The References choice of a stored mapping no key covers. */
+export declare const toCurrentKey: (columnIds: string[]) => CandidateKey;
+export {};
+//# sourceMappingURL=candidateKeys.d.ts.map

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

@@ -0,0 +1,8 @@
+export * from './alignTypes';
+export * from './buildRows';
+export * from './candidateKeys';
+export * from './mapping';
+export * from './prefill';
+export * from './toMapColumnsActions';
+export * from './validate';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,67 @@
+import { RootState } from '../../engine/state';
+import { Relationship, Table } from '../../internal-types';
+/** The child column a row maps its parent column to: one the child holds, or a new one. */
+export type ColumnPick = {
+    kind: 'existing';
+    columnId: string;
+} | {
+    kind: 'new';
+};
+/**
+ * One pair of a mapping, a parent key column and the child column picked for
+ * it, null until one is. A place of a stored mapping its lists cannot pair is
+ * invalid, with no parent column where the start list ends before it.
+ */
+export type MappingRow = {
+    parentColumnId: string | null;
+    pick: ColumnPick | null;
+    invalid?: boolean;
+};
+/**
+ * What the Map Columns dialog confirms: the relationship to create between two
+ * tables, or the one whose columns it changes, with the parent key it reads,
+ * a key id of the parent's columns or the stored mapping kept as it is.
+ */
+export type MapColumnsDraft = {
+    mode: 'create';
+    startTableId: string;
+    endTableId: string;
+    relationshipType: number;
+    keyId: string | null;
+    rows: MappingRow[];
+} | {
+    mode: 'edit';
+    relationshipId: string;
+    keyId: string;
+    rows: MappingRow[];
+};
+/** A relationship's two column lists, end[i] referencing start[i]. */
+export type ColumnMapping = {
+    start: string[];
+    end: string[];
+};
+/** The two column lists the relationship holds, as they stand. */
+export declare const toColumnMapping: ({ start, end, }: Relationship) => ColumnMapping;
+/** The table, while the document holds it; a removed one stays an entity a while. */
+export declare function getLiveTable({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, tableId: string): Table | undefined;
+/** The relationship, while the document holds it. */
+export declare function getLiveRelationship({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, relationshipId: string): Relationship | undefined;
+/** Whether the column is one of the live table's, not one removed from it. */
+export declare const isLiveColumn: (table: Table | undefined, columnId: string) => boolean;
+/** Two lists holding the same ids, however ordered or repeated. */
+export declare function sameSet(a: string[], b: string[]): boolean;
+/** Two lists holding the same ids once each, however ordered. */
+export declare const sameMembers: (a: string[], b: string[]) => boolean;
+/** The ids a list holds more than once. */
+export declare function repeatedIds(ids: string[]): Set<string>;
+/** Lists of one length that repeat no id, which pair by place into one key reference. */
+export declare const isNormalMapping: ({ start, end }: ColumnMapping) => boolean;
+/** Two mappings pairing the same columns, in whatever order they list the pairs. */
+export declare const samePairs: (a: ColumnMapping, b: ColumnMapping) => boolean;
+/** Whether the relationship's own lists are normal and pair what the mapping pairs. */
+export declare function holdsPairs(relationship: Relationship, mapping: ColumnMapping): boolean;
+/** The child column each picked row maps to, in row order. */
+export declare const toPickedColumnIds: (rows: MappingRow[]) => string[];
+/** The child columns the other rows hold, which a row's own list shows in use. */
+export declare const getUsedColumnIds: (rows: MappingRow[], rowIndex: number) => Set<string>;
+//# sourceMappingURL=mapping.d.ts.map

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

@@ -0,0 +1,26 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { CandidateKey } from './candidateKeys';
+import { ColumnPick } from './mapping';
+/**
+ * The names a child column may hold to reference the parent column, compared
+ * without case: the name a new foreign key column would take, that name from
+ * the table name without its schema, and for a unique key the column's own.
+ */
+export declare function toPrefillNames(tableName: string, columnName: string, bracketType: number, unique: boolean): Set<string>;
+export type PrefillInput = {
+    parentTable: Table;
+    childTable: Table;
+    keyKind: CandidateKey['kind'];
+    rows: Array<{
+        parentColumnId: string;
+        pick: ColumnPick | null;
+    }>;
+};
+/**
+ * Picks a child column for each empty row, in row order, where exactly one
+ * column holds a name of toPrefillNames; never the parent column itself, nor
+ * one a row holds or an earlier row was just given. Only the fills come back.
+ */
+export declare function prefillPicks({ collections, settings }: Pick<RootState, 'collections' | 'settings'>, { parentTable, childTable, keyKind, rows }: PrefillInput): Record<string, ColumnPick>;
+//# sourceMappingURL=prefill.d.ts.map

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