quicktype 18.0.6 → 19.0.5

package/dist/quicktype-core/input/CompressedJSON.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompressedJSONFromString = exports.CompressedJSON = exports.valueTag = exports.makeValue = exports.Tag = void 0;
-const collection_utils_1 = require("collection-utils");
-const Support_1 = require("../support/Support");
-const Type_1 = require("../Type");
-const StringTypes_1 = require("../attributes/StringTypes");
-var Tag;
-(function (Tag) {
-    Tag[Tag["Null"] = 0] = "Null";
-    Tag[Tag["False"] = 1] = "False";
-    Tag[Tag["True"] = 2] = "True";
-    Tag[Tag["Integer"] = 3] = "Integer";
-    Tag[Tag["Double"] = 4] = "Double";
-    Tag[Tag["InternedString"] = 5] = "InternedString";
-    Tag[Tag["UninternedString"] = 6] = "UninternedString";
-    Tag[Tag["Object"] = 7] = "Object";
-    Tag[Tag["Array"] = 8] = "Array";
-    Tag[Tag["StringFormat"] = 9] = "StringFormat";
-    Tag[Tag["TransformedString"] = 10] = "TransformedString";
-})(Tag = exports.Tag || (exports.Tag = {}));
-const TAG_BITS = 4;
-const TAG_MASK = (1 << TAG_BITS) - 1;
-function makeValue(t, index) {
-    return t | (index << TAG_BITS);
-}
-exports.makeValue = makeValue;
-function getIndex(v, tag) {
-    (0, Support_1.assert)(valueTag(v) === tag, "Trying to get index for value with invalid tag");
-    return v >> TAG_BITS;
-}
-function valueTag(v) {
-    return v & TAG_MASK;
-}
-exports.valueTag = valueTag;
-class CompressedJSON {
-    dateTimeRecognizer;
-    handleRefs;
-    _rootValue;
-    _ctx;
-    _contextStack = [];
-    _strings = [];
-    _stringIndexes = {};
-    _objects = [];
-    _arrays = [];
-    constructor(dateTimeRecognizer, handleRefs) {
-        this.dateTimeRecognizer = dateTimeRecognizer;
-        this.handleRefs = handleRefs;
-    }
-    parseSync(_input) {
-        return (0, Support_1.panic)("parseSync not implemented in CompressedJSON");
-    }
-    getStringForValue(v) {
-        const tag = valueTag(v);
-        (0, Support_1.assert)(tag === Tag.InternedString || tag === Tag.TransformedString);
-        return this._strings[getIndex(v, tag)];
-    }
-    getObjectForValue = (v) => {
-        return this._objects[getIndex(v, Tag.Object)];
-    };
-    getArrayForValue = (v) => {
-        return this._arrays[getIndex(v, Tag.Array)];
-    };
-    getStringFormatTypeKind(v) {
-        const kind = this._strings[getIndex(v, Tag.StringFormat)];
-        if (!(0, Type_1.isPrimitiveStringTypeKind)(kind) || kind === "string") {
-            return (0, Support_1.panic)("Not a transformed string type kind");
-        }
-        return kind;
-    }
-    get context() {
-        return (0, Support_1.defined)(this._ctx);
-    }
-    internString(s) {
-        if (Object.prototype.hasOwnProperty.call(this._stringIndexes, s)) {
-            return this._stringIndexes[s];
-        }
-        const index = this._strings.length;
-        this._strings.push(s);
-        this._stringIndexes[s] = index;
-        return index;
-    }
-    makeString(s) {
-        const value = makeValue(Tag.InternedString, this.internString(s));
-        (0, Support_1.assert)(typeof value === "number", `Interned string value is not a number: ${value}`);
-        return value;
-    }
-    internObject(obj) {
-        const index = this._objects.length;
-        this._objects.push(obj);
-        return makeValue(Tag.Object, index);
-    }
-    internArray = (arr) => {
-        const index = this._arrays.length;
-        this._arrays.push(arr);
-        return makeValue(Tag.Array, index);
-    };
-    get isExpectingRef() {
-        return this._ctx !== undefined && this._ctx.currentKey === "$ref";
-    }
-    commitValue(value) {
-        (0, Support_1.assert)(typeof value === "number", `CompressedJSON value is not a number: ${value}`);
-        if (this._ctx === undefined) {
-            (0, Support_1.assert)(this._rootValue === undefined, "Committing value but nowhere to commit to - root value still there.");
-            this._rootValue = value;
-        }
-        else if (this._ctx.currentObject !== undefined) {
-            if (this._ctx.currentKey === undefined) {
-                return (0, Support_1.panic)("Must have key and can't have string when committing");
-            }
-            this._ctx.currentObject.push(this.makeString(this._ctx.currentKey), value);
-            this._ctx.currentKey = undefined;
-        }
-        else if (this._ctx.currentArray !== undefined) {
-            this._ctx.currentArray.push(value);
-        }
-        else {
-            return (0, Support_1.panic)("Committing value but nowhere to commit to");
-        }
-    }
-    commitNull() {
-        this.commitValue(makeValue(Tag.Null, 0));
-    }
-    commitBoolean(v) {
-        this.commitValue(makeValue(v ? Tag.True : Tag.False, 0));
-    }
-    commitNumber(isDouble) {
-        const numberTag = isDouble ? Tag.Double : Tag.Integer;
-        this.commitValue(makeValue(numberTag, 0));
-    }
-    commitString(s) {
-        let value = undefined;
-        if (this.handleRefs && this.isExpectingRef) {
-            value = this.makeString(s);
-        }
-        else {
-            const format = (0, StringTypes_1.inferTransformedStringTypeKindForString)(s, this.dateTimeRecognizer);
-            if (format !== undefined) {
-                if ((0, Support_1.defined)(Type_1.transformedStringTypeTargetTypeKindsMap.get(format)).attributesProducer !== undefined) {
-                    value = makeValue(Tag.TransformedString, this.internString(s));
-                }
-                else {
-                    value = makeValue(Tag.StringFormat, this.internString(format));
-                }
-            }
-            else if (s.length <= 64) {
-                value = this.makeString(s);
-            }
-            else {
-                value = makeValue(Tag.UninternedString, 0);
-            }
-        }
-        this.commitValue(value);
-    }
-    finish() {
-        const value = this._rootValue;
-        if (value === undefined) {
-            return (0, Support_1.panic)("Finished without root document");
-        }
-        (0, Support_1.assert)(this._ctx === undefined && this._contextStack.length === 0, "Finished with contexts present");
-        this._rootValue = undefined;
-        return value;
-    }
-    pushContext() {
-        if (this._ctx !== undefined) {
-            this._contextStack.push(this._ctx);
-        }
-        this._ctx = {
-            currentObject: undefined,
-            currentArray: undefined,
-            currentKey: undefined,
-            currentNumberIsDouble: false
-        };
-    }
-    pushObjectContext() {
-        this.pushContext();
-        (0, Support_1.defined)(this._ctx).currentObject = [];
-    }
-    setPropertyKey(key) {
-        const ctx = this.context;
-        ctx.currentKey = key;
-    }
-    finishObject() {
-        const obj = this.context.currentObject;
-        if (obj === undefined) {
-            return (0, Support_1.panic)("Object ended but not started");
-        }
-        this.popContext();
-        this.commitValue(this.internObject(obj));
-    }
-    pushArrayContext() {
-        this.pushContext();
-        (0, Support_1.defined)(this._ctx).currentArray = [];
-    }
-    finishArray() {
-        const arr = this.context.currentArray;
-        if (arr === undefined) {
-            return (0, Support_1.panic)("Array ended but not started");
-        }
-        this.popContext();
-        this.commitValue(this.internArray(arr));
-    }
-    popContext() {
-        (0, Support_1.assert)(this._ctx !== undefined, "Popping context when there isn't one");
-        this._ctx = this._contextStack.pop();
-    }
-    equals(other) {
-        return this === other;
-    }
-    hashCode() {
-        let hashAccumulator = collection_utils_1.hashCodeInit;
-        for (const s of this._strings) {
-            hashAccumulator = (0, collection_utils_1.addHashCode)(hashAccumulator, (0, collection_utils_1.hashString)(s));
-        }
-        for (const s of Object.getOwnPropertyNames(this._stringIndexes).sort()) {
-            hashAccumulator = (0, collection_utils_1.addHashCode)(hashAccumulator, (0, collection_utils_1.hashString)(s));
-            hashAccumulator = (0, collection_utils_1.addHashCode)(hashAccumulator, this._stringIndexes[s]);
-        }
-        for (const o of this._objects) {
-            for (const v of o) {
-                hashAccumulator = (0, collection_utils_1.addHashCode)(hashAccumulator, v);
-            }
-        }
-        for (const o of this._arrays) {
-            for (const v of o) {
-                hashAccumulator = (0, collection_utils_1.addHashCode)(hashAccumulator, v);
-            }
-        }
-        return hashAccumulator;
-    }
-}
-exports.CompressedJSON = CompressedJSON;
-class CompressedJSONFromString extends CompressedJSON {
-    async parse(input) {
-        return this.parseSync(input);
-    }
-    parseSync(input) {
-        const json = JSON.parse(input);
-        this.process(json);
-        return this.finish();
-    }
-    process(json) {
-        if (json === null) {
-            this.commitNull();
-        }
-        else if (typeof json === "boolean") {
-            this.commitBoolean(json);
-        }
-        else if (typeof json === "string") {
-            this.commitString(json);
-        }
-        else if (typeof json === "number") {
-            const isDouble = json !== Math.floor(json) || json < Number.MIN_SAFE_INTEGER || json > Number.MAX_SAFE_INTEGER;
-            this.commitNumber(isDouble);
-        }
-        else if (Array.isArray(json)) {
-            this.pushArrayContext();
-            for (const v of json) {
-                this.process(v);
-            }
-            this.finishArray();
-        }
-        else if (typeof json === "object") {
-            this.pushObjectContext();
-            for (const key of Object.getOwnPropertyNames(json)) {
-                this.setPropertyKey(key);
-                this.process(json[key]);
-            }
-            this.finishObject();
-        }
-        else {
-            return (0, Support_1.panic)("Invalid JSON object");
-        }
-    }
-}
-exports.CompressedJSONFromString = CompressedJSONFromString;

