quicktype 18.0.6 → 19.0.4

package/dist/quicktype-core/GatherNames.js

@@ -1,333 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gatherNames = void 0;
-const pluralize = __importStar(require("pluralize"));
-const collection_utils_1 = require("collection-utils");
-const Type_1 = require("./Type");
-const TypeUtils_1 = require("./TypeUtils");
-const TypeNames_1 = require("./attributes/TypeNames");
-const Support_1 = require("./support/Support");
-const Transformers_1 = require("./Transformers");
-class UniqueQueue {
-    _present = new Set();
-    _queue = [];
-    _front = 0;
-    get size() {
-        return this._queue.length - this._front;
-    }
-    get isEmpty() {
-        return this.size <= 0;
-    }
-    push(v) {
-        if (this._present.has(v))
-            return;
-        this._queue.push(v);
-        this._present.add(v);
-    }
-    unshift() {
-        (0, Support_1.assert)(!this.isEmpty, "Trying to unshift from an empty queue");
-        const v = this._queue[this._front];
-        if (v === undefined) {
-            return (0, Support_1.panic)("Value should have been present in queue");
-        }
-        this._queue[this._front] = undefined;
-        this._front += 1;
-        this._present.delete(v);
-        if (this._front > this.size) {
-            this._queue = this._queue.slice(this._front);
-            this._front = 0;
-        }
-        return v;
-    }
-}
-// `gatherNames` infers names from given names and property names.
-//
-// 1. Propagate type and property names down to children.  Let's say
-//    we start with JSON like this, and we name the top-level `TopLevel`:
-//
-//    {
-//      "foos": [ [ { "bar": 123 } ] ]
-//    }
-//
-//    We use a work-list algorithm to first add the name `TopLevel` to
-//    the outermost class type.  Then we propagate the property name
-//    `foos` to the outer array, which in turn propagates its singular
-//    `foo` to the inner array type.  That tries to singularize `foo`,
-//    but it's already singular, so `foo` is added as a name for the
-//    inner class.  We also then add `bar` to the name of the integer
-//    type.
-//
-// 2. Add "ancestor" alternatives and some "direct" alternatives.
-//    Direct alternatives are those that don't contain any ancestor
-//    names, whereas ancestor alternatives do. What we do here is add
-//    names of the form `TopLevel_foo` and `TopLevel_foo_class` as
-//    ancestor alternatives to the inner class, and `foo_element` as
-//    a direct alternative, the latter because it's an element in an
-//    array.
-//
-// 3. Add more direct alternatives to the type names.  The reason we're
-//    doing this separately from step 2 is because step 2 only requires
-//    iterating over the types, wheras this step iterates over
-//    ancestor/descendant relationships.  In this case we would add
-//    `TopLevel_class`, and `foo_class` to the outer and inner classes,
-//    respectively.  We do similar stuff for all the other types.
-//
-// 4. For each type, set its inferred names to what we gathered in
-//    step 1, and its alternatives to a union of its direct and ancestor
-//    alternatives, gathered in steps 2 and 3.
-function gatherNames(graph, destructive, debugPrint) {
-    function setNames(t, tn) {
-        graph.attributeStore.set(TypeNames_1.namesTypeAttributeKind, t, tn);
-    }
-    if (destructive) {
-        for (const t of graph.allTypesUnordered()) {
-            if (t.hasNames) {
-                setNames(t, t.getNames().clearInferred());
-            }
-        }
-    }
-    const queue = new UniqueQueue();
-    // null means there are too many
-    const namesForType = new Map();
-    function addNames(t, names) {
-        // Always use the type's given names if it has some
-        if (t.hasNames) {
-            const originalNames = t.getNames();
-            if (!originalNames.areInferred) {
-                names = originalNames.names;
-            }
-        }
-        const oldNames = namesForType.get(t);
-        if (oldNames === null)
-            return;
-        let newNames;
-        if (oldNames === undefined) {
-            newNames = names;
-        }
-        else if (names === null) {
-            newNames = null;
-        }
-        else {
-            newNames = (0, collection_utils_1.setUnion)(oldNames, names);
-        }
-        if (newNames !== null && newNames.size >= TypeNames_1.tooManyNamesThreshold) {
-            newNames = null;
-        }
-        namesForType.set(t, newNames);
-        const transformation = (0, Transformers_1.transformationForType)(t);
-        if (transformation !== undefined) {
-            addNames(transformation.targetType, names);
-        }
-        if (oldNames !== undefined && newNames !== null) {
-            if (oldNames.size === newNames.size) {
-                return;
-            }
-        }
-        else if (oldNames === newNames) {
-            return;
-        }
-        queue.push(t);
-    }
-    for (const [name, t] of graph.topLevels) {
-        addNames(t, new Set([name]));
-    }
-    while (!queue.isEmpty) {
-        const t = queue.unshift();
-        const names = (0, Support_1.defined)(namesForType.get(t));
-        if (t instanceof Type_1.ObjectType) {
-            const properties = t.getSortedProperties();
-            for (const [propertyName, property] of properties) {
-                addNames(property.type, new Set([propertyName]));
-            }
-            const values = t.getAdditionalProperties();
-            if (values !== undefined) {
-                addNames(values, names === null ? null : (0, collection_utils_1.setMap)(names, pluralize.singular));
-            }
-        }
-        else {
-            (0, TypeUtils_1.matchCompoundType)(t, arrayType => {
-                addNames(arrayType.items, names === null ? null : (0, collection_utils_1.setMap)(names, pluralize.singular));
-            }, _classType => (0, Support_1.panic)("We handled this above"), _mapType => (0, Support_1.panic)("We handled this above"), _objectType => (0, Support_1.panic)("We handled this above"), unionType => {
-                const members = (0, collection_utils_1.setSortBy)(unionType.members, member => member.kind);
-                for (const memberType of members) {
-                    addNames(memberType, names);
-                }
-            });
-        }
-    }
-    if (debugPrint) {
-        for (const t of graph.allTypesUnordered()) {
-            const names = namesForType.get(t);
-            if (names === undefined)
-                return;
-            const index = t.index;
-            console.log(`${index}: ${names === null ? "*** too many ***" : Array.from(names).join(" ")}`);
-        }
-    }
-    // null means there are too many
-    const directAlternativesForType = new Map();
-    const ancestorAlternativesForType = new Map();
-    const pairsProcessed = new Map();
-    function addAlternatives(existing, alternatives) {
-        if (alternatives.length === 0) {
-            return existing;
-        }
-        if (existing === undefined) {
-            existing = new Set();
-        }
-        existing = (0, collection_utils_1.setUnion)(existing, alternatives);
-        if (existing.size < TypeNames_1.tooManyNamesThreshold) {
-            return existing;
-        }
-        return null;
-    }
-    function processType(ancestor, t, alternativeSuffix) {
-        const names = (0, Support_1.defined)(namesForType.get(t));
-        let processedEntry = pairsProcessed.get(ancestor);
-        if (processedEntry === undefined)
-            processedEntry = new Set();
-        if (processedEntry.has(t))
-            return;
-        processedEntry.add(t);
-        pairsProcessed.set(ancestor, processedEntry);
-        const transformation = (0, Transformers_1.transformationForType)(t);
-        if (transformation !== undefined) {
-            processType(ancestor, transformation.targetType, alternativeSuffix);
-        }
-        let ancestorAlternatives = ancestorAlternativesForType.get(t);
-        let directAlternatives = directAlternativesForType.get(t);
-        if (names === null) {
-            ancestorAlternatives = null;
-            directAlternatives = null;
-        }
-        else {
-            if (ancestor !== undefined && ancestorAlternatives !== null) {
-                const ancestorNames = namesForType.get(ancestor);
-                if (ancestorNames === null) {
-                    ancestorAlternatives = null;
-                }
-                else if (ancestorNames !== undefined) {
-                    const alternatives = [];
-                    for (const name of names) {
-                        alternatives.push(...Array.from(ancestorNames).map(an => `${an}_${name}`));
-                        // FIXME: add alternatives with the suffix here, too?
-                        alternatives.push(...Array.from(ancestorNames).map(an => `${an}_${name}_${t.kind}`));
-                        // FIXME: add alternatives with the suffix here, too?
-                    }
-                    ancestorAlternatives = addAlternatives(ancestorAlternatives, alternatives);
-                }
-            }
-            if (alternativeSuffix !== undefined && directAlternatives !== null) {
-                const alternatives = [];
-                for (const name of names) {
-                    // FIXME: we should only add these for names we couldn't singularize
-                    alternatives.push(`${name}_${alternativeSuffix}`);
-                }
-                directAlternatives = addAlternatives(directAlternatives, alternatives);
-            }
-        }
-        if (ancestorAlternatives !== undefined) {
-            ancestorAlternativesForType.set(t, ancestorAlternatives);
-        }
-        if (directAlternatives !== undefined) {
-            directAlternativesForType.set(t, directAlternatives);
-        }
-        if (t instanceof Type_1.ObjectType) {
-            const properties = t.getSortedProperties();
-            for (const [, property] of properties) {
-                processType(t, property.type, undefined);
-            }
-            const values = t.getAdditionalProperties();
-            if (values !== undefined) {
-                processType(properties.size === 0 ? ancestor : t, values, "value");
-            }
-        }
-        else {
-            (0, TypeUtils_1.matchCompoundType)(t, arrayType => {
-                processType(ancestor, arrayType.items, "element");
-            }, _classType => (0, Support_1.panic)("We handled this above"), _mapType => (0, Support_1.panic)("We handled this above"), _objectType => (0, Support_1.panic)("We handled this above"), unionType => {
-                const members = (0, collection_utils_1.setSortBy)(unionType.members, member => member.kind);
-                const unionHasGivenName = unionType.hasNames && !unionType.getNames().areInferred;
-                const unionIsAncestor = unionHasGivenName || (0, TypeUtils_1.nullableFromUnion)(unionType) === null;
-                const ancestorForMembers = unionIsAncestor ? unionType : ancestor;
-                for (const memberType of members) {
-                    processType(ancestorForMembers, memberType, undefined);
-                }
-            });
-        }
-    }
-    for (const [, t] of graph.topLevels) {
-        processType(undefined, t, undefined);
-    }
-    for (const t of graph.allTypesUnordered()) {
-        const names = namesForType.get(t);
-        if (names === undefined)
-            continue;
-        if (names === null) {
-            directAlternativesForType.set(t, null);
-            continue;
-        }
-        let alternatives = directAlternativesForType.get(t);
-        if (alternatives === null)
-            continue;
-        if (alternatives === undefined) {
-            alternatives = new Set();
-        }
-        alternatives = (0, collection_utils_1.setUnion)(alternatives, (0, collection_utils_1.setMap)(names, name => `${name}_${t.kind}`));
-        directAlternativesForType.set(t, alternatives);
-    }
-    for (const t of graph.allTypesUnordered()) {
-        const names = namesForType.get(t);
-        if (names === undefined)
-            continue;
-        let typeNames;
-        if (names === null) {
-            typeNames = new TypeNames_1.TooManyTypeNames(1);
-        }
-        else {
-            const ancestorAlternatives = ancestorAlternativesForType.get(t);
-            const directAlternatives = directAlternativesForType.get(t);
-            let alternatives;
-            if (ancestorAlternatives === null && directAlternatives === null) {
-                alternatives = undefined;
-            }
-            else {
-                if (directAlternatives !== null && directAlternatives !== undefined) {
-                    alternatives = directAlternatives;
-                }
-                else {
-                    alternatives = new Set();
-                }
-                if (ancestorAlternatives !== null && ancestorAlternatives !== undefined) {
-                    alternatives = (0, collection_utils_1.setUnion)(alternatives, ancestorAlternatives);
-                }
-            }
-            typeNames = TypeNames_1.TypeNames.makeWithDistance(names, alternatives, destructive ? 1 : 10);
-        }
-        setNames(t, t.hasNames ? t.getNames().add([typeNames]) : typeNames);
-    }
-}
-exports.gatherNames = gatherNames;

