@dineug/erd-editor 3.9.2 → 4.0.0

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

@@ -0,0 +1,90 @@
+import { ActionType } from '../../engine/actions';
+import { RootState } from '../../engine/state';
+import { ValuesType } from '../../internal-types';
+import { Matcher } from './matcher';
+export declare const FindField: {
+    readonly tableName: "tableName";
+    readonly tableComment: "tableComment";
+    readonly columnName: "columnName";
+    readonly columnComment: "columnComment";
+    readonly memo: "memo";
+};
+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.
+ */
+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. */
+    id: string;
+    /** The table of a table or column field; empty for a memo. */
+    tableId: string;
+    /** Where the field stands in the walk, so a match keeps its place when its text changes. */
+    slot: number;
+    text: string;
+    start: number;
+    end: number;
+};
+type Field = Omit<FindMatch, 'start' | 'end'>;
+/**
+ * What changes a text the search reads, or which fields it walks: the actions
+ * a search on screen runs again on. A hover, a selection or a scroll changes
+ * none, and a slow pattern would stall the tab on every one of them.
+ */
+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.
+ */
+export declare function walkFields(state: RootState, fields: ReadonlyArray<FindField>): Field[];
+/**
+ * Every occurrence the matcher finds in the fields given, one entry each, in
+ * document order.
+ *
+ * @example
+ * findMatches(store.state, matcher, [FindField.columnName]);
+ */
+export declare function findMatches(state: RootState, matcher: Matcher, fields?: ReadonlyArray<FindField>): 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,
+ * every other one as it was, since no other text moves.
+ */
+export declare function rematchField(matches: ReadonlyArray<FindMatch>, matcher: Matcher, changed: FindMatch, value: string): FindMatch[];
+/**
+ * The match a search goes on to once the text before a point has been dealt
+ * with: the first one past the offset in the slot given, or in a later slot,
+ * wrapping to the first. Minus one when there is none.
+ */
+export declare function indexAfter(matches: ReadonlyArray<FindMatch>, slot: number, offset: number): number;
+/**
+ * Where a run of Replace presses began, and whether it has since gone past the
+ * last match to the first. Its field is known by entity, with the text the run
+ * left there, since a slot shifts and an undo or a peer may write over that text.
+ */
+export type ReplaceRun = Pick<FindMatch, 'field' | 'id' | 'slot' | 'start'> & {
+    text: string;
+    wrapped: boolean;
+};
+/**
+ * A run as the document stands now, its field's slot found again, since a
+ * 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;
+/**
+ * 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
+ * the run has wrapped and come back to where it began, which it would replace again.
+ */
+export declare function nextReplace(after: ReadonlyArray<FindMatch>, match: FindMatch, value: string, run: ReplaceRun | null): {
+    index: number;
+    run: ReplaceRun;
+};
+export {};
+//# sourceMappingURL=findMatches.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './findMatches';
+export * from './matcher';
+export * from './present';
+export * from './replaceActions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,53 @@
+export type FindOptions = {
+    matchCase: boolean;
+    wholeWord: boolean;
+    regex: boolean;
+};
+export type TextRange = {
+    start: number;
+    end: number;
+};
+export type Replaced = {
+    value: string;
+    /** The occurrences whose replacement differs from the text they matched. */
+    changed: number;
+};
+export type Matcher = {
+    /** Every occurrence in the text, in order. An empty match is never one. */
+    find: (text: string) => TextRange[];
+    /**
+     * The text with its occurrences replaced, or only the one starting at the
+     * offset given. A regular expression expands $1, $<name>, $& and $$ in the
+     * replacement; plain text is inserted as it is.
+     */
+    replace: (text: string, replacement: string, onlyAt?: number) => Replaced;
+};
+export type MatcherResult = {
+    matcher: Matcher;
+    error: null;
+} | {
+    matcher: null;
+    error: 'empty' | 'invalid';
+};
+export declare const DEFAULT_FIND_OPTIONS: FindOptions;
+/**
+ * What a replacement template becomes for one match, by the rules of
+ * String.prototype.replace, which offers no way to expand a template for a
+ * match it is handed one at a time.
+ */
+export declare function expandReplacement(template: string, match: string, captures: Array<string | undefined>, position: number, subject: string, groups?: Record<string, string | undefined>): string;
+/**
+ * A typed pattern spelled for unicode mode, read the way people type it: an
+ * escaped character other than a letter, a digit or a syntax character by its
+ * code point, and a stray ] or a brace no quantifier owns as itself.
+ */
+export declare function toUnicodeSource(source: string): string;
+/**
+ * Builds the search a find and replace runs over every field, or says why
+ * there is none: nothing to look for, or a regular expression that does not parse.
+ *
+ * @example
+ * const { matcher } = createMatcher('user', { ...DEFAULT_FIND_OPTIONS, wholeWord: true });
+ */
+export declare function createMatcher(query: string, options: FindOptions): MatcherResult;
+//# sourceMappingURL=matcher.d.ts.map

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

