@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/composites/stream-ingest.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `StreamIngest`: the usual ClickHouse ingestion chain, a stream table, a materialized view reading it and a MergeTree target.
+ *
+ * The stream table (Kafka, S3Queue, AzureQueue, RabbitMQ, NATS or FileLog)
+ * stores no rows: it is the consumer. The materialized view pulls each batch
+ * through it with `TO` and writes the target, which is an ordinary MergeTree
+ * table that can be queried, altered and backfilled on its own. Every column
+ * the view's select list writes has to be one the target declares (SQLCH110).
+ *
+ * The stream engine usually carries credentials. Name a named collection as
+ * its first argument (`Kafka(kafka_creds)`, `S3Queue(lake_creds)`) and keep
+ * the broker, bucket and keys in the collection on the server: chant never
+ * declares or reads one (#4395), and SQLCH128 fails a build that writes a
+ * password in the engine's arguments.
+ *
+ * A change to the stream table is planned as SQLCH225, not as a rebuild: the
+ * view is detached, the table replaced and the view attached again. A
+ * different `kafka_group_name` or S3Queue `keeper_path` loses the table's
+ * position, and the plan says so (#4396).
+ */
+import { type ClickHouseTable, type ClickHouseView } from "../clickhouse/entities.js";
+import type { ClickHouseMemberName } from "../core/typed.js";
+import type { Instance, TypedComposite } from "./typed.js";
+export interface StreamIngestProps {
+    /** The target table's name. The stream table is `<name>_stream` and the view `<name>_mv`. */
+    name: string;
+    /** The target's columns, as SQL: `ts DateTime, user_id UInt64, kind LowCardinality(String)`. */
+    columns: string;
+    /**
+     * The stream table's engine, with a named collection as its first argument
+     * rather than inline credentials: `Kafka(kafka_creds)`, `S3Queue(lake_creds)`.
+     */
+    engine: string;
+    /**
+     * The engine's settings, the body of a `SETTINGS` clause:
+     * `kafka_topic_list = 'events', kafka_group_name = 'ingest', kafka_format = 'JSONEachRow'`.
+     * Settings the named collection already holds are left out.
+     */
+    settings?: string;
+    /** The stream table's columns when they differ from the target's: the message as it arrives. Default: `columns`. */
+    streamColumns?: string;
+    /** The view's select list over the stream table, each item aliased to a target column. Default: `*`. */
+    select?: string;
+    /** The target's sort key (a column list or an expression). */
+    orderBy: string;
+    /** The target's engine (default `MergeTree`). */
+    targetEngine?: string;
+    /** The target's partition key. Left out by default. */
+    partitionBy?: string;
+}
+/** `Target`, `Stream` and `View` are the members' names, when the call's props give them (chant#3787). */
+export type StreamIngestMembers<Target extends string = string, Stream extends string = string, View extends string = string> = {
+    target: ClickHouseTable<Target>;
+    stream: ClickHouseTable<Stream>;
+    view: ClickHouseView<View>;
+};
+type StreamIngestCall = <const N extends string>(props: StreamIngestProps & {
+    name: N;
+}) => Instance<StreamIngestMembers<ClickHouseMemberName<N>, ClickHouseMemberName<N, "_stream">, ClickHouseMemberName<N, "_mv">>>;
+/** A stream table, the materialized view that reads it, and the MergeTree target the view writes. */
+export declare const StreamIngest: TypedComposite<StreamIngestProps, StreamIngestMembers<string, string, string>, StreamIngestCall>;
+export {};
+//# sourceMappingURL=stream-ingest.d.ts.map

package/dist/composites/stream-ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-ingest.d.ts","sourceRoot":"","sources":["../../src/composites/stream-ingest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAe,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAChG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,gGAAgG;IAChG,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oHAAoH;IACpH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wGAAwG;IACxG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,0GAA0G;AAC1G,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,SAAS,MAAM,GAAG,MAAM,IAAI;IAC9H,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,gBAAgB,GAAG,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAC7C,KAAK,EAAE,iBAAiB,GAAG;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,KACnC,QAAQ,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;AAEhI,qGAAqG;AACrG,eAAO,MAAM,YAAY,kGAeP,CAAC"}

package/dist/composites/stream-ingest.js

@@ -0,0 +1,39 @@
+/**
+ * `StreamIngest`: the usual ClickHouse ingestion chain, a stream table, a materialized view reading it and a MergeTree target.
+ *
+ * The stream table (Kafka, S3Queue, AzureQueue, RabbitMQ, NATS or FileLog)
+ * stores no rows: it is the consumer. The materialized view pulls each batch
+ * through it with `TO` and writes the target, which is an ordinary MergeTree
+ * table that can be queried, altered and backfilled on its own. Every column
+ * the view's select list writes has to be one the target declares (SQLCH110).
+ *
+ * The stream engine usually carries credentials. Name a named collection as
+ * its first argument (`Kafka(kafka_creds)`, `S3Queue(lake_creds)`) and keep
+ * the broker, bucket and keys in the collection on the server: chant never
+ * declares or reads one (#4395), and SQLCH128 fails a build that writes a
+ * password in the engine's arguments.
+ *
+ * A change to the stream table is planned as SQLCH225, not as a rebuild: the
+ * view is detached, the table replaced and the view attached again. A
+ * different `kafka_group_name` or S3Queue `keeper_path` loses the table's
+ * position, and the plan says so (#4396).
+ */
+import { Composite } from "@intentius/chant/composite";
+import { table, view } from "../clickhouse/entities.js";
+/** A stream table, the materialized view that reads it, and the MergeTree target the view writes. */
+export const StreamIngest = Composite((props) => {
+    const target = table `
+    CREATE TABLE ${props.name} (${props.columns})
+    ENGINE = ${props.targetEngine ?? "MergeTree"}
+    ${props.partitionBy ? `PARTITION BY ${props.partitionBy}` : ""}
+    ORDER BY ${props.orderBy}`;
+    const stream = table `
+    CREATE TABLE ${`${props.name}_stream`} (${props.streamColumns ?? props.columns})
+    ENGINE = ${props.engine}
+    ${props.settings ? `SETTINGS ${props.settings}` : ""}`;
+    const ingest = view `
+    CREATE MATERIALIZED VIEW ${`${props.name}_mv`} TO ${target} AS
+    SELECT ${props.select ?? "*"}
+    FROM ${stream}`;
+    return { target, stream, view: ingest };
+}, "StreamIngest");

package/dist/core/statement-class.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What the statement classifiers (`../clickhouse/plan/statements.ts`,
+ * `../postgres/plan/statements.ts`) answer, in one shape for both dialects
+ * (#4407). They read a migration file's statements offline and give each the
+ * class the schema-diff classifier gives the same change, citing its rule.
+ * Nothing runs against a server.
+ */
+import type { ClassifierRule } from "./classifier.js";
+/** One change a statement makes, under one rule. */
+export interface StatementClassified {
+    rule: string;
+    /** The rule's class, e.g. `rebuild`, `concurrently`. */
+    class: string;
+    /** The class as a report names it, e.g. `REBUILD`. */
+    label: string;
+    title: string;
+    /** Postgres: the lock the rule's restriction names, e.g. `SHARE`. */
+    lock?: string;
+    /** Data is removed and not recoverable. */
+    destructive?: boolean;
+    note?: string;
+}
+/**
+ * - `classified`: every change has a rule.
+ * - `undecided`: the statement alone cannot say which of `candidates` applies
+ *   (a column type change is a rewrite, or a rebuild when the column is in a
+ *   key); the answer `classifyDisruption()` calls `unknown`.
+ * - `unclassified`: a schema change no rule covers; `note` says what.
+ * - `data`: the statement reads or writes rows or the session, not the schema.
+ */
+export type StatementOutcome = "classified" | "undecided" | "unclassified" | "data";
+export interface StatementVerdict {
+    /** 1-based position among the file's up statements. */
+    index: number;
+    /** The statement's first line, cut to 120 characters. */
+    sql: string;
+    outcome: StatementOutcome;
+    /** `classified`: one entry per change in the statement (an `ALTER TABLE` can hold several). */
+    changes: StatementClassified[];
+    /** `undecided`: the rules that could apply, in the order a reader should weigh them. */
+    candidates?: StatementClassified[];
+    note?: string;
+}
+/** A statement's own text cut for a note: the first line, at most 120 characters. */
+export declare function sqlHead(sql: string): string;
+/** The pieces of a classified change from a dialect's rule table. */
+export declare function classifiedOf<C extends string>(rules: Readonly<Record<string, ClassifierRule<C>>>, labels: Readonly<Record<C, string>>, id: string, extra?: Partial<StatementClassified>): StatementClassified;
+/** The first lock a rule's restriction names, or undefined when it names none. */
+export declare const lockOf: (restriction: string) => string | undefined;
+/**
+ * Split a statement's tokens' text into the pieces between top-level commas
+ * (an `ALTER TABLE`'s actions). Parentheses and brackets nest.
+ */
+export declare function splitTopLevel(words: readonly string[]): string[][];
+//# sourceMappingURL=statement-class.d.ts.map

package/dist/core/statement-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-class.d.ts","sourceRoot":"","sources":["../../src/core/statement-class.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,oDAAoD;AACpD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,MAAM,CAAC;AAEpF,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,gBAAgB,CAAC;IAC1B,+FAA+F;IAC/F,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,wFAAwF;IACxF,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qFAAqF;AACrF,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI3C;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,EAClD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EACnC,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACvC,mBAAmB,CAIrB;AAKD,kFAAkF;AAClF,eAAO,MAAM,MAAM,GAAI,aAAa,MAAM,KAAG,MAAM,GAAG,SAAwC,CAAC;AAE/F;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAUlE"}

package/dist/core/statement-class.js

@@ -0,0 +1,43 @@
+/**
+ * What the statement classifiers (`../clickhouse/plan/statements.ts`,
+ * `../postgres/plan/statements.ts`) answer, in one shape for both dialects
+ * (#4407). They read a migration file's statements offline and give each the
+ * class the schema-diff classifier gives the same change, citing its rule.
+ * Nothing runs against a server.
+ */
+/** A statement's own text cut for a note: the first line, at most 120 characters. */
+export function sqlHead(sql) {
+    const line = sql.split(/\r?\n/).find((l) => l.trim() !== "" && !l.trim().startsWith("--")) ?? sql;
+    const t = line.trim().replace(/\s+/g, " ");
+    return t.length > 120 ? `${t.slice(0, 117)}...` : t;
+}
+/** The pieces of a classified change from a dialect's rule table. */
+export function classifiedOf(rules, labels, id, extra = {}) {
+    const r = rules[id];
+    if (!r)
+        throw new Error(`no classifier rule ${id}`);
+    return { rule: id, class: r.class, label: labels[r.class], title: r.title, ...extra };
+}
+/** Lock names, longest first so `SHARE UPDATE EXCLUSIVE` is not read as `SHARE`. */
+const LOCK = /\b(ACCESS EXCLUSIVE|SHARE UPDATE EXCLUSIVE|SHARE ROW EXCLUSIVE|ROW EXCLUSIVE|ROW SHARE|EXCLUSIVE|SHARE)\b/;
+/** The first lock a rule's restriction names, or undefined when it names none. */
+export const lockOf = (restriction) => LOCK.exec(restriction)?.[1];
+/**
+ * Split a statement's tokens' text into the pieces between top-level commas
+ * (an `ALTER TABLE`'s actions). Parentheses and brackets nest.
+ */
+export function splitTopLevel(words) {
+    const out = [[]];
+    let depth = 0;
+    for (const w of words) {
+        if (w === "(" || w === "[")
+            depth++;
+        else if (w === ")" || w === "]")
+            depth--;
+        if (w === "," && depth === 0)
+            out.push([]);
+        else
+            out[out.length - 1].push(w);
+    }
+    return out.filter((a) => a.length > 0);
+}

package/dist/coverage/clickhouse.json

@@ -8,7 +8,7 @@
         { "command": "CREATE HANDLER", "kind": "HTTP handler", "status": "refused", "reason": "an HTTP handler is server-level configuration, not a schema object" },
         { "command": "CREATE INDEX", "kind": "index", "status": "declared", "entity": "ClickHouse::Table", "note": "an index is part of its table: SHOW CREATE TABLE prints it, and the table's declaration holds it" },
         { "command": "CREATE MASKING POLICY", "kind": "masking policy", "status": "refused", "reason": "masking policies are available only in ClickHouse Cloud, not on the pinned server" },
-        { "command": "CREATE NAMED COLLECTION", "kind": "named collection", "status": "refused", "reason": "a named collection holds credentials (a password, a secret key), which are the environment's and never in a build; the server hides its values, so a plan could not compare them either" },
+        { "command": "CREATE NAMED COLLECTION", "kind": "named collection", "status": "referenced", "reason": "a named collection holds credentials (a password, a secret key), which are the environment's: chant never declares one or reads its values. An engine, a table function or a dictionary SOURCE names it, a plan checks that it exists, and import lists the server's as prerequisites" },
         { "command": "CREATE QUOTA", "kind": "quota", "status": "declared", "entity": "ClickHouse::Quota", "note": "import reads only the access objects a build declares" },
         { "command": "CREATE RESOURCE", "kind": "workload resource", "status": "refused", "reason": "a resource is server-level scheduling (a disk's reads or writes), configured with the server, not a schema object" },
         { "command": "CREATE ROLE", "kind": "role", "status": "declared", "entity": "ClickHouse::Role", "note": "import reads only the access objects a build declares" },

package/dist/coverage/postgres.json

@@ -10,32 +10,32 @@
         { "command": "CREATE DOMAIN", "kind": "domain", "status": "declared", "entity": "Postgres::Domain" },
         { "command": "CREATE EVENT TRIGGER", "kind": "event trigger", "status": "declared", "entity": "Postgres::EventTrigger", "note": "the database's, not a schema's; creating one takes a superuser" },
         { "command": "CREATE EXTENSION", "kind": "extension", "status": "declared", "entity": "Postgres::Extension" },
-        { "command": "CREATE FOREIGN DATA WRAPPER", "kind": "foreign data wrapper", "status": "refused", "reason": "no tag declares a foreign data wrapper yet; one an extension installs comes with the extension" },
-        { "command": "CREATE FOREIGN TABLE", "kind": "foreign table", "status": "refused", "reason": "no tag declares a foreign table yet" },
+        { "command": "CREATE FOREIGN DATA WRAPPER", "kind": "foreign data wrapper", "status": "declared", "entity": "Postgres::ForeignDataWrapper", "note": "the database's, not a schema's; creating one takes a superuser; one an extension installs comes with the extension; an option that holds a credential is refused" },
+        { "command": "CREATE FOREIGN TABLE", "kind": "foreign table", "status": "declared", "entity": "Postgres::ForeignTable", "note": "its own tag, not table: another CREATE and ALTER, no key, index or storage clauses; its server cannot be altered; one that is a partition, inherits or has a generated column is not declared; an option that holds a credential is refused" },
         { "command": "CREATE FUNCTION", "kind": "function", "status": "declared", "entity": "Postgres::Function" },
         { "command": "CREATE FUNCTION", "form": "RETURN or BEGIN ATOMIC body", "match": "\\b(?:RETURN|BEGIN\\s+ATOMIC)\\b", "kind": "routine with a SQL-standard body", "status": "refused", "reason": "the server stores a SQL-standard body parsed and prints it back rewritten, so a declaration cannot be compared with it; declare the routine with a string body (AS $$ ... $$)" },
         { "command": "CREATE GROUP", "kind": "group", "status": "declared", "entity": "Postgres::Role", "note": "an alias of CREATE ROLE" },
         { "command": "CREATE INDEX", "kind": "index", "status": "declared", "entity": "Postgres::Index" },
         { "command": "CREATE LANGUAGE", "kind": "procedural language", "status": "refused", "reason": "no tag declares a procedural language; an extension installs one, and the extension is declared instead" },
         { "command": "CREATE MATERIALIZED VIEW", "kind": "materialized view", "status": "declared", "entity": "Postgres::MaterializedView" },
-        { "command": "CREATE OPERATOR", "kind": "operator", "status": "refused", "reason": "no tag declares an operator yet" },
-        { "command": "CREATE OPERATOR CLASS", "kind": "operator class", "status": "refused", "reason": "no tag declares an operator class yet" },
-        { "command": "CREATE OPERATOR FAMILY", "kind": "operator family", "status": "refused", "reason": "no tag declares an operator family yet" },
+        { "command": "CREATE OPERATOR", "kind": "operator", "status": "declared", "entity": "Postgres::Operator", "note": "identified by its name and operand types; RESTRICT and JOIN change in place, and from 17 so does setting a commutator or negator or turning on HASHES or MERGES; anything else is a drop and a create" },
+        { "command": "CREATE OPERATOR CLASS", "kind": "operator class", "status": "declared", "entity": "Postgres::OperatorClass", "note": "identified by its name and index method; a change is a drop and a create, since ALTER OPERATOR CLASS only renames or moves it; its own family, named as the class, comes with it" },
+        { "command": "CREATE OPERATOR FAMILY", "kind": "operator family", "status": "declared", "entity": "Postgres::OperatorFamily", "note": "identified by its name and index method; its members come with the classes that name it, and loose members added with ALTER OPERATOR FAMILY are not declared" },
         { "command": "CREATE POLICY", "kind": "policy", "status": "declared", "entity": "Postgres::Policy", "note": "read where the profile manages access (sql.profiles.<env>.access)" },
         { "command": "CREATE PROCEDURE", "kind": "procedure", "status": "declared", "entity": "Postgres::Procedure" },
-        { "command": "CREATE PUBLICATION", "kind": "publication", "status": "refused", "reason": "no tag declares a publication yet" },
+        { "command": "CREATE PUBLICATION", "kind": "publication", "status": "declared", "entity": "Postgres::Publication", "note": "the database's, not a schema's; a table of it may carry a column list and row filter from 15" },
         { "command": "CREATE ROLE", "kind": "role", "status": "declared", "entity": "Postgres::Role", "note": "import reads only the roles a build declares, since a role is the cluster's" },
         { "command": "CREATE RULE", "kind": "rule", "status": "refused", "reason": "no tag declares a rewrite rule; a view's own rule is the view's" },
         { "command": "CREATE SCHEMA", "kind": "schema", "status": "declared", "entity": "Postgres::Schema" },
         { "command": "CREATE SEQUENCE", "kind": "sequence", "status": "declared", "entity": "Postgres::Sequence" },
-        { "command": "CREATE SERVER", "kind": "foreign server", "status": "refused", "reason": "no tag declares a foreign server yet" },
-        { "command": "CREATE STATISTICS", "kind": "extended statistics", "status": "refused", "reason": "no tag declares extended statistics yet" },
-        { "command": "CREATE SUBSCRIPTION", "kind": "subscription", "status": "refused", "reason": "no tag declares a subscription yet" },
+        { "command": "CREATE SERVER", "kind": "foreign server", "status": "declared", "entity": "Postgres::ForeignServer", "note": "the database's, not a schema's; its user mappings are refused, so credentials stay out of the declaration" },
+        { "command": "CREATE STATISTICS", "kind": "extended statistics", "status": "declared", "entity": "Postgres::Statistics" },
+        { "command": "CREATE SUBSCRIPTION", "kind": "subscription", "status": "refused", "reason": "a subscription's connection string carries a credential, and creating one opens a replication slot on the publisher, outside this database; the environment makes it" },
         { "command": "CREATE TABLE", "kind": "table", "status": "declared", "entity": "Postgres::Table" },
         { "command": "CREATE TABLE AS", "kind": "table from a query", "status": "declared", "entity": "Postgres::Table", "note": "the server keeps no query, so the table it made reads as a CREATE TABLE" },
         { "command": "CREATE TABLESPACE", "kind": "tablespace", "status": "out-of-scope", "reason": "a tablespace is the cluster's, a directory on the server; a table's TABLESPACE clause is kept" },
-        { "command": "CREATE TEXT SEARCH CONFIGURATION", "kind": "text search configuration", "status": "refused", "reason": "no tag declares a text search configuration yet" },
-        { "command": "CREATE TEXT SEARCH DICTIONARY", "kind": "text search dictionary", "status": "refused", "reason": "no tag declares a text search dictionary yet" },
+        { "command": "CREATE TEXT SEARCH CONFIGURATION", "kind": "text search configuration", "status": "declared", "entity": "Postgres::TextSearchConfiguration", "note": "PARSER and its ADD MAPPING statements; COPY is refused, since it copies mappings chant does not read; mappings change in place, the parser by drop and create" },
+        { "command": "CREATE TEXT SEARCH DICTIONARY", "kind": "text search dictionary", "status": "declared", "entity": "Postgres::TextSearchDictionary", "note": "a template and its options; options change in place, the template by drop and create" },
         { "command": "CREATE TEXT SEARCH PARSER", "kind": "text search parser", "status": "refused", "reason": "no tag declares a text search parser; one is C code an extension installs" },
         { "command": "CREATE TEXT SEARCH TEMPLATE", "kind": "text search template", "status": "refused", "reason": "no tag declares a text search template; one is C code an extension installs" },
         { "command": "CREATE TRANSFORM", "kind": "transform", "status": "refused", "reason": "no tag declares a transform; an extension installs one" },
@@ -45,7 +45,7 @@
         { "command": "CREATE TYPE", "form": "AS RANGE", "match": "\\bAS\\s+RANGE\\b", "kind": "range type", "status": "declared", "entity": "Postgres::RangeType", "note": "its multirange type comes with it (MULTIRANGE_TYPE_NAME)" },
         { "command": "CREATE TYPE", "form": "INPUT, OUTPUT, or a shell type", "kind": "base type", "status": "refused", "reason": "no tag declares a base type; its input and output functions are C code an extension installs" },
         { "command": "CREATE USER", "kind": "user", "status": "declared", "entity": "Postgres::Role", "note": "an alias of CREATE ROLE ... LOGIN" },
-        { "command": "CREATE USER MAPPING", "kind": "user mapping", "status": "refused", "reason": "no tag declares a user mapping yet" },
+        { "command": "CREATE USER MAPPING", "kind": "user mapping", "status": "refused", "reason": "a user mapping carries the remote user and password, which the environment supplies and a declaration never holds" },
         { "command": "CREATE VIEW", "kind": "view", "status": "declared", "entity": "Postgres::View" }
     ]
 }

package/dist/coverage.d.ts

@@ -4,8 +4,10 @@
  * Which kinds of object each dialect declares (#3911): every `CREATE` command
  * a pinned server has (`./coverage/<dialect>-commands.json`, written by
  * `scripts/sql-create-commands.ts` from the server's own sources) has a row
- * in `./coverage/<dialect>.json` marking it declared, refused with a reason,
- * or out of scope. A command with several forms that differ in what chant can
+ * in `./coverage/<dialect>.json` marking it declared, referenced, refused
+ * with a reason, or out of scope. A referenced kind (a ClickHouse named
+ * collection, #4395) is never declared: a declaration names one, a plan
+ * checks it exists, and import lists the server's as prerequisites. A command with several forms that differ in what chant can
  * hold (`CREATE TYPE ... AS ENUM` and `CREATE TYPE ... AS RANGE`) has a row
  * per form. Import refuses an object of a refused kind by that row's `kind`
  * (`./core/undeclarable.ts`), and the docs page is rendered from the rows
@@ -21,8 +23,15 @@
  * that, per section, from the generated tables.
  */
 import type { SqlDialect } from "./dialects.js";
-/** `declared`: a tag holds it. `refused`: import names it and stops. `out-of-scope`: the environment's, never imported. */
-export type KindStatus = "declared" | "refused" | "out-of-scope";
+/**
+ * `declared`: a tag holds it. `referenced`: the environment's, never declared
+ * and its values never read; a declaration names it, a plan checks it exists,
+ * and import lists the server's as prerequisites (#4395). `refused`: import
+ * names it and stops. `out-of-scope`: the environment's, never imported.
+ */
+export type KindStatus = "declared" | "referenced" | "refused" | "out-of-scope";
+/** Every status a coverage row may have. */
+export declare const KIND_STATUSES: readonly KindStatus[];
 /** One row of a dialect's coverage table: a `CREATE` command, or one form of it. */
 export interface KindRow {
     /** The command as the server's reference names it: `CREATE TYPE`. */
@@ -40,7 +49,7 @@ export interface KindRow {
     status: KindStatus;
     /** The entity type that declares it, when declared. */
     entity?: string;
-    /** Why it is refused or out of scope. */
+    /** Why it is referenced, refused or out of scope. */
     reason?: string;
     /** Anything else a reader should know. */
     note?: string;
@@ -58,7 +67,8 @@ export declare function kindRow(dialect: SqlDialect, kind: string): KindRow;
  * What is wrong with a dialect's coverage table, against its pinned servers'
  * commands: a command a pinned server has and no row covers, a row for a
  * command no pinned server has, a kind named twice, a declared row with no
- * entity, a refused or out-of-scope row with no reason. Empty when complete.
+ * entity, a referenced, refused or out-of-scope row with no reason. Empty
+ * when complete.
  */
 export declare function kindCoverageProblems(dialect: SqlDialect, opts?: {
     pins?: ReadonlyArray<{

package/dist/coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQ7C,2HAA2H;AAC3H,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,cAAc,CAAC;AAEjE,oFAAoF;AACpF,MAAM,WAAW,OAAO;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,2GAA2G;IAC3G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,CAGhE,CAAC;AAEF,2GAA2G;AAC3G,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAG/G,CAAC;AAEF,2HAA2H;AAC3H,wBAAgB,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAIlE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;CAAO,GAAG,MAAM,EAAE,CAmBpL;AAiBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAcnF;AAED,sHAAsH;AACtH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,EAAE,CAQnE;AAID,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,wBAAgB,OAAO,IAAI,cAAc,CAyBxC;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,IAAI,CAYjH"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQ7C;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,SAAS,GAAG,cAAc,CAAC;AAEhF,4CAA4C;AAC5C,eAAO,MAAM,aAAa,EAAE,SAAS,UAAU,EAA0D,CAAC;AAE1G,oFAAoF;AACpF,MAAM,WAAW,OAAO;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,2GAA2G;IAC3G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,CAGhE,CAAC;AAEF,2GAA2G;AAC3G,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAG/G,CAAC;AAEF,2HAA2H;AAC3H,wBAAgB,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAIlE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;CAAO,GAAG,MAAM,EAAE,CAmBpL;AAiBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAcnF;AAED,sHAAsH;AACtH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,EAAE,CAQnE;AAID,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,wBAAgB,OAAO,IAAI,cAAc,CAyBxC;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,IAAI,CAYjH"}

package/dist/coverage.js

@@ -4,8 +4,10 @@
  * Which kinds of object each dialect declares (#3911): every `CREATE` command
  * a pinned server has (`./coverage/<dialect>-commands.json`, written by
  * `scripts/sql-create-commands.ts` from the server's own sources) has a row
- * in `./coverage/<dialect>.json` marking it declared, refused with a reason,
- * or out of scope. A command with several forms that differ in what chant can
+ * in `./coverage/<dialect>.json` marking it declared, referenced, refused
+ * with a reason, or out of scope. A referenced kind (a ClickHouse named
+ * collection, #4395) is never declared: a declaration names one, a plan
+ * checks it exists, and import lists the server's as prerequisites. A command with several forms that differ in what chant can
  * hold (`CREATE TYPE ... AS ENUM` and `CREATE TYPE ... AS RANGE`) has a row
  * per form. Import refuses an object of a refused kind by that row's `kind`
  * (`./core/undeclarable.ts`), and the docs page is rendered from the rows
@@ -26,6 +28,8 @@ import postgresKinds from "./coverage/postgres.json" with { type: "json" };
 import clickhouseKinds from "./coverage/clickhouse.json" with { type: "json" };
 import postgresCommands from "./coverage/postgres-commands.json" with { type: "json" };
 import clickhouseCommands from "./coverage/clickhouse-commands.json" with { type: "json" };
+/** Every status a coverage row may have. */
+export const KIND_STATUSES = ["declared", "referenced", "refused", "out-of-scope"];
 /** Each dialect's coverage table. */
 export const KIND_COVERAGE = {
     postgres: postgresKinds.kinds,
@@ -47,7 +51,8 @@ export function kindRow(dialect, kind) {
  * What is wrong with a dialect's coverage table, against its pinned servers'
  * commands: a command a pinned server has and no row covers, a row for a
  * command no pinned server has, a kind named twice, a declared row with no
- * entity, a refused or out-of-scope row with no reason. Empty when complete.
+ * entity, a referenced, refused or out-of-scope row with no reason. Empty
+ * when complete.
  */
 export function kindCoverageProblems(dialect, opts = {}) {
     const rows = opts.rows ?? KIND_COVERAGE[dialect];
@@ -68,8 +73,8 @@ export function kindCoverageProblems(dialect, opts = {}) {
         if (seen.has(r.kind))
             problems.push(`the kind "${r.kind}" has two rows`);
         seen.add(r.kind);
-        if (!["declared", "refused", "out-of-scope"].includes(r.status))
-            problems.push(`${r.kind}: status "${r.status}" is not declared, refused or out-of-scope`);
+        if (!KIND_STATUSES.includes(r.status))
+            problems.push(`${r.kind}: status "${r.status}" is not ${KIND_STATUSES.slice(0, -1).join(", ")} or ${KIND_STATUSES.at(-1)}`);
         if (r.status === "declared" && !r.entity)
             problems.push(`${r.kind} is declared, and names no entity type`);
         if (r.status !== "declared" && !r.reason)

package/dist/drizzle-command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `chant sql drizzle [--output <path>] [--check] [--bigint number|bigint]`
+ * (#4401): build the project the way `chant build` does, folded, and write the
+ * Drizzle schema module {@link renderDrizzle} renders from its entities.
+ *
+ * The file goes to `<project>/drizzle-schema.ts` by default, outside the
+ * source directory the build reads, and starts with chant's generated-file
+ * marker either way. `-o` and `--output` put it elsewhere, which is also the
+ * flag a workspace `generated` entry's generator passes. `--check` renders the
+ * same text and compares it with the file instead of writing it: exit 1,
+ * naming the file, when they differ.
+ */
+import type { CommandGroupContext } from "@intentius/chant/cli/command-group";
+/** The file `chant sql drizzle` writes by default, in the project directory. */
+export declare const DRIZZLE_SCHEMA_FILE = "drizzle-schema.ts";
+export declare function runDrizzle(ctx: CommandGroupContext): Promise<number>;
+//# sourceMappingURL=drizzle-command.d.ts.map

package/dist/drizzle-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-command.d.ts","sourceRoot":"","sources":["../src/drizzle-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAI9E,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AA6BvD,wBAAsB,UAAU,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4C1E"}

package/dist/drizzle-command.js

@@ -0,0 +1,91 @@
+/**
+ * `chant sql drizzle [--output <path>] [--check] [--bigint number|bigint]`
+ * (#4401): build the project the way `chant build` does, folded, and write the
+ * Drizzle schema module {@link renderDrizzle} renders from its entities.
+ *
+ * The file goes to `<project>/drizzle-schema.ts` by default, outside the
+ * source directory the build reads, and starts with chant's generated-file
+ * marker either way. `-o` and `--output` put it elsewhere, which is also the
+ * flag a workspace `generated` entry's generator passes. `--check` renders the
+ * same text and compares it with the file instead of writing it: exit 1,
+ * naming the file, when they differ.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { DrizzleDialectError, renderDrizzle } from "./drizzle.js";
+import { buildFolded, loadProject } from "./sql-types-command.js";
+/** The file `chant sql drizzle` writes by default, in the project directory. */
+export const DRIZZLE_SCHEMA_FILE = "drizzle-schema.ts";
+const USAGE = "usage: chant sql drizzle [--output <path>] [--check] [--bigint number|bigint]";
+function parseArgs(args) {
+    const out = { check: false };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--output" || a === "-o") {
+            const v = args[++i];
+            if (!v)
+                return { error: `${a} needs a path` };
+            out.output = v;
+        }
+        else if (a.startsWith("--output="))
+            out.output = a.slice("--output=".length);
+        else if (a === "--check")
+            out.check = true;
+        else if (a === "--bigint" || a.startsWith("--bigint=")) {
+            const v = a === "--bigint" ? args[++i] : a.slice("--bigint=".length);
+            if (v !== "number" && v !== "bigint")
+                return { error: "--bigint takes number or bigint" };
+            out.bigint = v;
+        }
+        else
+            return { error: `unknown argument ${a}` };
+    }
+    return out;
+}
+export async function runDrizzle(ctx) {
+    const args = parseArgs(ctx.rawArgs);
+    if ("error" in args) {
+        console.error(`${args.error}\n${USAGE}`);
+        return 1;
+    }
+    const cwd = process.cwd();
+    const project = await loadProject(cwd);
+    const output = args.output !== undefined ? resolve(cwd, args.output) : join(project.projectDir, DRIZZLE_SCHEMA_FILE);
+    const result = await buildFolded(project, "chant sql drizzle", "nothing was written");
+    if (!result)
+        return 1;
+    let rendered;
+    try {
+        rendered = renderDrizzle(result.entities, { config: project.config, ...(args.bigint ? { bigintMode: args.bigint } : {}) });
+    }
+    catch (err) {
+        if (!(err instanceof DrizzleDialectError))
+            throw err;
+        console.error(`chant sql drizzle: ${err.message}`);
+        return 1;
+    }
+    const shown = relative(cwd, output);
+    const named = shown && !shown.startsWith("..") ? shown : output;
+    if (args.check) {
+        // Compares only; the file is never written.
+        const onDisk = existsSync(output) ? readFileSync(output, "utf8") : undefined;
+        if (onDisk === rendered.text) {
+            console.log(`${named} is current`);
+            return 0;
+        }
+        console.error(onDisk === undefined
+            ? `chant sql drizzle: ${named} does not exist; run \`chant sql drizzle\` to write it`
+            : `chant sql drizzle: ${named} differs from what the build declares; run \`chant sql drizzle\` to rewrite it`);
+        return 1;
+    }
+    mkdirSync(dirname(output), { recursive: true });
+    writeFileSync(output, rendered.text);
+    const { tables, views, enums, sequences } = rendered.counts;
+    const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+    console.log(`wrote ${named}: ${[plural(tables, "table"), plural(views, "view"), plural(enums, "enum"), plural(sequences, "sequence")].join(", ")}`);
+    for (const s of rendered.skipped)
+        console.log(`not written: ${s.kind} ${s.names.join(", ")} (${s.reason})`);
+    for (const n of rendered.approximated)
+        console.log(`partly written: ${n}`);
+    return 0;
+}

package/dist/drizzle.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The Drizzle schema module `chant sql drizzle` writes (#4401): a Postgres
+ * build's tables, enums, sequences and views as `drizzle-orm/pg-core`
+ * declarations, so an application queries with Drizzle's row types while
+ * chant owns the schema, the plan and the apply.
+ *
+ * {@link renderDrizzle} is pure: the entities of a build in, the module's
+ * text and a list of what it left out. It reads the objects as the
+ * serializer writes them, as `sql-types.ts` does, so a `.sql` file's objects
+ * and a composite's members are covered as the build covers them.
+ *
+ * The API it writes is drizzle-orm {@link DRIZZLE_ORM_CHECKED}'s `pg-core`
+ * (type definitions read from the published package):
+ *
+ * - `pgTable(name, columns, (t) => [...])`, or `pgSchema(name).table(...)`
+ *   for a schema other than `public` (`pgSchema("public")` throws);
+ * - column builders, `.notNull()`, `.default()`, `.primaryKey()`,
+ *   `.generatedAlwaysAsIdentity()`, `.generatedAlwaysAs()`, `.array()`;
+ * - `foreignKey({ name, columns, foreignColumns })` with `.onDelete()` and
+ *   `.onUpdate()`, `unique(name).on()`, `check(name, sql)`,
+ *   `index(name).on()`, `uniqueIndex(name).on()`;
+ * - `pgEnum`, `pgSequence`, and `pgView(name, columns).existing()`;
+ * - `customType` for a column type Drizzle has no builder for.
+ *
+ * Each column key is the column's name in the database, so a row has the
+ * keys `RowOf` has. Every constraint and index carries the name Postgres
+ * would give it (`./postgres/constraint-names.ts`) when the DDL names none,
+ * so `drizzle-kit` compares equal names.
+ *
+ * Foreign keys use `foreignKey()` and not a column's `.references()`: the
+ * latter takes no name, and Drizzle derives `orders_user_id_users_id_fk`
+ * where Postgres says `orders_user_id_fkey`.
+ *
+ * Views are `.existing()`: chant creates them, and `drizzle-kit` must not.
+ */
+import type { Declarable } from "@intentius/chant/declarable";
+/** The drizzle-orm version whose type definitions the output was written against. */
+export declare const DRIZZLE_ORM_CHECKED = "0.45.4";
+export interface RenderDrizzleOptions {
+    /** The project's config: `sql.postgresMajor` for the catalog, `sql.dialect` when nothing is declared. */
+    config?: Record<string, unknown>;
+    /** How a `bigint` column reads: Drizzle's `number` (the default, as `drizzle-kit pull` writes it) or `bigint`. */
+    bigintMode?: "number" | "bigint";
+}
+export interface DrizzleRender {
+    text: string;
+    /** Objects with no Drizzle declaration, by kind. */
+    skipped: Array<{
+        kind: string;
+        names: string[];
+        reason: string;
+    }>;
+    /** Parts of a mapped object that Drizzle cannot say: `app.orders: ...`. */
+    approximated: string[];
+    counts: {
+        tables: number;
+        views: number;
+        enums: number;
+        sequences: number;
+    };
+}
+/** Thrown for a build that is not Postgres. */
+export declare class DrizzleDialectError extends Error {
+}
+/**
+ * The Drizzle schema module for a build's entities. Throws
+ * {@link DrizzleDialectError} when the build is not Postgres.
+ */
+export declare function renderDrizzle(entities: ReadonlyMap<string, Declarable>, opts?: RenderDrizzleOptions): DrizzleRender;
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../src/drizzle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAU9D,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,WAAW,CAAC;AAE5C,MAAM,WAAW,oBAAoB;IACnC,yGAAyG;IACzG,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,kHAAkH;IAClH,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,2EAA2E;IAC3E,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7E;AAED,+CAA+C;AAC/C,qBAAa,mBAAoB,SAAQ,KAAK;CAAG;AA2SjD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,IAAI,GAAE,oBAAyB,GAAG,aAAa,CAyUvH"}