quicktype 18.0.6 → 19.0.4

package/dist/quicktype-core/language/Haskell.js

@@ -1,411 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HaskellRenderer = exports.HaskellTargetLanguage = exports.haskellOptions = void 0;
-const collection_utils_1 = require("collection-utils");
-const TargetLanguage_1 = require("../TargetLanguage");
-const RendererOptions_1 = require("../RendererOptions");
-const TypeUtils_1 = require("../TypeUtils");
-const ConvenienceRenderer_1 = require("../ConvenienceRenderer");
-const Naming_1 = require("../Naming");
-const Strings_1 = require("../support/Strings");
-const Source_1 = require("../Source");
-exports.haskellOptions = {
-    justTypes: new RendererOptions_1.BooleanOption("just-types", "Plain types only", false),
-    useList: new RendererOptions_1.EnumOption("array-type", "Use Array or List", [
-        ["array", false],
-        ["list", true]
-    ]),
-    moduleName: new RendererOptions_1.StringOption("module", "Generated module name", "NAME", "QuickType")
-};
-class HaskellTargetLanguage extends TargetLanguage_1.TargetLanguage {
-    constructor() {
-        super("Haskell", ["haskell"], "haskell");
-    }
-    getOptions() {
-        return [exports.haskellOptions.justTypes, exports.haskellOptions.moduleName, exports.haskellOptions.useList];
-    }
-    get supportsOptionalClassProperties() {
-        return true;
-    }
-    get supportsUnionsWithBothNumberTypes() {
-        return true;
-    }
-    makeRenderer(renderContext, untypedOptionValues) {
-        return new HaskellRenderer(this, renderContext, (0, RendererOptions_1.getOptionValues)(exports.haskellOptions, untypedOptionValues));
-    }
-}
-exports.HaskellTargetLanguage = HaskellTargetLanguage;
-const forbiddenNames = [
-    // reserved keywords
-    "as",
-    "case",
-    "class",
-    "data",
-    "default",
-    "deriving",
-    "do",
-    "else",
-    "family",
-    "forall",
-    "foreign",
-    "hiding",
-    "if",
-    "import",
-    "in",
-    "infix",
-    "infixl",
-    "infixr",
-    "instance",
-    "let",
-    "of",
-    "mdo",
-    "module",
-    "newtype",
-    "proc",
-    "qualified",
-    "rec",
-    "then",
-    "type",
-    "where",
-    // in Prelude keywords ...
-    "id",
-    "Array",
-    "HashMap",
-    "Map",
-    "Maybe",
-    "Bool",
-    "Int",
-    "True",
-    "False",
-    "Enum",
-    // Aeson types
-    "encode",
-    "decode",
-    "text",
-    "Text",
-    "Value",
-    "Object",
-    "Result",
-    "Series",
-    "Error"
-];
-const legalizeName = (0, Strings_1.legalizeCharacters)(cp => (0, Strings_1.isAscii)(cp) && (0, Strings_1.isLetterOrUnderscoreOrDigit)(cp));
-function haskellNameStyle(original, upper) {
-    const words = (0, Strings_1.splitIntoWords)(original);
-    return (0, Strings_1.combineWords)(words, legalizeName, upper ? Strings_1.firstUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.firstUpperWordStyle, upper ? Strings_1.allUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.allUpperWordStyle, "", Strings_1.isLetterOrUnderscore);
-}
-const upperNamingFunction = (0, Naming_1.funPrefixNamer)("upper", n => haskellNameStyle(n, true));
-const lowerNamingFunction = (0, Naming_1.funPrefixNamer)("lower", n => haskellNameStyle(n, false));
-class HaskellRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
-    _options;
-    constructor(targetLanguage, renderContext, _options) {
-        super(targetLanguage, renderContext);
-        this._options = _options;
-    }
-    forbiddenNamesForGlobalNamespace() {
-        return forbiddenNames;
-    }
-    makeNamedTypeNamer() {
-        return upperNamingFunction;
-    }
-    namerForObjectProperty() {
-        return lowerNamingFunction;
-    }
-    forbiddenForObjectProperties(_c, _className) {
-        return { names: [], includeGlobalForbidden: true };
-    }
-    makeUnionMemberNamer() {
-        return upperNamingFunction;
-    }
-    get unionMembersInGlobalNamespace() {
-        return true;
-    }
-    makeEnumCaseNamer() {
-        return upperNamingFunction;
-    }
-    get enumCasesInGlobalNamespace() {
-        return true;
-    }
-    proposeUnionMemberName(u, unionName, fieldType, lookup) {
-        const fieldName = super.proposeUnionMemberName(u, unionName, fieldType, lookup);
-        return `${fieldName}_in_${lookup(unionName)}`;
-    }
-    get commentLineStart() {
-        return "-- ";
-    }
-    emitDescriptionBlock(lines) {
-        if (lines.length === 1) {
-            this.emitLine("{-| ", lines[0], " -}");
-        }
-        else {
-            this.emitCommentLines(lines, "", undefined, "-}", "{-| ");
-        }
-    }
-    haskellType(t, noOptional = false) {
-        return (0, TypeUtils_1.matchType)(t, _anyType => (0, Source_1.multiWord)(" ", "Maybe", "Text"), _nullType => (0, Source_1.multiWord)(" ", "Maybe", "Text"), _boolType => (0, Source_1.singleWord)("Bool"), _integerType => (0, Source_1.singleWord)("Int"), _doubleType => (0, Source_1.singleWord)("Float"), _stringType => (0, Source_1.singleWord)("Text"), arrayType => {
-            if (this._options.useList) {
-                return (0, Source_1.multiWord)("", "[", (0, Source_1.parenIfNeeded)(this.haskellType(arrayType.items)), "]");
-            }
-            return (0, Source_1.multiWord)(" ", "Vector", (0, Source_1.parenIfNeeded)(this.haskellType(arrayType.items)));
-        }, classType => (0, Source_1.singleWord)(this.nameForNamedType(classType)), mapType => (0, Source_1.multiWord)(" ", "HashMap Text", (0, Source_1.parenIfNeeded)(this.haskellType(mapType.values))), enumType => (0, Source_1.singleWord)(this.nameForNamedType(enumType)), unionType => {
-            const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
-            if (nullable !== null) {
-                const nullableType = this.haskellType(nullable);
-                if (noOptional)
-                    return nullableType;
-                return (0, Source_1.multiWord)(" ", "Maybe", (0, Source_1.parenIfNeeded)(nullableType));
-            }
-            return (0, Source_1.singleWord)(this.nameForNamedType(unionType));
-        });
-    }
-    haskellProperty(p) {
-        if (p.isOptional) {
-            return (0, Source_1.multiWord)(" ", "Maybe", (0, Source_1.parenIfNeeded)(this.haskellType(p.type, true))).source;
-        }
-        else {
-            return this.haskellType(p.type).source;
-        }
-    }
-    encoderNameForType(t) {
-        return (0, TypeUtils_1.matchType)(t, _anyType => (0, Source_1.singleWord)("String"), _nullType => (0, Source_1.singleWord)("Null"), _boolType => (0, Source_1.singleWord)("Bool"), _integerType => (0, Source_1.singleWord)("Number"), _doubleType => (0, Source_1.singleWord)("Number"), _stringType => (0, Source_1.singleWord)("String"), _arrayType => (0, Source_1.singleWord)("Array"), _classType => (0, Source_1.singleWord)("Object"), _mapType => (0, Source_1.singleWord)("Object"), _enumType => (0, Source_1.singleWord)("Object"), _unionType => (0, Source_1.singleWord)("Object"));
-    }
-    emitTopLevelDefinition(t, topLevelName) {
-        this.emitLine("type ", topLevelName, " = ", this.haskellType(t).source);
-    }
-    emitClassDefinition(c, className) {
-        let description = this.descriptionForType(c);
-        this.forEachClassProperty(c, "none", (name, jsonName) => {
-            const propertyDescription = this.descriptionForClassProperty(c, jsonName);
-            if (propertyDescription === undefined)
-                return;
-            if (description === undefined) {
-                description = [];
-            }
-            else {
-                description.push("");
-            }
-            description.push(`${this.sourcelikeToString(name)}:`);
-            description.push(...propertyDescription);
-        });
-        this.emitDescription(description);
-        this.emitLine("data ", className, " = ", className);
-        this.indent(() => {
-            let onFirst = true;
-            this.forEachClassProperty(c, "none", (name, _jsonName, p) => {
-                this.emitLine(onFirst ? "{ " : ", ", name, className, " :: ", this.haskellProperty(p));
-                onFirst = false;
-            });
-            if (onFirst) {
-                this.emitLine("{");
-            }
-            this.emitLine("} deriving (Show)");
-        });
-    }
-    emitEnumDefinition(e, enumName) {
-        this.emitDescription(this.descriptionForType(e));
-        this.emitLine("data ", enumName);
-        this.indent(() => {
-            let onFirst = true;
-            this.forEachEnumCase(e, "none", name => {
-                const equalsOrPipe = onFirst ? "=" : "|";
-                this.emitLine(equalsOrPipe, " ", name, enumName);
-                onFirst = false;
-            });
-            this.emitLine("deriving (Show)");
-        });
-    }
-    emitUnionDefinition(u, unionName) {
-        this.emitDescription(this.descriptionForType(u));
-        this.emitLine("data ", unionName);
-        this.indent(() => {
-            let onFirst = true;
-            this.forEachUnionMember(u, null, "none", null, (constructor, t) => {
-                const equalsOrPipe = onFirst ? "=" : "|";
-                if (t.kind === "null") {
-                    this.emitLine(equalsOrPipe, " ", constructor);
-                }
-                else {
-                    this.emitLine(equalsOrPipe, " ", constructor, " ", (0, Source_1.parenIfNeeded)(this.haskellType(t)));
-                }
-                onFirst = false;
-            });
-            this.emitLine("deriving (Show)");
-        });
-    }
-    emitTopLevelFunctions(topLevelName) {
-        this.emitLine("decodeTopLevel :: ByteString -> Maybe ", topLevelName);
-        this.emitLine("decodeTopLevel = decode");
-    }
-    classPropertyLength(c) {
-        let counter = 0;
-        this.forEachClassProperty(c, "none", () => {
-            counter += 1;
-        });
-        return counter;
-    }
-    emitClassEncoderInstance(c, className) {
-        let classProperties = [];
-        this.forEachClassProperty(c, "none", name => {
-            classProperties.push(" ");
-            classProperties.push(name);
-            classProperties.push(className);
-        });
-        this.emitLine("instance ToJSON ", className, " where");
-        this.indent(() => {
-            if (classProperties.length === 0) {
-                this.emitLine("toJSON = \\_ -> emptyObject");
-            }
-            else {
-                this.emitLine("toJSON (", className, ...classProperties, ") =");
-                this.indent(() => {
-                    this.emitLine("object");
-                    let onFirst = true;
-                    this.forEachClassProperty(c, "none", (name, jsonName) => {
-                        this.emitLine(onFirst ? "[ " : ", ", '"', (0, Strings_1.stringEscape)(jsonName), '" .= ', name, className);
-                        onFirst = false;
-                    });
-                    if (onFirst) {
-                        this.emitLine("[");
-                    }
-                    this.emitLine("]");
-                });
-            }
-        });
-    }
-    emitClassDecoderInstance(c, className) {
-        this.emitLine("instance FromJSON ", className, " where");
-        this.indent(() => {
-            if (this.classPropertyLength(c) === 0) {
-                this.emitLine("parseJSON emptyObject = return ", className);
-            }
-            else {
-                this.emitLine("parseJSON (Object v) = ", className);
-                this.indent(() => {
-                    let onFirst = true;
-                    this.forEachClassProperty(c, "none", (_, jsonName, p) => {
-                        const operator = p.isOptional ? ".:?" : ".:";
-                        this.emitLine(onFirst ? "<$> " : "<*> ", "v ", operator, ' "', (0, Strings_1.stringEscape)(jsonName), '"');
-                        onFirst = false;
-                    });
-                });
-            }
-        });
-    }
-    emitClassFunctions(c, className) {
-        this.emitClassEncoderInstance(c, className);
-        this.ensureBlankLine();
-        this.emitClassDecoderInstance(c, className);
-    }
-    emitEnumEncoderInstance(e, enumName) {
-        this.emitLine("instance ToJSON ", enumName, " where");
-        this.indent(() => {
-            this.forEachEnumCase(e, "none", (name, jsonName) => {
-                this.emitLine("toJSON ", name, enumName, ' = "', (0, Strings_1.stringEscape)(jsonName), '"');
-            });
-        });
-    }
-    emitEnumDecoderInstance(e, enumName) {
-        this.emitLine("instance FromJSON ", enumName, " where");
-        this.indent(() => {
-            this.emitLine('parseJSON = withText "', enumName, '" parseText');
-            this.indent(() => {
-                this.emitLine("where");
-                this.indent(() => {
-                    this.forEachEnumCase(e, "none", (name, jsonName) => {
-                        this.emitLine('parseText "', (0, Strings_1.stringEscape)(jsonName), '" = return ', name, enumName);
-                    });
-                });
-            });
-        });
-    }
-    emitEnumFunctions(e, enumName) {
-        this.emitEnumEncoderInstance(e, enumName);
-        this.ensureBlankLine();
-        this.emitEnumDecoderInstance(e, enumName);
-    }
-    emitUnionEncoderInstance(u, unionName) {
-        this.emitLine("instance ToJSON ", unionName, " where");
-        this.indent(() => {
-            this.forEachUnionMember(u, null, "none", null, (constructor, t) => {
-                if (t.kind === "null") {
-                    this.emitLine("toJSON ", constructor, " = Null");
-                }
-                else {
-                    this.emitLine("toJSON (", constructor, " x) = toJSON x");
-                }
-            });
-        });
-    }
-    emitUnionDecoderInstance(u, unionName) {
-        this.emitLine("instance FromJSON ", unionName, " where");
-        this.indent(() => {
-            this.forEachUnionMember(u, null, "none", null, (constructor, t) => {
-                if (t.kind === "null") {
-                    this.emitLine("parseJSON Null = return ", constructor);
-                }
-                else {
-                    this.emitLine("parseJSON xs@(", this.encoderNameForType(t).source, " _) = (fmap ", constructor, " . parseJSON) xs");
-                }
-            });
-        });
-    }
-    emitUnionFunctions(u, unionName) {
-        this.emitUnionEncoderInstance(u, unionName);
-        this.ensureBlankLine();
-        this.emitUnionDecoderInstance(u, unionName);
-    }
-    emitLanguageExtensions(ext) {
-        this.emitLine(`{-# LANGUAGE ${ext} #-}`);
-    }
-    emitSourceStructure() {
-        const exports = [];
-        this.forEachTopLevel("none", (_, name) => {
-            exports.push([name, " (..)"]);
-        });
-        this.forEachObject("none", (t, name) => {
-            if (!(0, collection_utils_1.mapContains)(this.topLevels, t))
-                exports.push([name, " (..)"]);
-        });
-        this.forEachEnum("none", (t, name) => {
-            if (!(0, collection_utils_1.mapContains)(this.topLevels, t))
-                exports.push([name, " (..)"]);
-        });
-        this.forEachUnion("none", (t, name) => {
-            if (!(0, collection_utils_1.mapContains)(this.topLevels, t))
-                exports.push([name, " (..)"]);
-        });
-        this.emitLanguageExtensions("StrictData");
-        this.emitLanguageExtensions("OverloadedStrings");
-        if (!this._options.justTypes) {
-            this.ensureBlankLine();
-            this.emitLine("module ", this._options.moduleName);
-            this.indent(() => {
-                for (let i = 0; i < exports.length; i++) {
-                    this.emitLine(i === 0 ? "(" : ",", " ", exports[i]);
-                }
-                this.emitLine(", decodeTopLevel");
-                this.emitLine(") where");
-            });
-            this.ensureBlankLine();
-            this.emitMultiline(`import Data.Aeson
-import Data.Aeson.Types (emptyObject)
-import Data.ByteString.Lazy (ByteString)
-import Data.HashMap.Strict (HashMap)
-import Data.Text (Text)`);
-            if (this._options.useList) {
-                // this.emitLine("import List (map)");
-            }
-            else {
-                this.emitLine("import Data.Vector (Vector)");
-            }
-        }
-        this.forEachTopLevel("leading-and-interposing", (t, topLevelName) => this.emitTopLevelDefinition(t, topLevelName), t => this.namedTypeToNameForTopLevel(t) === undefined);
-        this.forEachNamedType("leading-and-interposing", (c, className) => this.emitClassDefinition(c, className), (e, enumName) => this.emitEnumDefinition(e, enumName), (u, unionName) => this.emitUnionDefinition(u, unionName));
-        this.forEachTopLevel("leading-and-interposing", (_, topLevelName) => this.emitTopLevelFunctions(topLevelName));
-        this.forEachNamedType("leading-and-interposing", (c, className) => this.emitClassFunctions(c, className), (e, enumName) => this.emitEnumFunctions(e, enumName), (u, unionName) => this.emitUnionFunctions(u, unionName));
-        if (this._options.justTypes)
-            return;
-        this.ensureBlankLine();
-    }
-}
-exports.HaskellRenderer = HaskellRenderer;