@@ -0,0 +1,24 @@
+import { RootState } from '../../engine/state';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+import { FindField, FindMatch } from './findMatches';
+/** 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.
+ */
+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, i18n?: Pick<I18n, 't'>): string;
+export type Snippet = {
+    text: string;
+    start: number;
+    end: number;
+};
+/**
+ * The part of a long text a result row has room for, on one line, with the
+ * match inside it: from the start of a word some way before it, then as much
+ * after as fits. The range given back is the match's place within the excerpt.
+ */
+export declare function snippetOf({ text, start, end }: Pick<FindMatch, 'text' | 'start' | 'end'>, before?: number, length?: number): Snippet;
+//# sourceMappingURL=present.d.ts.map

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

@@ -0,0 +1,20 @@
+import { AnyAction } from '@dineug/r-html';
+import { FindMatch } from './findMatches';
+import { Matcher } from './matcher';
+/** The atom action that writes a new value into the field a match was found in. */
+export declare function toFieldAction({ field, id, tableId }: Pick<FindMatch, 'field' | 'id' | 'tableId'>, value: string): AnyAction;
+export type ReplaceActions = {
+    actions: AnyAction[];
+    /** The matches the replacement changed, leaving out one it wrote back as it was. */
+    replaced: number;
+};
+/**
+ * One atom action per field whose text the replacement changes, for a single
+ * dispatch: one undo entry, and the same LWW writes a peer receives from an
+ * edit by hand. Given one match, only that occurrence is replaced.
+ *
+ * @example
+ * store.dispatchSync(toReplaceActions(matches, matcher, 'account_id').actions);
+ */
+export declare function toReplaceActions(matches: ReadonlyArray<FindMatch>, matcher: Matcher, replacement: string, only?: FindMatch): ReplaceActions;
+//# sourceMappingURL=replaceActions.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

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

@@ -0,0 +1,28 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { FormatTableOptions } from './utils';
+/**
+ * PHP takes declare(strict_types=1) only as the first statement, so the text
+ * opens on the tag with nothing before it, not even the blank line the other
+ * languages open with.
+ */
+export declare const PHP_HEADER: readonly string[];
+export declare const INDENT = "    ";
+export declare function createCode(state: RootState): string;
+/** One table's class under the header, which a file of its own needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A PostgreSQL array type, which pdo_pgsql reads as a text literal such as {1,2}. */
+export declare function isPostgresArray(dataType: string, database: number): boolean;
+/**
+ * A name PHP refuses for a class, in any letter case, gets an underscore
+ * after it, as nikic/PHP-Parser names its List_ and Match_ nodes.
+ */
+export declare function toClassName(name: string): string;
+/**
+ * A comment as a doc block, one line or several: a line comment would end at
+ * a ?> in the text and leave PHP, where a block runs on to its close, which a
+ * star and a slash in the text would write early.
+ */
+export declare function formatDocComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=php.d.ts.map

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

@@ -0,0 +1,13 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare const INDENT = "    ";
+/** Every keyword of edition 2015 to 2024 a raw identifier takes. */
+export declare const RUST_KEYWORDS: ReadonlySet<string>;
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A keyword as a raw identifier, or with an underscore after it where rustc takes none. */
+export declare function toRustIdentifier(name: string): string;
+export declare function toStructName(name: string): string;
+/** A comment as line comments, its bidirectional controls written as escapes. */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=rust.d.ts.map

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