package/dist/quicktype-core/input/FetchingJSONSchemaStore.d.ts

@@ -1,6 +0,0 @@
-import { JSONSchema, JSONSchemaStore } from "./JSONSchemaStore";
-export declare class FetchingJSONSchemaStore extends JSONSchemaStore {
-    private readonly _httpHeaders?;
-    constructor(_httpHeaders?: string[] | undefined);
-    fetch(address: string): Promise<JSONSchema | undefined>;
-}

package/dist/quicktype-core/input/FetchingJSONSchemaStore.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FetchingJSONSchemaStore = void 0;
-const JSONSchemaStore_1 = require("./JSONSchemaStore");
-const __1 = require("..");
-const NodeIO_1 = require("./io/NodeIO");
-class FetchingJSONSchemaStore extends JSONSchemaStore_1.JSONSchemaStore {
-    _httpHeaders;
-    constructor(_httpHeaders) {
-        super();
-        this._httpHeaders = _httpHeaders;
-    }
-    async fetch(address) {
-        // console.log(`Fetching ${address}`);
-        return (0, __1.parseJSON)(await (0, NodeIO_1.readFromFileOrURL)(address, this._httpHeaders), "JSON Schema", address);
-    }
-}
-exports.FetchingJSONSchemaStore = FetchingJSONSchemaStore;