package/dist/quicktype-core/Graph.d.ts

@@ -1,12 +0,0 @@
-export declare class Graph<T> {
-    private readonly _nodes;
-    private readonly _indexByNode;
-    private readonly _successors;
-    constructor(nodes: Iterable<T>, invertDirection: boolean, edges: number[][] | ((node: T) => ReadonlySet<T>));
-    get size(): number;
-    get nodes(): ReadonlyArray<T>;
-    findRoots(): ReadonlySet<T>;
-    dfsTraversal(root: T, preOrder: boolean, process: (node: T) => void): void;
-    stronglyConnectedComponents(): Graph<ReadonlySet<T>>;
-    makeDot(includeNode: (n: T) => boolean, nodeLabel: (n: T) => string): string;
-}

package/dist/quicktype-core/Graph.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Graph = void 0;
-const collection_utils_1 = require("collection-utils");
-const Support_1 = require("./support/Support");
-function countComponentGraphNodes(components) {
-    if (components.length === 0)
-        return 0;
-    let largest = -1;
-    let count = 0;
-    for (const c of components) {
-        (0, Support_1.assert)(c.length > 0, "Empty component not allowed");
-        for (const v of c) {
-            (0, Support_1.assert)(v >= 0, "Negative vertex index is invalid");
-            largest = Math.max(largest, v);
-            count += 1;
-        }
-    }
-    (0, Support_1.assert)(largest + 1 === count, "Vertex indexes and count don't match up");
-    return count;
-}
-// https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
-function stronglyConnectedComponents(successors) {
-    let index = 0;
-    const stack = [];
-    const numNodes = successors.length;
-    const indexes = (0, Support_1.repeated)(numNodes, -1);
-    const lowLinks = (0, Support_1.repeated)(numNodes, -1);
-    const onStack = (0, Support_1.repeated)(numNodes, false);
-    const sccs = [];
-    function strongconnect(v) {
-        // Set the depth index for v to the smallest unused index
-        indexes[v] = index;
-        lowLinks[v] = index;
-        index += 1;
-        stack.push(v);
-        onStack[v] = true;
-        // Consider successors of v
-        for (const w of successors[v]) {
-            if (indexes[w] < 0) {
-                // Successor w has not yet been visited; recurse on it
-                strongconnect(w);
-                lowLinks[v] = Math.min(lowLinks[v], lowLinks[w]);
-            }
-            else if (onStack[w]) {
-                // Successor w is in stack and hence in the current SCC
-                // If w is not on stack, then (v, w) is a cross-edge in the DFS tree and must be ignored
-                // Note: The next line may look odd - but is correct.
-                // It says w.index not w.lowlink; that is deliberate and from the original paper
-                lowLinks[v] = Math.min(lowLinks[v], indexes[w]);
-            }
-        }
-        // If v is a root node, pop the stack and generate an SCC
-        if (lowLinks[v] === indexes[v]) {
-            const scc = [];
-            let w;
-            do {
-                w = (0, Support_1.defined)(stack.pop());
-                onStack[w] = false;
-                scc.push(w);
-            } while (w !== v);
-            sccs.push(scc);
-        }
-    }
-    for (let v = 0; v < numNodes; v++) {
-        if (indexes[v] < 0) {
-            strongconnect(v);
-        }
-    }
-    (0, Support_1.assert)(countComponentGraphNodes(sccs) === numNodes, "We didn't put all the nodes into SCCs");
-    return sccs;
-}
-function buildComponentOfNodeMap(successors, components) {
-    const numComponents = components.length;
-    const numNodes = successors.length;
-    (0, Support_1.assert)(numNodes === countComponentGraphNodes(components), "Components don't match up with graph");
-    const componentOfNode = (0, Support_1.repeated)(numNodes, -1);
-    for (let c = 0; c < numComponents; c++) {
-        for (const n of components[c]) {
-            (0, Support_1.assert)(componentOfNode[n] < 0, "We have a node that's in two components");
-            componentOfNode[n] = c;
-        }
-    }
-    return componentOfNode;
-}
-function buildMetaSuccessors(successors, components) {
-    const numComponents = components.length;
-    const componentOfNode = buildComponentOfNodeMap(successors, components);
-    const componentAdded = (0, Support_1.repeated)(numComponents, false);
-    const metaSuccessors = [];
-    for (let c = 0; c < numComponents; c++) {
-        const succ = [];
-        for (const n of components[c]) {
-            for (const s of successors[n]) {
-                const ms = componentOfNode[s];
-                if (ms === c || componentAdded[ms])
-                    continue;
-                succ.push(ms);
-                componentAdded[ms] = true;
-            }
-        }
-        // reset bookkeeping
-        for (const ms of succ) {
-            (0, Support_1.assert)(componentAdded[ms]);
-            componentAdded[ms] = false;
-        }
-        metaSuccessors.push(succ);
-    }
-    return metaSuccessors;
-}
-function invertEdges(successors) {
-    const numNodes = successors.length;
-    const predecessors = (0, Support_1.repeatedCall)(numNodes, () => []);
-    for (let s = 0; s < numNodes; s++) {
-        for (const v of successors[s]) {
-            predecessors[v].push(s);
-        }
-    }
-    return predecessors;
-}
-function calculateInDegrees(successors) {
-    const numNodes = successors.length;
-    const inDegrees = (0, Support_1.repeated)(numNodes, 0);
-    for (const s of successors) {
-        for (const v of s) {
-            inDegrees[v] += 1;
-        }
-    }
-    return inDegrees;
-}
-function findRoots(successors) {
-    const numNodes = successors.length;
-    const inDegrees = calculateInDegrees(successors);
-    const roots = [];
-    for (let v = 0; v < numNodes; v++) {
-        if (inDegrees[v] === 0) {
-            roots.push(v);
-        }
-    }
-    return roots;
-}
-class Graph {
-    _nodes;
-    _indexByNode;
-    _successors;
-    constructor(nodes, invertDirection, edges) {
-        this._nodes = Array.from(nodes);
-        this._indexByNode = new Map(this._nodes.map((n, i) => [n, i]));
-        let edgesArray;
-        if (Array.isArray(edges)) {
-            edgesArray = edges;
-        }
-        else {
-            edgesArray = this._nodes.map(n => Array.from(edges(n)).map(s => (0, Support_1.defined)(this._indexByNode.get(s))));
-        }
-        if (invertDirection) {
-            edgesArray = invertEdges(edgesArray);
-        }
-        this._successors = edgesArray;
-    }
-    get size() {
-        return this._nodes.length;
-    }
-    get nodes() {
-        return this._nodes;
-    }
-    findRoots() {
-        const roots = findRoots(this._successors);
-        return new Set(roots.map(n => this._nodes[n]));
-    }
-    // The subgraph starting at `root` must be acyclic.
-    dfsTraversal(root, preOrder, process) {
-        const visited = (0, Support_1.repeated)(this.size, false);
-        const visit = (v) => {
-            if (visited[v])
-                return;
-            visited[v] = true;
-            if (preOrder) {
-                process(this._nodes[v]);
-            }
-            for (const w of this._successors[v]) {
-                visit(w);
-            }
-            if (!preOrder) {
-                process(this._nodes[v]);
-            }
-        };
-        visit((0, Support_1.defined)(this._indexByNode.get(root)));
-    }
-    stronglyConnectedComponents() {
-        const components = stronglyConnectedComponents(this._successors);
-        const componentSuccessors = buildMetaSuccessors(this._successors, components);
-        return new Graph(components.map(ns => (0, collection_utils_1.setMap)(ns, n => this._nodes[n])), false, componentSuccessors);
-    }
-    makeDot(includeNode, nodeLabel) {
-        const lines = [];
-        lines.push("digraph G {");
-        lines.push("    ordering = out;");
-        lines.push("");
-        for (let i = 0; i < this.size; i++) {
-            const n = this._nodes[i];
-            if (!includeNode(n))
-                continue;
-            lines.push(`    node${i} [label="${nodeLabel(n)}"];`);
-        }
-        for (let i = 0; i < this.size; i++) {
-            if (!includeNode(this._nodes[i]))
-                continue;
-            for (const j of this._successors[i]) {
-                if (!includeNode(this._nodes[j]))
-                    continue;
-                lines.push(`    node${i} -> node${j};`);
-            }
-        }
-        lines.push("}");
-        lines.push("");
-        return lines.join("\n");
-    }
-}
-exports.Graph = Graph;

