true-pg 0.7.0 → 0.8.0

package/lib/extractor/canonicalise/types.d.ts

@@ -0,0 +1,70 @@
+export declare namespace Canonical {
+    enum Kind {
+        Base = "base",
+        Composite = "composite",
+        Domain = "domain",
+        Enum = "enum",
+        Range = "range",
+        Pseudo = "pseudo",
+        Unknown = "unknown"
+    }
+    interface Abstract {
+        original_type: string;
+        canonical_name: string;
+        schema: string;
+        name: string;
+        kind: Kind;
+        dimensions: number;
+        modifiers?: string | null;
+    }
+    interface Base extends Abstract {
+        kind: Kind.Base;
+    }
+    interface Enum extends Abstract {
+        kind: Kind.Enum;
+        enum_values: string[];
+    }
+    interface CompositeAttribute {
+        name: string;
+        index: number;
+        type: Canonical;
+        comment: string | null;
+        defaultValue: any;
+        isNullable: boolean;
+        /**
+         * Whether the attribute is an identity attribute.
+         */
+        isIdentity: boolean;
+        /**
+         * Behavior of the generated attribute. "ALWAYS" if always generated,
+         * "NEVER" if never generated, "BY DEFAULT" if generated when a value
+         * is not provided.
+         */
+        generated: "ALWAYS" | "NEVER" | "BY DEFAULT";
+    }
+    interface Composite extends Abstract {
+        kind: Kind.Composite;
+        attributes: CompositeAttribute[];
+    }
+    interface Domain extends Abstract {
+        kind: Kind.Domain;
+        domain_base_type: Canonical;
+    }
+    interface Range extends Abstract {
+        kind: Kind.Range;
+        range_subtype: Canonical;
+    }
+    interface Pseudo extends Abstract {
+        kind: Kind.Pseudo;
+    }
+}
+export type Canonical = Canonical.Base | Canonical.Enum | Canonical.Composite | Canonical.Domain | Canonical.Range | Canonical.Pseudo;
+type Exclusive<T> = Omit<T, Exclude<keyof Canonical.Abstract, "kind" | "canonical_name">>;
+export type ExclusiveBase = Exclusive<Canonical.Base>;
+export type ExclusiveEnum = Exclusive<Canonical.Enum>;
+export type ExclusiveComposite = Exclusive<Canonical.Composite>;
+export type ExclusiveDomain = Exclusive<Canonical.Domain>;
+export type ExclusiveRange = Exclusive<Canonical.Range>;
+export type ExclusivePseudo = Exclusive<Canonical.Pseudo>;
+export type ExclusiveCanonProps = ExclusiveBase | ExclusiveEnum | ExclusiveComposite | ExclusiveDomain | ExclusiveRange | ExclusivePseudo;
+export {};

package/lib/extractor/canonicalise/types.js

@@ -0,0 +1,13 @@
+export var Canonical;
+(function (Canonical) {
+    let Kind;
+    (function (Kind) {
+        Kind["Base"] = "base";
+        Kind["Composite"] = "composite";
+        Kind["Domain"] = "domain";
+        Kind["Enum"] = "enum";
+        Kind["Range"] = "range";
+        Kind["Pseudo"] = "pseudo";
+        Kind["Unknown"] = "unknown";
+    })(Kind = Canonical.Kind || (Canonical.Kind = {}));
+})(Canonical || (Canonical = {}));

package/lib/extractor/index.d.ts

@@ -11,7 +11,7 @@ import { type DomainDetails } from "./kinds/domain.ts";
 import { type RangeDetails } from "./kinds/range.ts";
 import type { PgType } from "./pgtype.ts";
 export { pgTypeKinds, type PgType, type Kind } from "./pgtype.ts";
-import { Canonical } from "./canonicalise.ts";
+import { Canonical } from "./canonicalise/index.ts";
 export { Canonical };
 export type { TableDetails, ViewDetails, MaterializedViewDetails, EnumDetails, CompositeTypeDetails, FunctionDetails, DomainDetails, RangeDetails, };
 export type { TableColumn } from "./kinds/table.ts";
