quicktype 18.0.6 → 19.0.4

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

@@ -1,61 +0,0 @@
-import { PrimitiveTypeKind, Type, PrimitiveStringTypeKind, ClassProperty, MaybeTypeIdentity, TransformedStringTypeKind } from "./Type";
-import { TypeGraph, TypeRef } from "./TypeGraph";
-import { TypeAttributes, TypeAttributeKind } from "./attributes/TypeAttributes";
-import { StringTypes } from "./attributes/StringTypes";
-export declare const provenanceTypeAttributeKind: TypeAttributeKind<Set<number>>;
-export type StringTypeMapping = ReadonlyMap<TransformedStringTypeKind, PrimitiveStringTypeKind>;
-export declare function stringTypeMappingGet(stm: StringTypeMapping, kind: TransformedStringTypeKind): PrimitiveStringTypeKind;
-export declare function getNoStringTypeMapping(): StringTypeMapping;
-export declare class TypeBuilder {
-    private readonly _stringTypeMapping;
-    readonly canonicalOrder: boolean;
-    private readonly _allPropertiesOptional;
-    private readonly _addProvenanceAttributes;
-    readonly typeGraph: TypeGraph;
-    protected readonly topLevels: Map<string, TypeRef>;
-    protected readonly types: (Type | undefined)[];
-    private readonly typeAttributes;
-    private _addedForwardingIntersection;
-    constructor(typeGraphSerial: number, _stringTypeMapping: StringTypeMapping, canonicalOrder: boolean, _allPropertiesOptional: boolean, _addProvenanceAttributes: boolean, inheritsProvenanceAttributes: boolean);
-    addTopLevel(name: string, tref: TypeRef): void;
-    reserveTypeRef(): TypeRef;
-    private assertTypeRefGraph;
-    private assertTypeRefSetGraph;
-    private filterTypeAttributes;
-    private commitType;
-    protected addType<T extends Type>(forwardingRef: TypeRef | undefined, creator: (tref: TypeRef) => T, attributes: TypeAttributes | undefined): TypeRef;
-    typeAtIndex(index: number): Type;
-    atIndex(index: number): [Type, TypeAttributes];
-    addAttributes(tref: TypeRef, attributes: TypeAttributes): void;
-    finish(): TypeGraph;
-    protected addForwardingIntersection(forwardingRef: TypeRef, tref: TypeRef): TypeRef;
-    protected forwardIfNecessary(forwardingRef: TypeRef | undefined, tref: undefined): undefined;
-    protected forwardIfNecessary(forwardingRef: TypeRef | undefined, tref: TypeRef): TypeRef;
-    protected forwardIfNecessary(forwardingRef: TypeRef | undefined, tref: TypeRef | undefined): TypeRef | undefined;
-    get didAddForwardingIntersection(): boolean;
-    private readonly _typeForIdentity;
-    private registerTypeForIdentity;
-    protected makeIdentity(maker: () => MaybeTypeIdentity): MaybeTypeIdentity;
-    private getOrAddType;
-    private registerType;
-    getPrimitiveType(kind: PrimitiveTypeKind, maybeAttributes?: TypeAttributes, forwardingRef?: TypeRef): TypeRef;
-    getStringType(attributes: TypeAttributes, stringTypes: StringTypes | undefined, forwardingRef?: TypeRef): TypeRef;
-    getEnumType(attributes: TypeAttributes, cases: ReadonlySet<string>, forwardingRef?: TypeRef): TypeRef;
-    makeClassProperty(tref: TypeRef, isOptional: boolean): ClassProperty;
-    getUniqueObjectType(attributes: TypeAttributes, properties: ReadonlyMap<string, ClassProperty> | undefined, additionalProperties: TypeRef | undefined, forwardingRef?: TypeRef): TypeRef;
-    getUniqueMapType(forwardingRef?: TypeRef): TypeRef;
-    getMapType(attributes: TypeAttributes, values: TypeRef, forwardingRef?: TypeRef): TypeRef;
-    setObjectProperties(ref: TypeRef, properties: ReadonlyMap<string, ClassProperty>, additionalProperties: TypeRef | undefined): void;
-    getUniqueArrayType(forwardingRef?: TypeRef): TypeRef;
-    getArrayType(attributes: TypeAttributes, items: TypeRef, forwardingRef?: TypeRef): TypeRef;
-    setArrayItems(ref: TypeRef, items: TypeRef): void;
-    modifyPropertiesIfNecessary(properties: ReadonlyMap<string, ClassProperty>): ReadonlyMap<string, ClassProperty>;
-    getClassType(attributes: TypeAttributes, properties: ReadonlyMap<string, ClassProperty>, forwardingRef?: TypeRef): TypeRef;
-    getUniqueClassType(attributes: TypeAttributes, isFixed: boolean, properties: ReadonlyMap<string, ClassProperty> | undefined, forwardingRef?: TypeRef): TypeRef;
-    getUnionType(attributes: TypeAttributes, members: ReadonlySet<TypeRef>, forwardingRef?: TypeRef): TypeRef;
-    getUniqueUnionType(attributes: TypeAttributes, members: ReadonlySet<TypeRef> | undefined, forwardingRef?: TypeRef): TypeRef;
-    getIntersectionType(attributes: TypeAttributes, members: ReadonlySet<TypeRef>, forwardingRef?: TypeRef): TypeRef;
-    getUniqueIntersectionType(attributes: TypeAttributes, members: ReadonlySet<TypeRef> | undefined, forwardingRef?: TypeRef): TypeRef;
-    setSetOperationMembers(ref: TypeRef, members: ReadonlySet<TypeRef>): void;
-    setLostTypeAttributes(): void;
-}