package/dist/quicktype-core/GraphRewriting.d.ts

@@ -1,87 +0,0 @@
-import { PrimitiveTypeKind, Type, ClassProperty, MaybeTypeIdentity } from "./Type";
-import { TypeGraph, TypeRef } from "./TypeGraph";
-import { TypeAttributes } from "./attributes/TypeAttributes";
-import { TypeBuilder, StringTypeMapping } from "./TypeBuilder";
-export interface TypeLookerUp {
-    lookupTypeRefs(typeRefs: TypeRef[], forwardingRef?: TypeRef): TypeRef | undefined;
-    reconstituteTypeRef(typeRef: TypeRef, attributes?: TypeAttributes, forwardingRef?: TypeRef): TypeRef;
-}
-export declare class TypeReconstituter<TBuilder extends BaseGraphRewriteBuilder> {
-    private readonly _typeBuilder;
-    private readonly _makeClassUnique;
-    private readonly _typeAttributes;
-    private readonly _forwardingRef;
-    private readonly _register;
-    private _wasUsed;
-    private _typeRef;
-    constructor(_typeBuilder: TBuilder, _makeClassUnique: boolean, _typeAttributes: TypeAttributes, _forwardingRef: TypeRef | undefined, _register: (tref: TypeRef) => void);
-    private builderForNewType;
-    private builderForSetting;
-    getResult(): TypeRef;
-    private register;
-    private registerAndAddAttributes;
-    lookup(tref: TypeRef): TypeRef | undefined;
-    lookup(trefs: Iterable<TypeRef>): ReadonlyArray<TypeRef> | undefined;
-    lookupMap<K>(trefs: ReadonlyMap<K, TypeRef>): ReadonlyMap<K, TypeRef> | undefined;
-    reconstitute(tref: TypeRef): TypeRef;
-    reconstitute(trefs: Iterable<TypeRef>): ReadonlyArray<TypeRef>;
-    reconstituteMap<K>(trefs: ReadonlyMap<K, TypeRef>): ReadonlyMap<K, TypeRef>;
-    getPrimitiveType(kind: PrimitiveTypeKind): void;
-    getEnumType(cases: ReadonlySet<string>): void;
-    getUniqueMapType(): void;
-    getMapType(values: TypeRef): void;
-    getUniqueArrayType(): void;
-    getArrayType(items: TypeRef): void;
-    setArrayItems(items: TypeRef): void;
-    makeClassProperty(tref: TypeRef, isOptional: boolean): ClassProperty;
-    getObjectType(properties: ReadonlyMap<string, ClassProperty>, additionalProperties: TypeRef | undefined): void;
-    getUniqueObjectType(properties: ReadonlyMap<string, ClassProperty> | undefined, additionalProperties: TypeRef | undefined): void;
-    getClassType(properties: ReadonlyMap<string, ClassProperty>): void;
-    getUniqueClassType(isFixed: boolean, properties: ReadonlyMap<string, ClassProperty> | undefined): void;
-    setObjectProperties(properties: ReadonlyMap<string, ClassProperty>, additionalProperties: TypeRef | undefined): void;
-    getUnionType(members: ReadonlySet<TypeRef>): void;
-    getUniqueUnionType(): void;
-    getIntersectionType(members: ReadonlySet<TypeRef>): void;
-    getUniqueIntersectionType(members?: ReadonlySet<TypeRef>): void;
-    setSetOperationMembers(members: ReadonlySet<TypeRef>): void;
-}
-export declare abstract class BaseGraphRewriteBuilder extends TypeBuilder implements TypeLookerUp {
-    readonly originalGraph: TypeGraph;
-    protected readonly debugPrint: boolean;
-    protected readonly reconstitutedTypes: Map<number, TypeRef>;
-    private _lostTypeAttributes;
-    private _printIndent;
-    constructor(originalGraph: TypeGraph, stringTypeMapping: StringTypeMapping, alphabetizeProperties: boolean, graphHasProvenanceAttributes: boolean, debugPrint: boolean);
-    withForwardingRef(maybeForwardingRef: TypeRef | undefined, typeCreator: (forwardingRef: TypeRef) => TypeRef): TypeRef;
-    reconstituteType(t: Type, attributes?: TypeAttributes, forwardingRef?: TypeRef): TypeRef;
-    abstract lookupTypeRefs(typeRefs: TypeRef[], forwardingRef?: TypeRef, replaceSet?: boolean): TypeRef | undefined;
-    protected abstract forceReconstituteTypeRef(originalRef: TypeRef, attributes?: TypeAttributes, maybeForwardingRef?: TypeRef): TypeRef;
-    reconstituteTypeRef(originalRef: TypeRef, attributes?: TypeAttributes, maybeForwardingRef?: TypeRef): TypeRef;
-    reconstituteTypeAttributes(attributes: TypeAttributes): TypeAttributes;
-    protected assertTypeRefsToReconstitute(typeRefs: TypeRef[], forwardingRef?: TypeRef): void;
-    protected changeDebugPrintIndent(delta: number): void;
-    protected get debugPrintIndentation(): string;
-    finish(): TypeGraph;
-    setLostTypeAttributes(): void;
-    get lostTypeAttributes(): boolean;
-}
-export declare class GraphRemapBuilder extends BaseGraphRewriteBuilder {
-    private readonly _map;
-    private readonly _attributeSources;
-    constructor(originalGraph: TypeGraph, stringTypeMapping: StringTypeMapping, alphabetizeProperties: boolean, graphHasProvenanceAttributes: boolean, _map: ReadonlyMap<Type, Type>, debugPrintRemapping: boolean);
-    protected makeIdentity(_maker: () => MaybeTypeIdentity): MaybeTypeIdentity;
-    private getMapTarget;
-    protected addForwardingIntersection(_forwardingRef: TypeRef, _tref: TypeRef): TypeRef;
-    lookupTypeRefs(typeRefs: TypeRef[], forwardingRef?: TypeRef): TypeRef | undefined;
-    protected forceReconstituteTypeRef(originalRef: TypeRef, attributes?: TypeAttributes, maybeForwardingRef?: TypeRef): TypeRef;
-}
-export declare class GraphRewriteBuilder<T extends Type> extends BaseGraphRewriteBuilder {
-    private readonly _replacer;
-    private readonly _setsToReplaceByMember;
-    private readonly _reconstitutedUnions;
-    constructor(originalGraph: TypeGraph, stringTypeMapping: StringTypeMapping, alphabetizeProperties: boolean, graphHasProvenanceAttributes: boolean, setsToReplace: T[][], debugPrintReconstitution: boolean, _replacer: (typesToReplace: ReadonlySet<T>, builder: GraphRewriteBuilder<T>, forwardingRef: TypeRef) => TypeRef);
-    registerUnion(typeRefs: TypeRef[], reconstituted: TypeRef): void;
-    private replaceSet;
-    protected forceReconstituteTypeRef(originalRef: TypeRef, attributes?: TypeAttributes, maybeForwardingRef?: TypeRef): TypeRef;
-    lookupTypeRefs(typeRefs: TypeRef[], forwardingRef?: TypeRef, replaceSet?: boolean): TypeRef | undefined;
-}