@@ -92,5 +92,8 @@ export declare class Extractor {
      * @param options - Optional options
      * @returns A record of all the schemas extracted, indexed by schema name.
      */
-    extractSchemas(options?: ExtractSchemaOptions): Promise<Record<string, Schema>>;
+    extractSchemas(options?: ExtractSchemaOptions): Promise<{
+        schemas: Record<string, Schema>;
+        queryCount: number;
+    }>;
 }

package/lib/extractor/index.js

@@ -11,7 +11,7 @@ import extractDomain, {} from "./kinds/domain.js";
 import extractRange, {} from "./kinds/range.js";
 import fetchTypes from "./fetchTypes.js";
 export { pgTypeKinds } from "./pgtype.js";
-import { canonicalise, Canonical, canonicaliseFromOids } from "./canonicalise.js";
+import { Canonical } from "./canonicalise/index.js";
 export { Canonical };
 export { FunctionReturnTypeKind } from "./kinds/function.js";
 const emptySchema = {
@@ -133,13 +133,11 @@ export class Extractor {
             }
             schemas[p.schemaName][p.kind] = [...schemas[p.schemaName][p.kind], p];
         }
-        const result = 
-        //  options?.resolveViews
-        // 	? resolveViewColumns(schemas)
-        // :
-        schemas;
+        // resolve all canonical types and patch the results into their placeholders
+        await db.resolve();
+        const queryCount = db.queryCount;
         options?.onProgressEnd?.();
         await db.close();
-        return result;
+        return { schemas, queryCount };
     }
 }

package/lib/extractor/kinds/composite.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 /**
  * Composite type in a schema with details.
  */

package/lib/extractor/kinds/composite.js