package/dist/quicktype-core/TypeBuilder.js

@@ -1,324 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeBuilder = exports.getNoStringTypeMapping = exports.stringTypeMappingGet = exports.provenanceTypeAttributeKind = void 0;
-const collection_utils_1 = require("collection-utils");
-const Type_1 = require("./Type");
-const TypeGraph_1 = require("./TypeGraph");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const Support_1 = require("./support/Support");
-const StringTypes_1 = require("./attributes/StringTypes");
-// FIXME: Don't infer provenance.  All original types should be present in
-// non-inferred form in the final graph.
-class ProvenanceTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("provenance");
-    }
-    appliesToTypeKind(_kind) {
-        return true;
-    }
-    combine(arr) {
-        return (0, collection_utils_1.setUnionManyInto)(new Set(), arr);
-    }
-    makeInferred(p) {
-        return p;
-    }
-    stringify(p) {
-        return Array.from(p)
-            .sort()
-            .map(i => i.toString())
-            .join(",");
-    }
-}
-exports.provenanceTypeAttributeKind = new ProvenanceTypeAttributeKind();
-function stringTypeMappingGet(stm, kind) {
-    const mapped = stm.get(kind);
-    if (mapped === undefined)
-        return "string";
-    return mapped;
-}
-exports.stringTypeMappingGet = stringTypeMappingGet;
-let noStringTypeMapping;
-function getNoStringTypeMapping() {
-    if (noStringTypeMapping === undefined) {
-        noStringTypeMapping = new Map(Array.from(Type_1.transformedStringTypeKinds).map(k => [k, k]));
-    }
-    return noStringTypeMapping;
-}
-exports.getNoStringTypeMapping = getNoStringTypeMapping;
-class TypeBuilder {
-    _stringTypeMapping;
-    canonicalOrder;
-    _allPropertiesOptional;
-    _addProvenanceAttributes;
-    typeGraph;
-    topLevels = new Map();
-    types = [];
-    typeAttributes = [];
-    _addedForwardingIntersection = false;
-    constructor(typeGraphSerial, _stringTypeMapping, canonicalOrder, _allPropertiesOptional, _addProvenanceAttributes, inheritsProvenanceAttributes) {
-        this._stringTypeMapping = _stringTypeMapping;
-        this.canonicalOrder = canonicalOrder;
-        this._allPropertiesOptional = _allPropertiesOptional;
-        this._addProvenanceAttributes = _addProvenanceAttributes;
-        (0, Support_1.assert)(!_addProvenanceAttributes || !inheritsProvenanceAttributes, "We can't both inherit as well as add provenance");
-        this.typeGraph = new TypeGraph_1.TypeGraph(this, typeGraphSerial, _addProvenanceAttributes || inheritsProvenanceAttributes);
-    }
-    addTopLevel(name, tref) {
-        // assert(t.typeGraph === this.typeGraph, "Adding top-level to wrong type graph");
-        (0, Support_1.assert)(!this.topLevels.has(name), "Trying to add top-level with existing name");
-        (0, Support_1.assert)(this.types[(0, TypeGraph_1.typeRefIndex)(tref)] !== undefined, "Trying to add a top-level type that doesn't exist (yet?)");
-        this.topLevels.set(name, tref);
-    }
-    reserveTypeRef() {
-        const index = this.types.length;
-        // console.log(`reserving ${index}`);
-        this.types.push(undefined);
-        const tref = (0, TypeGraph_1.makeTypeRef)(this.typeGraph, index);
-        const attributes = this._addProvenanceAttributes
-            ? exports.provenanceTypeAttributeKind.makeAttributes(new Set([index]))
-            : TypeAttributes_1.emptyTypeAttributes;
-        this.typeAttributes.push(attributes);
-        return tref;
-    }
-    assertTypeRefGraph(tref) {
-        if (tref === undefined)
-            return;
-        (0, TypeGraph_1.assertTypeRefGraph)(tref, this.typeGraph);
-    }
-    assertTypeRefSetGraph(trefs) {
-        if (trefs === undefined)
-            return;
-        trefs.forEach(tref => this.assertTypeRefGraph(tref));
-    }
-    filterTypeAttributes(t, attributes) {
-        const filtered = (0, collection_utils_1.mapFilter)(attributes, (_, k) => k.appliesToTypeKind(t.kind));
-        if (attributes.size !== filtered.size) {
-            this.setLostTypeAttributes();
-        }
-        return filtered;
-    }
-    commitType(tref, t) {
-        this.assertTypeRefGraph(tref);
-        const index = (0, TypeGraph_1.typeRefIndex)(tref);
-        // const name = names !== undefined ? ` ${names.combinedName}` : "";
-        // console.log(`committing ${t.kind}${name} to ${index}`);
-        (0, Support_1.assert)(this.types[index] === undefined, "A type index was committed twice");
-        this.types[index] = t;
-        this.typeAttributes[index] = this.filterTypeAttributes(t, this.typeAttributes[index]);
-    }
-    addType(forwardingRef, creator, attributes) {
-        if (forwardingRef !== undefined) {
-            this.assertTypeRefGraph(forwardingRef);
-            (0, Support_1.assert)(this.types[(0, TypeGraph_1.typeRefIndex)(forwardingRef)] === undefined);
-        }
-        const tref = forwardingRef !== undefined ? forwardingRef : this.reserveTypeRef();
-        if (attributes !== undefined) {
-            const index = (0, TypeGraph_1.typeRefIndex)(tref);
-            this.typeAttributes[index] = (0, TypeAttributes_1.combineTypeAttributes)("union", this.typeAttributes[index], attributes);
-        }
-        const t = creator(tref);
-        this.commitType(tref, t);
-        return tref;
-    }
-    typeAtIndex(index) {
-        const maybeType = this.types[index];
-        if (maybeType === undefined) {
-            return (0, Support_1.panic)("Trying to deref an undefined type in a type builder");
-        }
-        return maybeType;
-    }
-    atIndex(index) {
-        const t = this.typeAtIndex(index);
-        const attribtues = this.typeAttributes[index];
-        return [t, attribtues];
-    }
-    addAttributes(tref, attributes) {
-        this.assertTypeRefGraph(tref);
-        const index = (0, TypeGraph_1.typeRefIndex)(tref);
-        const existingAttributes = this.typeAttributes[index];
-        (0, Support_1.assert)((0, collection_utils_1.iterableEvery)(attributes, ([k, v]) => {
-            if (!k.inIdentity)
-                return true;
-            const existing = existingAttributes.get(k);
-            if (existing === undefined)
-                return false;
-            return (0, collection_utils_1.areEqual)(existing, v);
-        }), "Can't add different identity type attributes to an existing type");
-        const maybeType = this.types[index];
-        if (maybeType !== undefined) {
-            attributes = this.filterTypeAttributes(maybeType, attributes);
-        }
-        const nonIdentityAttributes = (0, collection_utils_1.mapFilter)(attributes, (_, k) => !k.inIdentity);
-        this.typeAttributes[index] = (0, TypeAttributes_1.combineTypeAttributes)("union", existingAttributes, nonIdentityAttributes);
-    }
-    finish() {
-        this.typeGraph.freeze(this.topLevels, this.types.map(Support_1.defined), this.typeAttributes);
-        return this.typeGraph;
-    }
-    addForwardingIntersection(forwardingRef, tref) {
-        this.assertTypeRefGraph(tref);
-        this._addedForwardingIntersection = true;
-        return this.addType(forwardingRef, tr => new Type_1.IntersectionType(tr, this.typeGraph, new Set([tref])), undefined);
-    }
-    forwardIfNecessary(forwardingRef, tref) {
-        if (tref === undefined)
-            return undefined;
-        if (forwardingRef === undefined)
-            return tref;
-        return this.addForwardingIntersection(forwardingRef, tref);
-    }
-    get didAddForwardingIntersection() {
-        return this._addedForwardingIntersection;
-    }
-    _typeForIdentity = new collection_utils_1.EqualityMap();
-    registerTypeForIdentity(identity, tref) {
-        if (identity === undefined)
-            return;
-        this._typeForIdentity.set(identity, tref);
-    }
-    makeIdentity(maker) {
-        return maker();
-    }
-    getOrAddType(identityMaker, creator, attributes, forwardingRef) {
-        const identity = this.makeIdentity(identityMaker);
-        let maybeTypeRef;
-        if (identity === undefined) {
-            maybeTypeRef = undefined;
-        }
-        else {
-            maybeTypeRef = this._typeForIdentity.get(identity);
-        }
-        if (maybeTypeRef !== undefined) {
-            const result = this.forwardIfNecessary(forwardingRef, maybeTypeRef);
-            if (attributes !== undefined) {
-                // We only add the attributes that are not in the identity, since
-                // we found the type based on its identity, i.e. all the identity
-                // attributes must be in there already, and we have a check that
-                // asserts that no identity attributes are added later.
-                this.addAttributes(result, (0, collection_utils_1.mapFilter)(attributes, (_, k) => !k.inIdentity));
-            }
-            return result;
-        }
-        const tref = this.addType(forwardingRef, creator, attributes);
-        this.registerTypeForIdentity(identity, tref);
-        return tref;
-    }
-    registerType(t) {
-        this.registerTypeForIdentity(t.identity, t.typeRef);
-    }
-    getPrimitiveType(kind, maybeAttributes, forwardingRef) {
-        const attributes = (0, collection_utils_1.withDefault)(maybeAttributes, TypeAttributes_1.emptyTypeAttributes);
-        // FIXME: Why do date/time types need a StringTypes attribute?
-        // FIXME: Remove this from here and put it into flattenStrings
-        let stringTypes = kind === "string" ? undefined : StringTypes_1.StringTypes.unrestricted;
-        if ((0, Type_1.isPrimitiveStringTypeKind)(kind) && kind !== "string") {
-            kind = stringTypeMappingGet(this._stringTypeMapping, kind);
-        }
-        if (kind === "string") {
-            return this.getStringType(attributes, stringTypes, forwardingRef);
-        }
-        return this.getOrAddType(() => (0, Type_1.primitiveTypeIdentity)(kind, attributes), tr => new Type_1.PrimitiveType(tr, this.typeGraph, kind), attributes, forwardingRef);
-    }
-    getStringType(attributes, stringTypes, forwardingRef) {
-        const existingStringTypes = (0, collection_utils_1.mapFind)(attributes, (_, k) => k === StringTypes_1.stringTypesTypeAttributeKind);
-        (0, Support_1.assert)((stringTypes === undefined) !== (existingStringTypes === undefined), "Must instantiate string type with one enum case attribute");
-        if (existingStringTypes === undefined) {
-            attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, StringTypes_1.stringTypesTypeAttributeKind.makeAttributes((0, Support_1.defined)(stringTypes)));
-        }
-        return this.getOrAddType(() => (0, Type_1.primitiveTypeIdentity)("string", attributes), tr => new Type_1.PrimitiveType(tr, this.typeGraph, "string"), attributes, forwardingRef);
-    }
-    getEnumType(attributes, cases, forwardingRef) {
-        return this.getOrAddType(() => (0, Type_1.enumTypeIdentity)(attributes, cases), tr => new Type_1.EnumType(tr, this.typeGraph, cases), attributes, forwardingRef);
-    }
-    makeClassProperty(tref, isOptional) {
-        return new Type_1.ClassProperty(tref, this.typeGraph, isOptional);
-    }
-    getUniqueObjectType(attributes, properties, additionalProperties, forwardingRef) {
-        this.assertTypeRefGraph(additionalProperties);
-        properties = (0, collection_utils_1.definedMap)(properties, p => this.modifyPropertiesIfNecessary(p));
-        return this.addType(forwardingRef, tref => new Type_1.ObjectType(tref, this.typeGraph, "object", true, properties, additionalProperties), attributes);
-    }
-    getUniqueMapType(forwardingRef) {
-        return this.addType(forwardingRef, tr => new Type_1.MapType(tr, this.typeGraph, undefined), undefined);
-    }
-    getMapType(attributes, values, forwardingRef) {
-        this.assertTypeRefGraph(values);
-        return this.getOrAddType(() => (0, Type_1.mapTypeIdentify)(attributes, values), tr => new Type_1.MapType(tr, this.typeGraph, values), attributes, forwardingRef);
-    }
-    setObjectProperties(ref, properties, additionalProperties) {
-        this.assertTypeRefGraph(additionalProperties);
-        const type = (0, TypeGraph_1.derefTypeRef)(ref, this.typeGraph);
-        if (!(type instanceof Type_1.ObjectType)) {
-            return (0, Support_1.panic)("Tried to set properties of non-object type");
-        }
-        type.setProperties(this.modifyPropertiesIfNecessary(properties), additionalProperties);
-        this.registerType(type);
-    }
-    getUniqueArrayType(forwardingRef) {
-        return this.addType(forwardingRef, tr => new Type_1.ArrayType(tr, this.typeGraph, undefined), undefined);
-    }
-    getArrayType(attributes, items, forwardingRef) {
-        this.assertTypeRefGraph(items);
-        return this.getOrAddType(() => (0, Type_1.arrayTypeIdentity)(attributes, items), tr => new Type_1.ArrayType(tr, this.typeGraph, items), attributes, forwardingRef);
-    }
-    setArrayItems(ref, items) {
-        this.assertTypeRefGraph(items);
-        const type = (0, TypeGraph_1.derefTypeRef)(ref, this.typeGraph);
-        if (!(type instanceof Type_1.ArrayType)) {
-            return (0, Support_1.panic)("Tried to set items of non-array type");
-        }
-        type.setItems(items);
-        this.registerType(type);
-    }
-    modifyPropertiesIfNecessary(properties) {
-        properties.forEach(p => this.assertTypeRefGraph(p.typeRef));
-        if (this.canonicalOrder) {
-            properties = (0, collection_utils_1.mapSortByKey)(properties);
-        }
-        if (this._allPropertiesOptional) {
-            properties = (0, collection_utils_1.mapMap)(properties, cp => this.makeClassProperty(cp.typeRef, true));
-        }
-        return properties;
-    }
-    getClassType(attributes, properties, forwardingRef) {
-        properties = this.modifyPropertiesIfNecessary(properties);
-        return this.getOrAddType(() => (0, Type_1.classTypeIdentity)(attributes, properties), tr => new Type_1.ClassType(tr, this.typeGraph, false, properties), attributes, forwardingRef);
-    }
-    // FIXME: Maybe just distinguish between this and `getClassType`
-    // via a flag?  That would make `ClassType.map` simpler.
-    getUniqueClassType(attributes, isFixed, properties, forwardingRef) {
-        properties = (0, collection_utils_1.definedMap)(properties, p => this.modifyPropertiesIfNecessary(p));
-        return this.addType(forwardingRef, tref => new Type_1.ClassType(tref, this.typeGraph, isFixed, properties), attributes);
-    }
-    getUnionType(attributes, members, forwardingRef) {
-        this.assertTypeRefSetGraph(members);
-        return this.getOrAddType(() => (0, Type_1.unionTypeIdentity)(attributes, members), tr => new Type_1.UnionType(tr, this.typeGraph, members), attributes, forwardingRef);
-    }
-    // FIXME: why do we sometimes call this with defined members???
-    getUniqueUnionType(attributes, members, forwardingRef) {
-        this.assertTypeRefSetGraph(members);
-        return this.addType(forwardingRef, tref => new Type_1.UnionType(tref, this.typeGraph, members), attributes);
-    }
-    getIntersectionType(attributes, members, forwardingRef) {
-        this.assertTypeRefSetGraph(members);
-        return this.getOrAddType(() => (0, Type_1.intersectionTypeIdentity)(attributes, members), tr => new Type_1.IntersectionType(tr, this.typeGraph, members), attributes, forwardingRef);
-    }
-    // FIXME: why do we sometimes call this with defined members???
-    getUniqueIntersectionType(attributes, members, forwardingRef) {
-        this.assertTypeRefSetGraph(members);
-        return this.addType(forwardingRef, tref => new Type_1.IntersectionType(tref, this.typeGraph, members), attributes);
-    }
-    setSetOperationMembers(ref, members) {
-        this.assertTypeRefSetGraph(members);
-        const type = (0, TypeGraph_1.derefTypeRef)(ref, this.typeGraph);
-        if (!(type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType)) {
-            return (0, Support_1.panic)("Tried to set members of non-set-operation type");
-        }
-        type.setMembers(members);
-        this.registerType(type);
-    }
-    setLostTypeAttributes() {
-        return;
-    }
-}
-exports.TypeBuilder = TypeBuilder;

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