package/dist/quicktype-core/language/JSONSchema.d.ts

@@ -1,31 +0,0 @@
-import { TargetLanguage } from "../TargetLanguage";
-import { ConvenienceRenderer } from "../ConvenienceRenderer";
-import { Namer } from "../Naming";
-import { StringTypeMapping } from "../TypeBuilder";
-import { Option } from "../RendererOptions";
-import { RenderContext } from "../Renderer";
-export declare class JSONSchemaTargetLanguage extends TargetLanguage {
-    constructor();
-    protected getOptions(): Option<any>[];
-    get stringTypeMapping(): StringTypeMapping;
-    get supportsOptionalClassProperties(): boolean;
-    get supportsFullObjectType(): boolean;
-    protected makeRenderer(renderContext: RenderContext, _untypedOptionValues: {
-        [name: string]: any;
-    }): JSONSchemaRenderer;
-}
-export declare class JSONSchemaRenderer extends ConvenienceRenderer {
-    protected makeNamedTypeNamer(): Namer;
-    protected namerForObjectProperty(): null;
-    protected makeUnionMemberNamer(): null;
-    protected makeEnumCaseNamer(): null;
-    private nameForType;
-    private makeOneOf;
-    private makeRef;
-    private addAttributesToSchema;
-    private schemaForType;
-    private definitionForObject;
-    private definitionForUnion;
-    private definitionForEnum;
-    protected emitSourceStructure(): void;
-}