@@ -2,7 +2,7 @@ const extractComposite = async (db, composite) => {
     // Form the fully qualified type name
     const fullTypeName = `"${composite.schemaName}"."${composite.name}"`;
     // Get canonical type information with all the metadata
-    const [canonical] = await db.canonicalise([fullTypeName]);
+    const canonical = db.enqueue(fullTypeName);
     // Return the composite type with its canonical representation
     return {
         ...composite,

package/lib/extractor/kinds/domain.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 /**
  * Domain type in a schema with details.
  */

package/lib/extractor/kinds/domain.js

@@ -2,7 +2,7 @@ const extractDomain = async (db, domain) => {
     // Form the fully qualified type name
     const fullTypeName = `"${domain.schemaName}"."${domain.name}"`;
     // Get canonical type information with all the metadata
-    const [canonical] = await db.canonicalise([fullTypeName]);
+    const canonical = db.enqueue(fullTypeName);
     // Return the composite type with its canonical representation
     return {
         ...domain,

package/lib/extractor/kinds/function.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 declare const parameterModeMap: {
     readonly i: "IN";
     readonly o: "OUT";

package/lib/extractor/kinds/function.js

@@ -74,13 +74,13 @@ async function extractFunction(db, pgType) {
         if (row.arg_names && !row.arg_modes)
             row.arg_modes = row.arg_names.map(() => "i");
         const argModes = row.arg_modes?.map(mode => parameterModeMap[mode]) ?? [];
-        const canonical_arg_types = row.arg_types ? await db.canonicalise(row.arg_types) : [];
+        const canonical_arg_types = row.arg_types ? row.arg_types.map(type => db.enqueue(type)) : [];
         let returnType;
         const tableMatch = row.declared_return_type.match(/^TABLE\((.*)\)$/i);
         if (tableMatch) {
             const columnDefs = parsePostgresTableDefinition(row.declared_return_type);
             const columnTypes = columnDefs.map(col => col.type);
-            const canonicalColumnTypes = await db.canonicalise(columnTypes);
+            const canonicalColumnTypes = columnTypes.map(type => db.enqueue(type));
             returnType = {
                 kind: FunctionReturnTypeKind.InlineTable,
                 columns: columnDefs.map((col, i) => ({
@@ -110,7 +110,7 @@ async function extractFunction(db, pgType) {
                 else if (
                 // "c" = composite type
                 row.return_type_relation_kind === "c") {
-                    const canonicalReturnType = (await db.canonicalise([row.return_type_string]))[0];
+                    const canonicalReturnType = db.enqueue(row.return_type_string);
                     returnType = {
                         kind: FunctionReturnTypeKind.Regular,
                         type: canonicalReturnType,
@@ -119,19 +119,17 @@ async function extractFunction(db, pgType) {
                 }
                 else {
                     console.warn(`Composite return type '${row.return_type_string}' has unexpected relkind '${row.return_type_relation_kind}' for function ${pgType.schemaName}.${row.name}`);
-                    const canonicalReturnType = (await db.canonicalise([row.return_type_string]))[0];
                     returnType = {
                         kind: FunctionReturnTypeKind.Regular,
-                        type: canonicalReturnType,
+                        type: db.enqueue(row.return_type_string),
                         isSet: row.returns_set,
                     };
                 }
             }
             else {
-                const canonicalReturnType = (await db.canonicalise([row.return_type_string]))[0];
                 returnType = {
                     kind: FunctionReturnTypeKind.Regular,
-                    type: canonicalReturnType,
+                    type: db.enqueue(row.return_type_string),
                     isSet: row.returns_set,
                 };
             }

package/lib/extractor/kinds/materialized-view.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 export interface MaterializedViewColumn {
     name: string;
     type: Canonical;

package/lib/extractor/kinds/materialized-view.js

@@ -1,5 +1,5 @@
 const extractMaterializedView = async (db, mview) => {
-    // 1. Query for columns (using pg_attribute for potentially more accurate nullability)
+    // Query for columns (using pg_attribute for potentially more accurate nullability)
     const columnQuery = await db.query(`
 		SELECT
 			attr.attname AS "name",
@@ -23,17 +23,14 @@ const extractMaterializedView = async (db, mview) => {
 			AND NOT attr.attisdropped
 		ORDER BY attr.attnum;
 		`, [mview.name, mview.schemaName]);
-    // 2. Get canonical types
-    const definedTypes = columnQuery.map(row => row.definedType);
-    const canonicalTypes = await db.canonicalise(definedTypes);
-    const columns = columnQuery.map((row, index) => ({
+    const columns = columnQuery.map(row => ({
         name: row.name,
-        type: canonicalTypes[index],
+        type: db.enqueue(row.definedType),
         isNullable: row.isNullable,
         ordinalPosition: row.ordinalPosition,
         comment: row.comment,
     }));
-    // 3. Query for materialized view definition, comment, and properties
+    // Query for materialized view definition, comment, and properties
     const mviewInfoQuery = await db.query(`
 		SELECT
 			m.definition,

package/lib/extractor/kinds/range.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 /**
  * Range type in a schema with details.
  */

package/lib/extractor/kinds/range.js

@@ -1,8 +1,7 @@
 const extractRange = async (db, range) => {
     // Form the fully qualified type name
     const fullTypeName = `"${range.schemaName}"."${range.name}"`;
-    // Get canonical type information with all the metadata
-    const [canonical] = await db.canonicalise([fullTypeName]);
+    const canonical = db.enqueue(fullTypeName);
     // Return the composite type with its canonical representation
     return {
         ...range,

package/lib/extractor/kinds/table.d.ts

@@ -1,6 +1,6 @@
 import { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 export declare const updateActionMap: {
     readonly a: "NO ACTION";
     readonly r: "RESTRICT";

package/lib/extractor/kinds/table.js

@@ -105,14 +105,10 @@ const extractTable = async (db, table) => {
 			AND NOT attr.attisdropped
 		ORDER BY col.ordinal_position;
 	`, [table.name, table.schemaName]);
-    // Get the expanded type names from the query result
-    const definedTypes = columnsQuery.map(row => row.definedType);
-    // Use canonicaliseTypes to get detailed type information
-    const canonicalTypes = await db.canonicalise(definedTypes);
     // Combine the column information with the canonical type information
-    const columns = columnsQuery.map((row, index) => ({
+    const columns = columnsQuery.map(row => ({
         name: row.name,
-        type: canonicalTypes[index],
+        type: db.enqueue(row.definedType),
         comment: row.comment,
         defaultValue: row.defaultValue,
         isPrimaryKey: row.isPrimaryKey,
@@ -122,7 +118,6 @@ const extractTable = async (db, table) => {
         isIdentity: row.isIdentity,
         isUpdatable: row.isUpdatable,
         generated: row.generated,
-        informationSchemaValue: row.informationSchemaValue,
     }));
     const indicesQuery = await db.query(`
 		WITH index_columns AS (

package/lib/extractor/kinds/view.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import type { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise/index.ts";
 export interface ViewColumn {
     name: string;
     type: Canonical;

package/lib/extractor/kinds/view.js

@@ -1,5 +1,5 @@
 const extractView = async (db, view) => {
-    // 1. Query for columns (information_schema.columns + pg_attribute)
+    // Query for columns (information_schema.columns + pg_attribute)
     const columnQuery = await db.query(`
 		SELECT
 			col.column_name AS "name",
@@ -22,17 +22,14 @@ const extractView = async (db, view) => {
 			AND NOT attr.attisdropped -- Exclude dropped columns
 		ORDER BY col.ordinal_position;
 		`, [view.name, view.schemaName]);
-    // 2. Get canonical types
-    const definedTypes = columnQuery.map(row => row.definedType);
-    const canonicalTypes = await db.canonicalise(definedTypes);
-    const columns = columnQuery.map((row, index) => ({
+    const columns = columnQuery.map(row => ({
         name: row.name,
-        type: canonicalTypes[index],
+        type: db.enqueue(row.definedType),
         isNullable: row.isNullable,
         isUpdatable: row.isUpdatable,
         ordinalPosition: row.ordinalPosition,
     }));
-    // 3. Query for view definition, comment, and other properties
+    // Query for view definition, comment, and other properties
     const viewInfoQuery = await db.query(`
 		SELECT
 			d.description AS "comment",

package/lib/imports.test.js

@@ -1,4 +1,4 @@
-import { Canonical } from "./extractor/canonicalise.js";
+import { Canonical } from "./extractor/canonicalise/index.js";
 import { Import, ImportList } from "./imports.js";
 import { describe, it, expect } from "bun:test";
 const files = {
@@ -92,8 +92,7 @@ describe("Import Class", () => {
             },
         });
         expect(importInstance).toBeInstanceOf(Import);
-        expect(typeof importInstance.from === "function" ||
-            typeof importInstance.from === "string").toBe(true);
+        expect(typeof importInstance.from === "function" || typeof importInstance.from === "string").toBe(true);
         if (typeof importInstance.from === "function") {
             const generatedPath = importInstance.from(files);
             expect(generatedPath).toBe("../enums/testEnum.ts");
@@ -113,8 +112,7 @@ describe("Import Class", () => {
             },
         });
         expect(importInstance).toBeInstanceOf(Import);
-        expect(typeof importInstance.from === "function" ||
-            typeof importInstance.from === "string").toBe(true);
+        expect(typeof importInstance.from === "function" || typeof importInstance.from === "string").toBe(true);
         if (typeof importInstance.from === "function") {
             const generatedPath = importInstance.from(files);
             expect(generatedPath).toBe("../enums/testEnum.ts");
@@ -141,19 +139,13 @@ describe("ImportList Class", () => {
         expect(importList.imports[0]).toBe(newImport);
     });
     it("should merge import lists correctly", () => {
-        const list1 = new ImportList([
-            new Import({ from: "module1", namedImports: ["a"] }),
-        ]);
-        const list2 = new ImportList([
-            new Import({ from: "module2", namedImports: ["b"] }),
-        ]);
+        const list1 = new ImportList([new Import({ from: "module1", namedImports: ["a"] })]);
+        const list2 = new ImportList([new Import({ from: "module2", namedImports: ["b"] })]);
         const mergedList = ImportList.merge([list1, list2]);
         expect(mergedList.imports).toHaveLength(2);
     });
     it("should merge import lists correctly with empty list", () => {
-        const list1 = new ImportList([
-            new Import({ from: "module1", namedImports: ["a"] }),
-        ]);
+        const list1 = new ImportList([new Import({ from: "module1", namedImports: ["a"] })]);
         const list2 = new ImportList([]);
         const mergedList = ImportList.merge([list1, list2]);
         expect(mergedList.imports).toHaveLength(1);

package/lib/index.js

@@ -217,8 +217,8 @@ export async function generate(opts, generators) {
     const out = validated.out;
     const extractor = new Extractor(opts);
     const start = performance.now();
-    const schemas = await extractor.extractSchemas();
-    console.log("Extracted schemas %s\n", time(start));
+    const { schemas, queryCount } = await extractor.extractSchemas();
+    console.log("Extracted schemas %s (made %s queries)\n", time(start), queryCount);
     console.info("Generators enabled: %s\n", validated.generators.join(", "));
     generators = validated.generators.map(generator => builtin_generators[generator]).concat(generators ?? []);
     console.log("Clearing directory and generating schemas at '%s'\n", out);

package/lib/util.d.ts

@@ -1,10 +1,4 @@
 export declare const unreachable: (value: never) => never;
-export declare class Deferred<T> {
-    resolve: (value: T) => void;
-    reject: (reason?: any) => void;
-    promise: Promise<T>;
-    constructor();
-}
 export declare const eq: <T>(a: T, b: T) => boolean;
 export declare const toPascalCase: (str: string) => string;
 export declare const to_snake_case: (str: string) => string;
@@ -20,4 +14,7 @@ export type Simplify<T> = {
 export declare const parens: (str: string, type?: string) => string;
 export declare const quote: (str: string, using?: string) => string;
 export declare const quoteI: (str: string, using?: string) => string;
+export declare const removeNulls: <T>(o: T) => T;
+export declare const pos: (num: number) => number | undefined;
+export declare const minifyQuery: (query: string) => string;
 export {};

package/lib/util.js

@@ -1,17 +1,6 @@
 export const unreachable = (value) => {
     throw new Error(`Fatal: Reached unreachable code: ${value}`);
 };
-export class Deferred {
-    resolve;
-    reject;
-    promise;
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-    }
-}
 export const eq = (a, b) => {
     if (a === b)
         return true;
@@ -142,3 +131,18 @@ const isIdentifierInvalid = (str) => {
 export const parens = (str, type = "()") => `${type[0]}${str}${type[1]}`;
 export const quote = (str, using = '"') => `${using}${str.replaceAll(using, "\\" + using)}${using}`;
 export const quoteI = (str, using = '"') => (isIdentifierInvalid(str) ? quote(str, using) : str);
+export const removeNulls = (o) => {
+    for (const key in o)
+        if (o[key] == null)
+            delete o[key];
+    return o;
+};
+export const pos = (num) => (num < 0 ? undefined : num);
+export const minifyQuery = (query) => {
+    return query
+        .split("\n")
+        .map(line => line.slice(0, pos(line.indexOf("--"))))
+        .join("\n")
+        .replaceAll(/\s+/g, " ")
+        .trim();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "true-pg",
-	"version": "0.7.0",
+	"version": "0.8.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",

package/lib/extractor/canonicalise.d.ts

@@ -1,110 +0,0 @@
-import { DbAdapter } from "./adapter.ts";
-interface ParsedTypeName {
-    /** Name after removing modifiers and brackets, e.g. "varchar" in "varchar(50)" */
-    base: string;
-    /** Modifiers, e.g. "50" in "varchar(50)" */
-    modifiers: string | null;
-    /** Number of dimensions from explicit brackets, e.g. 1 in "int[]" */
-    dimensions: number;
-    /** Original type name, e.g. "varchar(50)" */
-    original: string;
-}
-/**
- * Parses a PostgreSQL type name string to extract its base name,
- * modifiers, and dimensions from explicit '[]' brackets.
- *
- * Examples:
- *
- * - `parseTypeName("varchar(50)")`
- *
- *		`⤷ { baseTypeName: "varchar", modifiers: "50", dimensions: 0, originalTypeName: "varchar(50)" }`
- *
- * - `parseTypeName("int[]")`
- *
- *		`⤷ { baseTypeName: "int", modifiers: null, dimensions: 1, originalTypeName: "int[]" }`
- *
- * - `parseTypeName("public.my_table[][]")`
- *
- *		`⤷ { baseTypeName: "public.my_table", modifiers: null, dimensions: 2, originalTypeName: "public.my_table[][]" }`
- *
- * - `parseTypeName("numeric(10, 2)[]")`
- *
- *		`⤷ { baseTypeName: "numeric", modifiers: "10, 2", dimensions: 1, originalTypeName: "numeric(10, 2)[]" }`
- *
- * - `parseTypeName("geometry(Point, 4326)")`
- *
- *		`⤷ { baseTypeName: "geometry", modifiers: "Point, 4326", dimensions: 0, originalTypeName: "geometry(Point, 4326)" }`
- *
- * - `parseTypeName("_text")`
- *
- *		`⤷ { baseTypeName: "_text", modifiers: null, dimensions: 0, originalTypeName: "_text" }`
- *
- *		Internal arrays aren't handled here
- */
-export declare function parseTypeName(type: string): ParsedTypeName;
-export declare namespace Canonical {
-    enum Kind {
-        Base = "base",
-        Composite = "composite",
-        Domain = "domain",
-        Enum = "enum",
-        Range = "range",
-        Pseudo = "pseudo",
-        Unknown = "unknown"
-    }
-    interface Abstract {
-        original_type: string;
-        canonical_name: string;
-        schema: string;
-        name: string;
-        kind: Kind;
-        dimensions: number;
-        modifiers?: string | null;
-    }
-    interface Base extends Abstract {
-        kind: Kind.Base;
-    }
-    interface Enum extends Abstract {
-        kind: Kind.Enum;
-        enum_values: string[];
-    }
-    interface CompositeAttribute {
-        name: string;
-        index: number;
-        type: Canonical;
-        comment: string | null;
-        defaultValue: any;
-        isNullable: boolean;
-        /**
-         * Whether the attribute is an identity attribute.
-         */
-        isIdentity: boolean;
-        /**
-         * Behavior of the generated attribute. "ALWAYS" if always generated,
-         * "NEVER" if never generated, "BY DEFAULT" if generated when a value
-         * is not provided.
-         */
-        generated: "ALWAYS" | "NEVER" | "BY DEFAULT";
-    }
-    interface Composite extends Abstract {
-        kind: Kind.Composite;
-        attributes: CompositeAttribute[];
-    }
-    interface Domain extends Abstract {
-        kind: Kind.Domain;
-        domain_base_type: Canonical;
-    }
-    interface Range extends Abstract {
-        kind: Kind.Range;
-        range_subtype: Canonical;
-    }
-    interface Pseudo extends Abstract {
-        kind: Kind.Pseudo;
-    }
-}
-export type Canonical = Canonical.Base | Canonical.Enum | Canonical.Composite | Canonical.Domain | Canonical.Range | Canonical.Pseudo;
-type ExclusiveCanonProps = Omit<Canonical, keyof Canonical.Abstract>;
-export declare const canonicalise: (db: DbAdapter, types: string[], rawTypeCache: Map<string, Promise<Canonical>>, canonicalCache: Map<string, Promise<ExclusiveCanonProps>>) => Promise<Canonical[]>;
-export declare const oidsToQualifiedNames: (db: DbAdapter, oids: number[]) => Promise<string[]>;
-export declare const canonicaliseFromOids: (db: DbAdapter, oids: number[]) => Promise<Canonical[]>;
-export {};