@@ -1,75 +0,0 @@
-import { Type } from "./Type";
-import { SeparatedNamedTypes } from "./TypeUtils";
-import { TypeBuilder, StringTypeMapping } from "./TypeBuilder";
-import { GraphRewriteBuilder, BaseGraphRewriteBuilder } from "./GraphRewriting";
-import { Graph } from "./Graph";
-import { TypeAttributeKind, TypeAttributes } from "./attributes/TypeAttributes";
-export type TypeRef = number;
-export declare function isTypeRef(x: any): x is TypeRef;
-export declare function makeTypeRef(graph: TypeGraph, index: number): TypeRef;
-export declare function typeRefIndex(tref: TypeRef): number;
-export declare function assertTypeRefGraph(tref: TypeRef, graph: TypeGraph): void;
-export declare function derefTypeRef(tref: TypeRef, graphOrBuilder: TypeGraph | BaseGraphRewriteBuilder): Type;
-export declare function attributesForTypeRef(tref: TypeRef, graphOrBuilder: TypeGraph | BaseGraphRewriteBuilder): TypeAttributes;
-export declare function typeAndAttributesForTypeRef(tref: TypeRef, graphOrBuilder: TypeGraph | BaseGraphRewriteBuilder): [Type, TypeAttributes];
-export declare class TypeAttributeStore {
-    private readonly _typeGraph;
-    private _values;
-    private readonly _topLevelValues;
-    constructor(_typeGraph: TypeGraph, _values: (TypeAttributes | undefined)[]);
-    private getTypeIndex;
-    attributesForType(t: Type): TypeAttributes;
-    attributesForTopLevel(name: string): TypeAttributes;
-    private setInMap;
-    set<T>(kind: TypeAttributeKind<T>, t: Type, value: T): void;
-    setForTopLevel<T>(kind: TypeAttributeKind<T>, topLevelName: string, value: T): void;
-    private tryGetInMap;
-    tryGet<T>(kind: TypeAttributeKind<T>, t: Type): T | undefined;
-    tryGetForTopLevel<T>(kind: TypeAttributeKind<T>, topLevelName: string): T | undefined;
-}
-export declare class TypeAttributeStoreView<T> {
-    private readonly _attributeStore;
-    private readonly _definition;
-    constructor(_attributeStore: TypeAttributeStore, _definition: TypeAttributeKind<T>);
-    set(t: Type, value: T): void;
-    setForTopLevel(name: string, value: T): void;
-    tryGet(t: Type): T | undefined;
-    get(t: Type): T;
-    tryGetForTopLevel(name: string): T | undefined;
-    getForTopLevel(name: string): T;
-}
-export declare class TypeGraph {
-    readonly serial: number;
-    private readonly _haveProvenanceAttributes;
-    private _typeBuilder?;
-    private _attributeStore;
-    private _topLevels;
-    private _types?;
-    private _parents;
-    private _printOnRewrite;
-    constructor(typeBuilder: TypeBuilder, serial: number, _haveProvenanceAttributes: boolean);
-    private get isFrozen();
-    get attributeStore(): TypeAttributeStore;
-    freeze(topLevels: ReadonlyMap<string, TypeRef>, types: Type[], typeAttributes: (TypeAttributes | undefined)[]): void;
-    get topLevels(): ReadonlyMap<string, Type>;
-    typeAtIndex(index: number): Type;
-    atIndex(index: number): [Type, TypeAttributes];
-    private filterTypes;
-    allNamedTypes(): ReadonlySet<Type>;
-    allNamedTypesSeparated(): SeparatedNamedTypes;
-    private allProvenance;
-    setPrintOnRewrite(): void;
-    private checkLostTypeAttributes;
-    private printRewrite;
-    rewrite<T extends Type>(title: string, stringTypeMapping: StringTypeMapping, alphabetizeProperties: boolean, replacementGroups: T[][], debugPrintReconstitution: boolean, replacer: (typesToReplace: ReadonlySet<T>, builder: GraphRewriteBuilder<T>, forwardingRef: TypeRef) => TypeRef, force?: boolean): TypeGraph;
-    remap(title: string, stringTypeMapping: StringTypeMapping, alphabetizeProperties: boolean, map: ReadonlyMap<Type, Type>, debugPrintRemapping: boolean, force?: boolean): TypeGraph;
-    garbageCollect(alphabetizeProperties: boolean, debugPrintReconstitution: boolean): TypeGraph;
-    rewriteFixedPoint(alphabetizeProperties: boolean, debugPrintReconstitution: boolean): TypeGraph;
-    allTypesUnordered(): ReadonlySet<Type>;
-    makeGraph(invertDirection: boolean, childrenOfType: (t: Type) => ReadonlySet<Type>): Graph<Type>;
-    getParentsOfType(t: Type): Set<Type>;
-    printGraph(): void;
-}
-export declare function noneToAny(graph: TypeGraph, stringTypeMapping: StringTypeMapping, debugPrintReconstitution: boolean): TypeGraph;
-export declare function optionalToNullable(graph: TypeGraph, stringTypeMapping: StringTypeMapping, debugPrintReconstitution: boolean): TypeGraph;
-export declare function removeIndirectionIntersections(graph: TypeGraph, stringTypeMapping: StringTypeMapping, debugPrintRemapping: boolean): TypeGraph;