@dineug/erd-editor 3.10.0 → 4.1.0

package/dist/utils/emitter.d.ts

@@ -1,13 +1,21 @@
 import { Action, AnyAction, DOMTemplateLiterals } from '@dineug/r-html';
 import { TablePlacement } from '../constants/tablePlacement';
+import { LocaleOption } from '../i18n/locales';
 import { ValuesType } from '../internal-types';
 import { ThemeOptions } from '../themes/radix-ui-theme';
 import { GeometrySource } from './draw-relationship/geometrySource';
-import { FindField } from './find-replace/findMatches';
-/** A search the palette hands Find and Replace: the query, and the kinds of text it searches in. */
-export type FindReplaceQuery = {
-    query: string;
-    fields: FindField[];
+/**
+ * What Map Columns opens on: a relationship drawn between two tables and not
+ * made yet, or one the document holds whose columns it changes.
+ */
+export type MapColumnsOpening = {
+    mode: 'create';
+    startTableId: string;
+    endTableId: string;
+    relationshipType: number;
+} | {
+    mode: 'edit';
+    relationshipId: string;
 };
 declare const InternalActionType: {
     readonly openColorPicker: "openColorPicker";
@@ -17,11 +25,14 @@ declare const InternalActionType: {
     readonly dragendColumnAll: "dragendColumnAll";
     readonly copy: "copy";
     readonly paste: "paste";
-    readonly schemaGC: "schemaGC";
     readonly toggleSearch: "toggleSearch";
     readonly openFindReplace: "openFindReplace";
+    readonly openExportImage: "openExportImage";
+    readonly openMapColumns: "openMapColumns";
     readonly openThemeBuilder: "openThemeBuilder";
     readonly setThemeOptions: "setThemeOptions";
+    readonly openLocalePicker: "openLocalePicker";
+    readonly setLocaleOption: "setLocaleOption";
     readonly mouseTrackerStart: "mouseTrackerStart";
     readonly mouseTrackerEnd: "mouseTrackerEnd";
     readonly openDiffViewer: "openDiffViewer";
@@ -40,6 +51,8 @@ type InternalActionMap = {
     [InternalActionType.openToast]: {
         message: DOMTemplateLiterals;
         close?: Promise<void>;
+        /** One toast per key: a toast opened under a key already up takes its place. */
+        key?: string;
     };
     [InternalActionType.openTableProperties]: {
         tableId: string;
@@ -51,11 +64,16 @@ type InternalActionMap = {
     [InternalActionType.paste]: {
         event: ClipboardEvent;
     };
-    [InternalActionType.schemaGC]: void;
     [InternalActionType.toggleSearch]: void;
-    [InternalActionType.openFindReplace]: FindReplaceQuery | void;
+    [InternalActionType.openFindReplace]: void;
+    [InternalActionType.openExportImage]: void;
+    [InternalActionType.openMapColumns]: MapColumnsOpening;
     [InternalActionType.openThemeBuilder]: void;
     [InternalActionType.setThemeOptions]: Partial<ThemeOptions>;
+    [InternalActionType.openLocalePicker]: void;
+    [InternalActionType.setLocaleOption]: {
+        locale: LocaleOption;
+    };
     [InternalActionType.mouseTrackerStart]: void;
     [InternalActionType.mouseTrackerEnd]: void;
     [InternalActionType.openDiffViewer]: {
@@ -105,9 +123,13 @@ export declare const openToastAction: {
     (payload: {
         message: DOMTemplateLiterals;
         close?: Promise<void>;
+        /** One toast per key: a toast opened under a key already up takes its place. */
+        key?: string;
     }): AnyAction<{
         message: DOMTemplateLiterals;
         close?: Promise<void>;
+        /** One toast per key: a toast opened under a key already up takes its place. */
+        key?: string;
     }>;
     toString(): string;
     type: string;
@@ -144,18 +166,23 @@ export declare const pasteAction: {
     toString(): string;
     type: string;
 };
-export declare const schemaGCAction: {
+export declare const toggleSearchAction: {
     (payload: void): AnyAction<void>;
     toString(): string;
     type: string;
 };
-export declare const toggleSearchAction: {
+export declare const openFindReplaceAction: {
     (payload: void): AnyAction<void>;
     toString(): string;
     type: string;
 };
-export declare const openFindReplaceAction: {
-    (payload: void | FindReplaceQuery): AnyAction<void | FindReplaceQuery>;
+export declare const openExportImageAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const openMapColumnsAction: {
+    (payload: MapColumnsOpening): AnyAction<MapColumnsOpening>;
     toString(): string;
     type: string;
 };
@@ -169,6 +196,20 @@ export declare const setThemeOptionsAction: {
     toString(): string;
     type: string;
 };
+export declare const openLocalePickerAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const setLocaleOptionAction: {
+    (payload: {
+        locale: LocaleOption;
+    }): AnyAction<{
+        locale: LocaleOption;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const mouseTrackerStartAction: {
     (payload: void): AnyAction<void>;
     toString(): string;

package/dist/utils/file/exportFile.d.ts

@@ -1,4 +1,4 @@
-import { DocumentPngOptions } from '../../services/export-png';
+import { DocumentPngOptions, DocumentSvgOptions } from '../../services/export-png';
 type ExportOptions = {
     fileName: string;
 };
@@ -6,14 +6,24 @@ type ExportFileCallback = (blob: Blob, options: ExportOptions) => void;
 export declare function setExportFileCallback(callback: ExportFileCallback | null): void;
 export declare function exportJSON(json: string, name?: string): void;
 export declare function exportSchemaSQL(sql: string, name?: string): void;
+/** The Code Generator's text, named as the other exports are, with its language's extension. */
+export declare function exportCode(code: string, extension: string, name?: string): void;
 /**
- * Writes the whole document out as an image, at the zoom the author is reading
- * it at. The scene is rendered again off screen rather than captured, so the
- * file holds the whole document however far it was scrolled away from.
+ * Writes the whole document out as an image, at 100% whatever zoom the author
+ * is reading it at. The scene is rendered again off screen rather than captured,
+ * so the file holds the whole document however far it was scrolled away from.
  *
  * @example
- * exportPNG({ doc: toJson(store.state), theme, toWidth, zoomLevel }, databaseName);
+ * exportPNG({ doc: toJson(store.state), theme, toWidth }, databaseName);
  */
 export declare function exportPNG(options: DocumentPngOptions, name?: string): Promise<void>;
+/**
+ * Writes the whole document out as an svg, at 100% and with no scale, drawn
+ * again off screen the way the png is.
+ *
+ * @example
+ * exportSVG({ doc: toJson(store.state), theme, toWidth }, databaseName);
+ */
+export declare function exportSVG(options: DocumentSvgOptions, name?: string): Promise<void>;
 export {};
 //# sourceMappingURL=exportFile.d.ts.map

package/dist/utils/file/importFile.d.ts

@@ -1,16 +1,20 @@
 import { AppContext } from '../../components/appContext';
+/** Whether an import takes the document's place or joins it below the diagram. */
+export type ImportMode = 'replace' | 'append';
 type ImportOptions = {
     type: 'json' | 'sql' | 'graphql' | 'dbml' | 'aml';
     op: 'set' | 'diff';
     accept: string;
+    /** Named only for an append, so a host that knows no mode replaces as before. */
+    mode?: ImportMode;
 };
 type ImportFileCallback = (options: ImportOptions) => void;
 export declare function setImportFileCallback(callback: ImportFileCallback | null): void;
-export declare function importJSON({ store, emitter }: AppContext): void;
-export declare function importSchemaSQL({ store, emitter }: AppContext): void;
-export declare function importGraphQL({ store, emitter }: AppContext): void;
-export declare function importDBML({ store, emitter }: AppContext): void;
-export declare function importAML({ store, emitter }: AppContext): void;
+export declare function importJSON(app: AppContext, mode?: ImportMode): void;
+export declare function importSchemaSQL(app: AppContext, mode?: ImportMode): void;
+export declare function importGraphQL(app: AppContext, mode?: ImportMode): void;
+export declare function importDBML(app: AppContext, mode?: ImportMode): void;
+export declare function importAML(app: AppContext, mode?: ImportMode): void;
 export declare function importDiffJSON({ emitter }: AppContext): void;
 export {};
 //# sourceMappingURL=importFile.d.ts.map

package/dist/utils/file/importSchema.d.ts

@@ -0,0 +1,45 @@
+import { AppContext } from '../../components/appContext';
+import { SchemaImportType } from '../../engine/modules/editor/generator.actions';
+/**
+ * Replaces the document with an import whose tables stand in the grid, in
+ * one dispatch, as the element's setters always did.
+ *
+ * @example
+ * importSchema(app, 'sql', value);
+ */
+export declare function importSchema({ store }: AppContext, type: SchemaImportType, value: string): void;
+/**
+ * Replaces the document with an import Flow placed first, in one dispatch:
+ * one undo puts the previous document back and no grid shows in between. A
+ * load or another placed replace meanwhile supersedes it and nothing lands.
+ *
+ * @example
+ * await importSchemaPlaced(app, 'sql', value);
+ */
+export declare function importSchemaPlaced(app: AppContext, type: SchemaImportType, value: string): Promise<void>;
+/**
+ * Adds an import to the document below the diagram, its tables in the grid,
+ * in one dispatch, leaving every table and setting already there as it is.
+ *
+ * @example
+ * appendSchema(app, 'sql', value);
+ */
+export declare function appendSchema(app: AppContext, type: SchemaImportType, value: string): void;
+/**
+ * Adds an .erd.json document to this one below the diagram, its tables and
+ * memos standing apart as the file has them, its settings left out.
+ *
+ * @example
+ * appendSchemaJSON(app, value);
+ */
+export declare function appendSchemaJSON(app: AppContext, value: string): void;
+/**
+ * Adds an import Flow placed first below the diagram, in one dispatch, after
+ * every placed import started before it. The diagram is read as it lands, so a
+ * table moved meanwhile is cleared; a load or a later placed replace drops it.
+ *
+ * @example
+ * await appendSchemaPlaced(app, 'sql', value);
+ */
+export declare function appendSchemaPlaced(app: AppContext, type: SchemaImportType, value: string): Promise<void>;
+//# sourceMappingURL=importSchema.d.ts.map

package/dist/utils/find-replace/findMatches.d.ts

@@ -8,20 +8,22 @@ export declare const FindField: {
     readonly columnName: "columnName";
     readonly columnComment: "columnComment";
     readonly memo: "memo";
+    readonly indexName: "indexName";
+    readonly tableGroupName: "tableGroupName";
 };
 export type FindField = ValuesType<typeof FindField>;
 export declare const FindFieldList: ReadonlyArray<FindField>;
 /**
- * The kinds of text Find and Replace first opens on, the names of tables and
- * columns alone (an owner decision): a comment or memo is prose a rename
- * should not reach unasked. A search given no fields still reads every kind.
+ * The kinds of text Find and Replace first opens on, the names alone of
+ * tables, columns, indexes and table groups (an owner decision): a comment or
+ * memo is prose a rename should not reach unasked. No fields reads every kind.
  */
 export declare const DEFAULT_FIND_FIELDS: ReadonlyArray<FindField>;
 export type FindMatch = {
     field: FindField;
-    /** The entity holding the text: a table, a column or a memo. */
+    /** The entity holding the text: a table, a column, an index, a table group or a memo. */
     id: string;
-    /** The table of a table or column field; empty for a memo. */
+    /** The table of a table, column or index field; empty for a memo or a table group. */
     tableId: string;
     /** Where the field stands in the walk, so a match keeps its place when its text changes. */
     slot: number;
@@ -37,19 +39,30 @@ type Field = Omit<FindMatch, 'start' | 'end'>;
  */
 export declare const FindTextActionTypes: ReadonlyArray<ActionType>;
 /**
- * Every text field the fields given cover, in document order: each table's
- * name and comment, then its columns' names and comments, then the memos.
- * The walk reads the live id lists, since a removed entity keeps its record.
+ * The order a walk takes the tables and the table groups in. A search on the
+ * tree reads them by name; a run of Replace presses keeps the order it began
+ * with, so a rename that moves a table in the name order is not met again.
  */
-export declare function walkFields({ doc, collections }: RootState, fields: ReadonlyArray<FindField>): Field[];
+export type FieldOrder = {
+    tableIds: ReadonlyArray<string>;
+    tableGroupIds: ReadonlyArray<string>;
+};
+/** The tables and the table groups by name, as the tree lists them, ties in document order. */
+export declare function treeOrderOf({ doc, collections }: RootState): FieldOrder;
+/**
+ * Every text field the fields given cover: each table's name and comment,
+ * its columns' names and comments and its index names, then the table groups'
+ * names and the memos, in document order or in the order given.
+ */
+export declare function walkFields(state: RootState, fields: ReadonlyArray<FindField>, order?: FieldOrder): Field[];
 /**
  * Every occurrence the matcher finds in the fields given, one entry each, in
- * document order.
+ * document order or in the order given.
  *
  * @example
  * findMatches(store.state, matcher, [FindField.columnName]);
  */
-export declare function findMatches(state: RootState, matcher: Matcher, fields?: ReadonlyArray<FindField>): FindMatch[];
+export declare function findMatches(state: RootState, matcher: Matcher, fields?: ReadonlyArray<FindField>, order?: FieldOrder): FindMatch[];
 /**
  * The matches as they will stand once the field a match was found in holds a
  * new value, before the store has it: that field searched again in the value,
@@ -76,7 +89,7 @@ export type ReplaceRun = Pick<FindMatch, 'field' | 'id' | 'slot' | 'start'> & {
  * table added or removed before it moves that, or null once the field is gone
  * or holds a text the run did not leave, after an undo or a peer's edit say.
  */
-export declare function resumeRun(state: RootState, fields: ReadonlyArray<FindField>, run: ReplaceRun | null): ReplaceRun | null;
+export declare function resumeRun(state: RootState, fields: ReadonlyArray<FindField>, run: ReplaceRun | null, order?: FieldOrder): ReplaceRun | null;
 /**
  * Where a Replace goes on to once it has written value in place of a match:
  * the first match past what it wrote, wrapping to the first, or minus one once

package/dist/utils/find-replace/matcher.d.ts

@@ -2,6 +2,8 @@ export type FindOptions = {
     matchCase: boolean;
     wholeWord: boolean;
     regex: boolean;
+    /** Cases each replacement the way the text it replaces is (preserveCase.ts). */
+    preserveCase?: boolean;
 };
 export type TextRange = {
     start: number;

package/dist/utils/find-replace/present.d.ts

@@ -1,13 +1,16 @@
 import { RootState } from '../../engine/state';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
 import { FindField, FindMatch } from './findMatches';
-export declare const FindFieldLabel: Record<FindField, string>;
+/** The kind of text a match was found in, as its result row names it. */
+export declare const FindFieldLabel: Record<FindField, PlainMessageKey>;
 /**
- * Where a match sits, as a reader finds it on the canvas: the table, or the
- * table and column, and nothing for a memo, which has no name.
+ * Where a match sits, as a reader finds it on the canvas: the table, the
+ * table and column, the table an index belongs to, and nothing for a memo or
+ * a table group, which stand on their own.
  */
-export declare function locationOf({ collections }: RootState, { field, id, tableId }: FindMatch): string;
+export declare function locationOf({ collections }: RootState, { field, id, tableId }: FindMatch, i18n?: Pick<I18n, 't'>): string;
 /** A result row's second line: where the match sits, then the kind of text it was found in. */
-export declare function describeMatch(state: RootState, match: FindMatch): string;
+export declare function describeMatch(state: RootState, match: FindMatch, i18n?: Pick<I18n, 't'>): string;
 export type Snippet = {
     text: string;
     start: number;

package/dist/utils/find-replace/preserveCase.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The replacement cased the way the text it replaces is, as VS Code's Preserve
+ * Case does: all upper, all lower or by the first letter, and piece by piece
+ * across the hyphens or the underscores both split into as many pieces by.
+ *
+ * @example
+ * preserveCase('USER_ID', 'account_key'); // 'ACCOUNT_KEY'
+ */
+export declare function preserveCase(matched: string, replacement: string): string;
+//# sourceMappingURL=preserveCase.d.ts.map

package/dist/utils/generator-code/columnTypes.d.ts

@@ -0,0 +1,99 @@
+import { PrimitiveType } from '../../constants/sql/dataType';
+/**
+ * The value a column's element holds, apart from any driver or library that
+ * reads it: integers by width and sign, floats by width, each date and time.
+ */
+export type ColumnScalar = 'bool' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64' | 'decimal' | 'string' | 'bytes' | 'uuid' | 'json' | 'date' | 'time' | 'timeTz' | 'dateTime' | 'dateTimeUtc' | 'dateTimeOffset' | 'interval';
+/** The fields an interval holds: years and months, days to seconds, or both. */
+export type IntervalFields = 'yearMonth' | 'dayTime' | 'mixed';
+/** A network address type, by what it holds. */
+export type NetworkType = 'ipv4' | 'ipv6' | 'inet' | 'cidr' | 'macaddr' | 'macaddr8';
+export type ColumnType = {
+    scalar: ColumnScalar;
+    /** The element's data type as written, a PostgreSQL array's suffix gone. */
+    element: string;
+    /**
+     * The element's type name, lower case, its arguments gone, and on MySQL and
+     * MariaDB its UNSIGNED, ZEROFILL and SIGNED too.
+     */
+    base: string;
+    /** The element's arguments when all are numbers: numeric(10,2) gives [10, 2]. */
+    args: number[];
+    arrayDepth: number;
+    /** An integer's width, 24 for MySQL's MEDIUMINT; null for any other scalar. */
+    bits: 8 | 16 | 24 | 32 | 64 | null;
+    /** Whether the database's vendor list names the element's type. */
+    isListed: boolean;
+    /** MySQL and MariaDB: UNSIGNED, ZEROFILL or SERIAL in the type. */
+    isUnsigned: boolean;
+    /** A type that numbers its rows itself: PostgreSQL's serials, MySQL's SERIAL. */
+    isSerial: boolean;
+    isFloat: boolean;
+    /** money or smallmoney, which PostgreSQL prints in the session's currency. */
+    isMoney: boolean;
+    /** SQL Server's uniqueidentifier, which holds any 16 bytes, not only an RFC UUID. */
+    isGuid: boolean;
+    /** SQL Server's timestamp and rowversion, eight bytes it writes on every change. */
+    isRowVersion: boolean;
+    /** A Snowflake or Databricks VARIANT, OBJECT, ARRAY, MAP or STRUCT. */
+    isSemiStructured: boolean;
+    /** A PostgreSQL bit string, which drivers read as text such as 1010. */
+    isBitString: boolean;
+    /** PostgreSQL's xid, cid and xid8, integers node-postgres hands over as text. */
+    isTextInteger: boolean;
+    /** Databricks' VOID, which holds nothing but NULL. */
+    isNullOnly: boolean;
+    /** A character type's declared length, BYTE or CHAR units alike; else null. */
+    length: number | null;
+    /** A decimal or NUMBER's declared precision, a star being 38; else null. */
+    precision: number | null;
+    /** A decimal or NUMBER's declared scale; null where none is written. */
+    scale: number | null;
+    interval: IntervalFields | null;
+    network: NetworkType | null;
+    /** An ENUM's members, each read as MySQL reads a string literal. */
+    enumMembers: string[] | null;
+    /** A SET's members, each read as MySQL reads a string literal. */
+    setMembers: string[] | null;
+};
+/** The binary types, which every database hands over as bytes. */
+export declare const BINARY_TYPES: ReadonlySet<string>;
+export declare const UUID_TYPES: ReadonlySet<string>;
+export declare const JSON_TYPES: ReadonlySet<string>;
+/** The timestamps that keep their offset, or an instant read with one. */
+export declare const TIMESTAMP_TZ_TYPES: ReadonlySet<string>;
+/** An instant the database shows in the session's zone, as MySQL's TIMESTAMP. */
+export declare const TIMESTAMP_LTZ_TYPES: ReadonlySet<string>;
+export declare const MONEY_TYPES: ReadonlySet<string>;
+/** PostgreSQL's bit strings, which its drivers read as text such as 1010. */
+export declare const POSTGRES_BIT_TYPES: ReadonlySet<string>;
+export declare const POSTGRES_TIME_TZ_TYPES: ReadonlySet<string>;
+/** PostgreSQL's system identifiers: xid8 is 64 bits, the others 32. */
+export declare const POSTGRES_OBJECT_ID_TYPES: ReadonlySet<string>;
+export declare const POSTGRES_SERIAL_TYPES: ReadonlySet<string>;
+/** The character types a length argument bounds, in characters or bytes. */
+export declare const CHARACTER_TYPES: ReadonlySet<string>;
+/**
+ * What a column's type holds on a database, read by type name before the
+ * vendor lists, which only file each name under one of eleven categories.
+ */
+export declare function getColumnType(dataType: string, database: number): ColumnType;
+/** MySQL and MariaDB: whether UNSIGNED, ZEROFILL or SERIAL makes a type unsigned. */
+export declare function isUnsigned(dataType: string, database: number): boolean;
+/**
+ * An ENUM's or SET's members, each read as MySQL reads a string literal in
+ * either quote; null where the list holds anything else or nothing.
+ */
+export declare function enumMembers(dataType: string): string[] | null;
+/** A PostgreSQL array's element type and its number of dimensions. */
+export declare function splitPostgresArray(dataType: string, database: number): [element: string, depth: number];
+/** A type's first argument list when every argument is a number. */
+export declare function typeArguments(dataType: string): number[];
+export declare function isMySQLFamily(database: number): boolean;
+/**
+ * The scalar a type's base name gives on a database at the width the name
+ * declares, by the rules by name and then by the category primitiveOf files
+ * the type under; getColumnType widens what Oracle, Snowflake and SQLite store.
+ */
+export declare function columnScalar(element: string, base: string, args: number[], database: number, isUnsigned: boolean, primitiveOf?: (dataType: string, database: number) => PrimitiveType): ColumnScalar;
+//# sourceMappingURL=columnTypes.d.ts.map

package/dist/utils/generator-code/doctrine.d.ts

@@ -0,0 +1,6 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+export declare function createCode(state: RootState): string;
+/** One table's entity under the header and the use statements it needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+//# sourceMappingURL=doctrine.d.ts.map

package/dist/utils/generator-code/doctrineReservedWords.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Every word DBAL 4 lists as reserved on MySQL, MariaDB, PostgreSQL, SQL
+ * Server, Oracle or SQLite, in lower case: Doctrine quotes such a name in the
+ * DDL it writes but in a query only when the mapping marks it with backticks.
+ */
+export declare const DOCTRINE_RESERVED_WORDS: ReadonlySet<string>;
+//# sourceMappingURL=doctrineReservedWords.d.ts.map

package/dist/utils/generator-code/graphql.d.ts

@@ -2,4 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * The name before a last word id, in any case, the separator before it
+ * dropped, words split as isSingleWord splits them; null where id is not a
+ * word of its own, or is the only one.
+ */
+export declare function stripIdWord(name: string): string | null;
 //# sourceMappingURL=graphql.d.ts.map

package/dist/utils/generator-code/heck.d.ts

@@ -0,0 +1,5 @@
+/** heck's to_snake_case, which SeaORM's derive macros name columns by. */
+export declare function toSnakeCase(value: string): string;
+/** heck's to_upper_camel_case, which SeaORM's derive macros name variants by. */
+export declare function toUpperCamelCase(value: string): string;
+//# sourceMappingURL=heck.d.ts.map

package/dist/utils/generator-code/java.d.ts

@@ -1,5 +1,33 @@
 import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
+/**
+ * A column element's type on the JVM, named as Java writes it but for bytes,
+ * which Java, Kotlin and Scala each spell their own way.
+ */
+export type JvmType = 'BigDecimal' | 'Boolean' | 'Byte' | 'bytes' | 'Double' | 'Duration' | 'Float' | 'Integer' | 'LocalDate' | 'LocalDateTime' | 'LocalTime' | 'Long' | 'OffsetDateTime' | 'OffsetTime' | 'Short' | 'String' | 'UUID';
+export type JvmColumnType = {
+    type: JvmType;
+    /** PostgreSQL array dimensions, each one array or list level around the type. */
+    arrayDepth: number;
+};
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** The JVM type of a column on a database, from the shared column classifier. */
+export declare function getJvmType(dataType: string, database: number): JvmColumnType;
+/**
+ * A field name, with an underscore after a reserved word and after a name
+ * that breaks the class Lombok completes.
+ */
+export declare function toJavaFieldName(name: string): string;
+export declare function toJavaClassName(name: string): string;
+/**
+ * javac reads a backslash and u as a Unicode escape even in a comment, where
+ * a bad one fails the compile; an even run of backslashes starts none.
+ */
+export declare function escapeUnicodeEscapes(value: string): string;
+/**
+ * A comment as line comments, one for each of its lines, its blank first and
+ * last lines dropped; nothing for a comment that is only whitespace.
+ */
+export declare function formatLineComment(buffer: string[], indent: string, comment: string, escape?: (line: string) => string): void;
 //# sourceMappingURL=java.d.ts.map

package/dist/utils/generator-code/jsonSchema.d.ts

@@ -0,0 +1,50 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { JsonShape } from './jsonShape';
+export type JsonScalar = string | number | boolean | null;
+/**
+ * An object as a Map, which keeps every key where it was set, __proto__ and
+ * integer-like keys too, where a plain object loses or reorders them.
+ */
+export type JsonObject = Map<string, JsonValue>;
+export type JsonValue = JsonScalar | JsonScalar[] | JsonObject;
+export declare const DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/**
+ * A time of day with no offset, as z.iso.time() takes it, written with [0-9]
+ * since \d matches any script's decimal digits in a Python or .NET validator.
+ */
+export declare const TIME_PATTERN = "^(?:[01][0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:\\.[0-9]+)?)?$";
+/**
+ * A date and time with no offset; the Z a driver's Date.prototype.toJSON adds
+ * passes after seconds, as z.iso.datetime({ local: true }) lets it.
+ */
+export declare const NAIVE_DATE_TIME_PATTERN = "^[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])T(?:[01][0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:\\.[0-9]+)?Z?)?$";
+/** Every table's row schema under $defs, keyed by the cased table name. */
+export declare function createCode(state: RootState): string;
+/** One table's row schema standing alone, its name never numbered. */
+export declare function createTableCode(state: RootState, table: Table): string;
+/**
+ * Each table's key: a name met again is numbered from 2, past every name a
+ * table takes as is, so a table named user2 keeps User2 beside two users.
+ */
+export declare function toDefinitionKeys(names: string[]): string[];
+/** The schema of one value of a column, NOT NULL, with no description. */
+export declare function toValueSchema(shape: JsonShape): JsonObject;
+/**
+ * A schema that takes null too: null joins its type, and its enum, which
+ * refuses a value it does not list; a schema with no type takes null already.
+ */
+export declare function withNull(schema: JsonObject): JsonObject;
+/**
+ * JSON as Prettier writes it: two spaces a level, an object one key a line,
+ * and an array on one line while that line fits in 80 columns, its comma
+ * counted only where another key follows, else one item a line.
+ */
+export declare function formatJson(object: JsonObject, indent?: string): string;
+/**
+ * Columns a string takes on a line, a code point at a time as Prettier counts:
+ * two for a wide or fullwidth one or an emoji that takes a skin tone, none for
+ * a control, a combining mark U+0300-U+036F or a variation selector, else one.
+ */
+export declare function textWidth(text: string): number;
+//# sourceMappingURL=jsonSchema.d.ts.map

package/dist/utils/generator-code/jsonShape.d.ts

@@ -0,0 +1,37 @@
+import { Column } from '../../internal-types';
+/**
+ * What one value of a column looks like in JSON, as an API sends a row: dates
+ * and times as ISO text, a decimal as a string, binary as base64.
+ */
+export type JsonShapeKind = 'boolean' | 'integer' | 'number' | 'string' | 'uuid' | 'guid' | 'date' | 'time' | 'naiveDateTime' | 'offsetDateTime' | 'base64' | 'json' | 'enum' | 'ipv4' | 'ipv6' | 'null';
+export type JsonShape = {
+    kind: JsonShapeKind;
+    /** An integer's least value; null where the column sets none. */
+    minimum: number | null;
+    /**
+     * An integer's greatest value; null for a 64-bit one, whose range no JSON
+     * number holds exactly, so each language writes its own safe bound or none.
+     */
+    maximum: number | null;
+    /** A character type's declared length, which a shorter value meets too. */
+    maxLength: number | null;
+    /** An ENUM's members as a row holds them, each once, in the type's order. */
+    members: string[];
+    /** A PostgreSQL array's dimensions, each one a JSON array around the last. */
+    arrayDepth: number;
+};
+/**
+ * A column's value in the JSON shape, the one reading the Zod, JSON Schema
+ * and TypeScript generators share, so their types agree column by column.
+ */
+export declare function getJsonShape(dataType: string, database: number): JsonShape;
+/** A primary key takes no NULL, its NN flag set or not, as in every generator. */
+export declare function isNullableColumn(column: Column): boolean;
+/**
+ * A name TypeScript refuses for an interface or a type alias gets an
+ * underscore after it; any other name is written as the name cases give it.
+ */
+export declare function toTypeScriptTypeName(name: string): string;
+/** A key bare where TypeScript reads an identifier, else a string literal. */
+export declare function toTypeScriptPropertyKey(name: string): string;
+//# sourceMappingURL=jsonShape.d.ts.map

package/dist/utils/generator-code/kotlin.d.ts

@@ -2,4 +2,5 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function toKotlinName(name: string): string;
 //# sourceMappingURL=kotlin.d.ts.map

package/dist/utils/generator-code/mermaid.d.ts

@@ -0,0 +1,5 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=mermaid.d.ts.map