@@ -0,0 +1,44 @@
+/** The Rust value a column's element holds, which each generator spells its own way. */
+export type RustScalar = 'bool' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64' | 'decimal' | 'string' | 'bytes' | 'uuid' | 'json' | 'date' | 'time' | 'dateTime' | 'dateTimeUtc' | 'dateTimeOffset';
+/**
+ * Each scalar by its full path, so a struct compiles with no use statement
+ * and beside a struct of any of these last names.
+ */
+export declare const RUST_SCALAR_PATHS: Readonly<Record<RustScalar, string>>;
+export type RustColumnType = {
+    scalar: RustScalar;
+    /** The field type with one Vec a PostgreSQL array dimension, by full paths. */
+    rust: string;
+    /**
+     * The element's type name, lower case, its arguments gone, and on MySQL and
+     * MariaDB its UNSIGNED and ZEROFILL too.
+     */
+    base: string;
+    /** The element's arguments when all are numbers: numeric(10,2) gives [10, 2]. */
+    args: number[];
+    arrayDepth: number;
+    /** MySQL and MariaDB: UNSIGNED, ZEROFILL or SERIAL in the type. */
+    isUnsigned: boolean;
+    isFloat: boolean;
+    /**
+     * PostgreSQL alone: the type sqlx reads the column through, cast, where it
+     * reads the column's own type into no Rust type here; null elsewhere.
+     */
+    selectAs: string | null;
+    /**
+     * The element as an entity declares it: a PostgreSQL array of more than one
+     * dimension, which neither sqlx nor SeaORM decodes, is a string read as text.
+     */
+    entityScalar: RustScalar;
+};
+/** PostgreSQL's character types, which sqlx reads into a String as they are. */
+export declare const POSTGRES_CHARACTER_TYPES: ReadonlySet<string>;
+/**
+ * The shared column classifier with the choices sqlx makes for Rust on top: an
+ * Oracle, Snowflake or SQLite integer keeps the width its name declares, and a
+ * MySQL SIGNED stays in the name, which keeps it from every rule by name.
+ */
+export declare function getRustColumnType(dataType: string, database: number): RustColumnType;
+/** A type inside one Vec per dimension. */
+export declare function wrapVec(type: string, depth: number): string;
+//# sourceMappingURL=rustTypes.d.ts.map

package/dist/utils/generator-code/scala.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 toScalaName(name: string): string;
 //# sourceMappingURL=scala.d.ts.map

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

@@ -0,0 +1,22 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+type EntityColumnType = {
+    type: string;
+    columnType: string | null;
+    selectAs: string | null;
+    saveAs: string | null;
+    isFloat: boolean;
+};
+export declare function createCode(state: RootState): string;
+/** One table's entity as its module file holds it, named in the whole document. */
+export declare function createTableCode(state: RootState, table: Table): string;
+/** The column name DeriveEntityModel gives a field it reads without column_name. */
+export declare function derivedColumnName(field: string): string;
+/** UpperCamelCase applied until it stops changing: aBC gives ABc, then ABc. */
+export declare function stableUpperCamelCase(value: string): string;
+/** A Rust string literal rustc takes for any text. */
+export declare function rustString(value: string): string;
+/** The field type, column_type, select_as and save_as an entity writes. */
+export declare function getEntityColumnType(dataType: string, database: number): EntityColumnType;
+export {};
+//# sourceMappingURL=seaorm.d.ts.map

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

@@ -0,0 +1,44 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { FormatTableOptions } from './utils';
+/**
+ * Date, Data, Decimal and UUID need Foundation, and an unused import draws no
+ * warning, so the text and the one-table view open on it whatever they hold.
+ */
+export declare const SWIFT_HEADER: readonly string[];
+export declare const INDENT = "    ";
+/**
+ * A nonisolated struct keeps its conformances usable off the main actor in a
+ * module whose default isolation is MainActor, as new Xcode app targets set.
+ */
+export declare const STRUCT_HEAD = "nonisolated struct";
+export declare const CONFORMANCES = "Codable, Hashable, Sendable";
+/** The words the Swift lexer reserves, which a name takes only in backticks. */
+export declare const SWIFT_KEYWORDS: ReadonlySet<string>;
+/**
+ * The types and protocols the output writes unqualified: a struct of one of
+ * these names breaks the conformances or silently retypes every such field.
+ */
+export declare const TYPE_NAMES: ReadonlySet<string>;
+export declare function createCode(state: RootState): string;
+/** One table's struct under the import, which a file of its own needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A column's Swift type, one array a PostgreSQL dimension, without its optional. */
+export declare function swiftType(dataType: string, database: number): string;
+/** A type name gets an underscore after it, and a keyword backticks. */
+export declare function toStructName(name: string): string;
+/** A property's coding key, an underscore after a name the keys reserve. */
+export declare function toPropertyKey(name: string): string;
+export declare function toPropertyName(key: string): string;
+/**
+ * A Swift string literal: a quote and a backslash, which would also open an
+ * interpolation, get a backslash, and every C0 control and DEL an escape.
+ */
+export declare function toStringLiteral(value: string): string;
+/**
+ * A comment as documentation lines, split at every line terminator, since a
+ * lone CR ends a line comment; a NUL, which Swift warns about, is an escape.
+ */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=swift.d.ts.map