package/dist/quicktype-core/language/JSONSchema.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONSchemaRenderer = exports.JSONSchemaTargetLanguage = void 0;
-const collection_utils_1 = require("collection-utils");
-const TargetLanguage_1 = require("../TargetLanguage");
-const Type_1 = require("../Type");
-const TypeUtils_1 = require("../TypeUtils");
-const ConvenienceRenderer_1 = require("../ConvenienceRenderer");
-const Naming_1 = require("../Naming");
-const Strings_1 = require("../support/Strings");
-const Support_1 = require("../support/Support");
-const TypeBuilder_1 = require("../TypeBuilder");
-const Description_1 = require("../attributes/Description");
-class JSONSchemaTargetLanguage extends TargetLanguage_1.TargetLanguage {
-    constructor() {
-        super("JSON Schema", ["schema", "json-schema"], "schema");
-    }
-    getOptions() {
-        return [];
-    }
-    get stringTypeMapping() {
-        return (0, TypeBuilder_1.getNoStringTypeMapping)();
-    }
-    get supportsOptionalClassProperties() {
-        return true;
-    }
-    get supportsFullObjectType() {
-        return true;
-    }
-    makeRenderer(renderContext, _untypedOptionValues) {
-        return new JSONSchemaRenderer(this, renderContext);
-    }
-}
-exports.JSONSchemaTargetLanguage = JSONSchemaTargetLanguage;
-const namingFunction = (0, Naming_1.funPrefixNamer)("namer", jsonNameStyle);
-const legalizeName = (0, Strings_1.legalizeCharacters)(cp => cp >= 32 && cp < 128 && cp !== 0x2f /* slash */);
-function jsonNameStyle(original) {
-    const words = (0, Strings_1.splitIntoWords)(original);
-    return (0, Strings_1.combineWords)(words, legalizeName, Strings_1.firstUpperWordStyle, Strings_1.firstUpperWordStyle, Strings_1.allUpperWordStyle, Strings_1.allUpperWordStyle, "", _ => true);
-}
-class JSONSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
-    makeNamedTypeNamer() {
-        return namingFunction;
-    }
-    namerForObjectProperty() {
-        return null;
-    }
-    makeUnionMemberNamer() {
-        return null;
-    }
-    makeEnumCaseNamer() {
-        return null;
-    }
-    nameForType(t) {
-        return (0, Support_1.defined)(this.names.get(this.nameForNamedType(t)));
-    }
-    makeOneOf(types) {
-        const first = (0, collection_utils_1.iterableFirst)(types);
-        if (first === undefined) {
-            return (0, Support_1.panic)("Must have at least one type for oneOf");
-        }
-        if (types.size === 1) {
-            return this.schemaForType(first);
-        }
-        return { anyOf: Array.from(types).map((t) => this.schemaForType(t)) };
-    }
-    makeRef(t) {
-        return { $ref: `#/definitions/${this.nameForType(t)}` };
-    }
-    addAttributesToSchema(t, schema) {
-        const attributes = this.typeGraph.attributeStore.attributesForType(t);
-        for (const [kind, attr] of attributes) {
-            kind.addToSchema(schema, t, attr);
-        }
-    }
-    schemaForType(t) {
-        const schema = (0, TypeUtils_1.matchTypeExhaustive)(t, _noneType => {
-            return (0, Support_1.panic)("none type should have been replaced");
-        }, _anyType => ({}), _nullType => ({ type: "null" }), _boolType => ({ type: "boolean" }), _integerType => ({ type: "integer" }), _doubleType => ({ type: "number" }), _stringType => ({ type: "string" }), arrayType => ({ type: "array", items: this.schemaForType(arrayType.items) }), classType => this.makeRef(classType), mapType => this.definitionForObject(mapType, undefined), objectType => this.makeRef(objectType), enumType => this.makeRef(enumType), unionType => {
-            if (this.unionNeedsName(unionType)) {
-                return this.makeRef(unionType);
-            }
-            else {
-                return this.definitionForUnion(unionType);
-            }
-        }, transformedStringType => {
-            const target = Type_1.transformedStringTypeTargetTypeKindsMap.get(transformedStringType.kind);
-            if (target === undefined) {
-                return (0, Support_1.panic)(`Unknown transformed string type ${transformedStringType.kind}`);
-            }
-            return { type: "string", format: target.jsonSchema };
-        });
-        if (schema.$ref === undefined) {
-            this.addAttributesToSchema(t, schema);
-        }
-        return schema;
-    }
-    definitionForObject(o, title) {
-        let properties;
-        let required;
-        if (o.getProperties().size === 0) {
-            properties = undefined;
-            required = undefined;
-        }
-        else {
-            const props = {};
-            const req = [];
-            for (const [name, p] of o.getProperties()) {
-                const prop = this.schemaForType(p.type);
-                if (prop.description === undefined) {
-                    (0, Description_1.addDescriptionToSchema)(prop, this.descriptionForClassProperty(o, name));
-                }
-                props[name] = prop;
-                if (!p.isOptional) {
-                    req.push(name);
-                }
-            }
-            properties = props;
-            required = req.sort();
-        }
-        const additional = o.getAdditionalProperties();
-        const additionalProperties = additional !== undefined ? this.schemaForType(additional) : false;
-        const schema = {
-            type: "object",
-            additionalProperties,
-            properties,
-            required,
-            title
-        };
-        this.addAttributesToSchema(o, schema);
-        return schema;
-    }
-    definitionForUnion(u, title) {
-        const oneOf = this.makeOneOf(u.sortedMembers);
-        if (title !== undefined) {
-            oneOf.title = title;
-        }
-        this.addAttributesToSchema(u, oneOf);
-        return oneOf;
-    }
-    definitionForEnum(e, title) {
-        const schema = { type: "string", enum: Array.from(e.cases), title };
-        this.addAttributesToSchema(e, schema);
-        return schema;
-    }
-    emitSourceStructure() {
-        // FIXME: Find a good way to do multiple top-levels.  Maybe multiple files?
-        const topLevelType = this.topLevels.size === 1 ? this.schemaForType((0, Support_1.defined)((0, collection_utils_1.mapFirst)(this.topLevels))) : {};
-        const schema = Object.assign({ $schema: "http://json-schema.org/draft-06/schema#" }, topLevelType);
-        const definitions = {};
-        this.forEachObject("none", (o, name) => {
-            const title = (0, Support_1.defined)(this.names.get(name));
-            definitions[title] = this.definitionForObject(o, title);
-        });
-        this.forEachUnion("none", (u, name) => {
-            if (!this.unionNeedsName(u))
-                return;
-            const title = (0, Support_1.defined)(this.names.get(name));
-            definitions[title] = this.definitionForUnion(u, title);
-        });
-        this.forEachEnum("none", (e, name) => {
-            const title = (0, Support_1.defined)(this.names.get(name));
-            definitions[title] = this.definitionForEnum(e, title);
-        });
-        schema.definitions = definitions;
-        this.emitMultiline(JSON.stringify(schema, undefined, "    "));
-    }
-}
-exports.JSONSchemaRenderer = JSONSchemaRenderer;