package/dist/quicktype-core/input/Inference.d.ts

@@ -1,22 +0,0 @@
-import { CompressedJSON } from "./CompressedJSON";
-import { TypeBuilder } from "../TypeBuilder";
-import { UnionAccumulator } from "../UnionBuilder";
-import { TypeAttributes } from "../attributes/TypeAttributes";
-import { TypeRef } from "../TypeGraph";
-export type NestedValueArray = any;
-export type Accumulator = UnionAccumulator<NestedValueArray, NestedValueArray>;
-export declare class TypeInference {
-    private readonly _cjson;
-    private readonly _typeBuilder;
-    private readonly _inferMaps;
-    private readonly _inferEnums;
-    private _refIntersections;
-    constructor(_cjson: CompressedJSON<unknown>, _typeBuilder: TypeBuilder, _inferMaps: boolean, _inferEnums: boolean);
-    addValuesToAccumulator(valueArray: NestedValueArray, accumulator: Accumulator): void;
-    inferType(typeAttributes: TypeAttributes, valueArray: NestedValueArray, fixed: boolean, forwardingRef?: TypeRef): TypeRef;
-    private resolveRef;
-    inferTopLevelType(typeAttributes: TypeAttributes, valueArray: NestedValueArray, fixed: boolean): TypeRef;
-    accumulatorForArray(valueArray: NestedValueArray): Accumulator;
-    makeTypeFromAccumulator(accumulator: Accumulator, typeAttributes: TypeAttributes, fixed: boolean, forwardingRef?: TypeRef): TypeRef;
-    inferClassType(typeAttributes: TypeAttributes, objects: NestedValueArray, fixed: boolean, forwardingRef?: TypeRef): TypeRef;
-}

package/dist/quicktype-core/input/Inference.js

@@ -1,240 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeInference = void 0;
-const CompressedJSON_1 = require("./CompressedJSON");
-const Support_1 = require("../support/Support");
-const UnionBuilder_1 = require("../UnionBuilder");
-const Type_1 = require("../Type");
-const TypeAttributes_1 = require("../attributes/TypeAttributes");
-const StringTypes_1 = require("../attributes/StringTypes");
-const TypeGraph_1 = require("../TypeGraph");
-const Messages_1 = require("../Messages");
-const TypeUtils_1 = require("../TypeUtils");
-function forEachArrayInNestedValueArray(va, f) {
-    if (va.length === 0) {
-        return;
-    }
-    if (Array.isArray(va[0])) {
-        for (const x of va) {
-            forEachArrayInNestedValueArray(x, f);
-        }
-    }
-    else {
-        f(va);
-    }
-}
-function forEachValueInNestedValueArray(va, f) {
-    forEachArrayInNestedValueArray(va, a => {
-        for (const x of a) {
-            f(x);
-        }
-    });
-}
-class InferenceUnionBuilder extends UnionBuilder_1.UnionBuilder {
-    _typeInference;
-    _fixed;
-    constructor(typeBuilder, _typeInference, _fixed) {
-        super(typeBuilder);
-        this._typeInference = _typeInference;
-        this._fixed = _fixed;
-    }
-    makeObject(objects, typeAttributes, forwardingRef) {
-        return this._typeInference.inferClassType(typeAttributes, objects, this._fixed, forwardingRef);
-    }
-    makeArray(arrays, typeAttributes, forwardingRef) {
-        return this.typeBuilder.getArrayType(typeAttributes, this._typeInference.inferType(TypeAttributes_1.emptyTypeAttributes, arrays, this._fixed, forwardingRef));
-    }
-}
-function canBeEnumCase(_s) {
-    return true;
-}
-class TypeInference {
-    _cjson;
-    _typeBuilder;
-    _inferMaps;
-    _inferEnums;
-    _refIntersections;
-    constructor(_cjson, _typeBuilder, _inferMaps, _inferEnums) {
-        this._cjson = _cjson;
-        this._typeBuilder = _typeBuilder;
-        this._inferMaps = _inferMaps;
-        this._inferEnums = _inferEnums;
-    }
-    addValuesToAccumulator(valueArray, accumulator) {
-        forEachValueInNestedValueArray(valueArray, value => {
-            const t = (0, CompressedJSON_1.valueTag)(value);
-            switch (t) {
-                case CompressedJSON_1.Tag.Null:
-                    accumulator.addPrimitive("null", TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.False:
-                case CompressedJSON_1.Tag.True:
-                    accumulator.addPrimitive("bool", TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.Integer:
-                    accumulator.addPrimitive("integer", TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.Double:
-                    accumulator.addPrimitive("double", TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.InternedString:
-                    if (this._inferEnums) {
-                        const s = this._cjson.getStringForValue(value);
-                        if (canBeEnumCase(s)) {
-                            accumulator.addStringCase(s, 1, TypeAttributes_1.emptyTypeAttributes);
-                        }
-                        else {
-                            accumulator.addStringType("string", TypeAttributes_1.emptyTypeAttributes);
-                        }
-                    }
-                    else {
-                        accumulator.addStringType("string", TypeAttributes_1.emptyTypeAttributes);
-                    }
-                    break;
-                case CompressedJSON_1.Tag.UninternedString:
-                    accumulator.addStringType("string", TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.Object:
-                    accumulator.addObject(this._cjson.getObjectForValue(value), TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.Array:
-                    accumulator.addArray(this._cjson.getArrayForValue(value), TypeAttributes_1.emptyTypeAttributes);
-                    break;
-                case CompressedJSON_1.Tag.StringFormat: {
-                    const kind = this._cjson.getStringFormatTypeKind(value);
-                    accumulator.addStringType("string", TypeAttributes_1.emptyTypeAttributes, new StringTypes_1.StringTypes(new Map(), new Set([kind])));
-                    break;
-                }
-                case CompressedJSON_1.Tag.TransformedString: {
-                    const s = this._cjson.getStringForValue(value);
-                    const kind = (0, StringTypes_1.inferTransformedStringTypeKindForString)(s, this._cjson.dateTimeRecognizer);
-                    if (kind === undefined) {
-                        return (0, Support_1.panic)("TransformedString does not have a kind");
-                    }
-                    const producer = (0, Support_1.defined)(Type_1.transformedStringTypeTargetTypeKindsMap.get(kind)).attributesProducer;
-                    if (producer === undefined) {
-                        return (0, Support_1.panic)("TransformedString does not have attribute producer");
-                    }
-                    accumulator.addStringType("string", producer(s), new StringTypes_1.StringTypes(new Map(), new Set([kind])));
-                    break;
-                }
-                default:
-                    return (0, Support_1.assertNever)(t);
-            }
-        });
-    }
-    inferType(typeAttributes, valueArray, fixed, forwardingRef) {
-        const accumulator = this.accumulatorForArray(valueArray);
-        return this.makeTypeFromAccumulator(accumulator, typeAttributes, fixed, forwardingRef);
-    }
-    resolveRef(ref, topLevel) {
-        if (!ref.startsWith("#/")) {
-            return (0, Messages_1.messageError)("InferenceJSONReferenceNotRooted", { reference: ref });
-        }
-        const parts = ref.split("/").slice(1);
-        const graph = this._typeBuilder.typeGraph;
-        let tref = topLevel;
-        for (const part of parts) {
-            let t = (0, TypeGraph_1.derefTypeRef)(tref, graph);
-            if (t instanceof Type_1.UnionType) {
-                const nullable = (0, TypeUtils_1.nullableFromUnion)(t);
-                if (nullable === null) {
-                    // FIXME: handle unions
-                    return (0, Messages_1.messageError)("InferenceJSONReferenceToUnion", { reference: ref });
-                }
-                t = nullable;
-            }
-            if (t instanceof Type_1.ClassType) {
-                const cp = t.getProperties().get(part);
-                if (cp === undefined) {
-                    return (0, Messages_1.messageError)("InferenceJSONReferenceWrongProperty", { reference: ref });
-                }
-                tref = cp.typeRef;
-            }
-            else if (t instanceof Type_1.MapType) {
-                tref = t.values.typeRef;
-            }
-            else if (t instanceof Type_1.ArrayType) {
-                if (part.match("^[0-9]+$") === null) {
-                    return (0, Messages_1.messageError)("InferenceJSONReferenceInvalidArrayIndex", { reference: ref });
-                }
-                tref = t.items.typeRef;
-            }
-            else {
-                return (0, Messages_1.messageError)("InferenceJSONReferenceWrongProperty", { reference: ref });
-            }
-        }
-        return tref;
-    }
-    inferTopLevelType(typeAttributes, valueArray, fixed) {
-        (0, Support_1.assert)(this._refIntersections === undefined, "Didn't reset ref intersections - nested invocations?");
-        if (this._cjson.handleRefs) {
-            this._refIntersections = [];
-        }
-        const topLevel = this.inferType(typeAttributes, valueArray, fixed);
-        if (this._cjson.handleRefs) {
-            for (const [tref, refs] of (0, Support_1.defined)(this._refIntersections)) {
-                const resolved = refs.map(r => this.resolveRef(r, topLevel));
-                this._typeBuilder.setSetOperationMembers(tref, new Set(resolved));
-            }
-            this._refIntersections = undefined;
-        }
-        return topLevel;
-    }
-    accumulatorForArray(valueArray) {
-        const accumulator = new UnionBuilder_1.UnionAccumulator(true);
-        this.addValuesToAccumulator(valueArray, accumulator);
-        return accumulator;
-    }
-    makeTypeFromAccumulator(accumulator, typeAttributes, fixed, forwardingRef) {
-        const unionBuilder = new InferenceUnionBuilder(this._typeBuilder, this, fixed);
-        return unionBuilder.buildUnion(accumulator, false, typeAttributes, forwardingRef);
-    }
-    inferClassType(typeAttributes, objects, fixed, forwardingRef) {
-        const propertyNames = [];
-        const propertyValues = {};
-        forEachArrayInNestedValueArray(objects, arr => {
-            for (let i = 0; i < arr.length; i += 2) {
-                const key = this._cjson.getStringForValue(arr[i]);
-                const value = arr[i + 1];
-                if (!Object.prototype.hasOwnProperty.call(propertyValues, key)) {
-                    propertyNames.push(key);
-                    propertyValues[key] = [];
-                }
-                propertyValues[key].push(value);
-            }
-        });
-        if (this._cjson.handleRefs && propertyNames.length === 1 && propertyNames[0] === "$ref") {
-            const values = propertyValues["$ref"];
-            if (values.every(v => (0, CompressedJSON_1.valueTag)(v) === CompressedJSON_1.Tag.InternedString)) {
-                const allRefs = values.map(v => this._cjson.getStringForValue(v));
-                // FIXME: Add is-ref attribute
-                const tref = this._typeBuilder.getUniqueIntersectionType(typeAttributes, undefined);
-                (0, Support_1.defined)(this._refIntersections).push([tref, allRefs]);
-                return tref;
-            }
-        }
-        if (this._inferMaps && propertyNames.length > 500) {
-            const accumulator = new UnionBuilder_1.UnionAccumulator(true);
-            for (const key of propertyNames) {
-                this.addValuesToAccumulator(propertyValues[key], accumulator);
-            }
-            const values = this.makeTypeFromAccumulator(accumulator, TypeAttributes_1.emptyTypeAttributes, fixed);
-            return this._typeBuilder.getMapType(typeAttributes, values, forwardingRef);
-        }
-        const properties = new Map();
-        for (const key of propertyNames) {
-            const values = propertyValues[key];
-            const t = this.inferType(TypeAttributes_1.emptyTypeAttributes, values, false);
-            const isOptional = values.length < objects.length;
-            properties.set(key, this._typeBuilder.makeClassProperty(t, isOptional));
-        }
-        if (fixed) {
-            return this._typeBuilder.getUniqueClassType(typeAttributes, true, properties, forwardingRef);
-        }
-        else {
-            return this._typeBuilder.getClassType(typeAttributes, properties, forwardingRef);
-        }
-    }
-}
-exports.TypeInference = TypeInference;

package/dist/quicktype-core/input/Inputs.d.ts

@@ -1,48 +0,0 @@
-import { CompressedJSON } from "./CompressedJSON";
-import { TypeBuilder } from "../TypeBuilder";
-import { TargetLanguage } from "../TargetLanguage";
-import { RunContext } from "../Run";
-export interface Input<T> {
-    readonly kind: string;
-    readonly needIR: boolean;
-    readonly needSchemaProcessing: boolean;
-    addSource(source: T): Promise<void>;
-    addSourceSync(source: T): void;
-    singleStringSchemaSource(): string | undefined;
-    addTypes(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): Promise<void>;
-    addTypesSync(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): void;
-}
-export interface JSONSourceData<T> {
-    name: string;
-    samples: T[];
-    description?: string;
-}
-export declare class JSONInput<T> implements Input<JSONSourceData<T>> {
-    private readonly _compressedJSON;
-    readonly kind: string;
-    readonly needIR: boolean;
-    readonly needSchemaProcessing: boolean;
-    private readonly _topLevels;
-    constructor(_compressedJSON: CompressedJSON<T>);
-    private addSample;
-    private setDescription;
-    private addSamples;
-    addSource(source: JSONSourceData<T>): Promise<void>;
-    addSourceSync(source: JSONSourceData<T>): void;
-    singleStringSchemaSource(): undefined;
-    addTypes(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): Promise<void>;
-    addTypesSync(_ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): void;
-}
-export declare function jsonInputForTargetLanguage(targetLanguage: string | TargetLanguage, languages?: TargetLanguage[], handleJSONRefs?: boolean): JSONInput<string>;
-export declare class InputData {
-    private _inputs;
-    addInput<T>(input: Input<T>): void;
-    private getOrAddInput;
-    addSource<T>(kind: string, source: T, makeInput: () => Input<T>): Promise<void>;
-    addSourceSync<T>(kind: string, source: T, makeInput: () => Input<T>): void;
-    addTypes(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): Promise<void>;
-    addTypesSync(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): void;
-    get needIR(): boolean;
-    get needSchemaProcessing(): boolean;
-    singleStringSchemaSource(): string | undefined;
-}