quicktype 18.0.5 → 19.0.4

package/dist/quicktype-core/attributes/AccessorNames.js

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.accessorNamesAttributeProducer = exports.makeAccessorNames = exports.unionMemberName = exports.makeUnionMemberNamesAttribute = exports.unionMemberNamesTypeAttributeKind = exports.makeUnionIdentifierAttribute = exports.unionIdentifierTypeAttributeKind = exports.getAccessorName = exports.enumCaseNames = exports.objectPropertyNames = exports.lookupKey = exports.accessorNamesTypeAttributeKind = void 0;
-const collection_utils_1 = require("collection-utils");
-const TypeAttributes_1 = require("./TypeAttributes");
-const Support_1 = require("../support/Support");
-const Messages_1 = require("../Messages");
-class AccessorNamesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("accessorNames");
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-}
-exports.accessorNamesTypeAttributeKind = new AccessorNamesTypeAttributeKind();
-// Returns [name, isFixed].
-function getFromEntry(entry, language) {
-    if (typeof entry === "string")
-        return [entry, false];
-    const maybeForLanguage = entry.get(language);
-    if (maybeForLanguage !== undefined)
-        return [maybeForLanguage, true];
-    const maybeWildcard = entry.get("*");
-    if (maybeWildcard !== undefined)
-        return [maybeWildcard, false];
-    return undefined;
-}
-function lookupKey(accessors, key, language) {
-    const entry = accessors.get(key);
-    if (entry === undefined)
-        return undefined;
-    return getFromEntry(entry, language);
-}
-exports.lookupKey = lookupKey;
-function objectPropertyNames(o, language) {
-    const accessors = exports.accessorNamesTypeAttributeKind.tryGetInAttributes(o.getAttributes());
-    const map = o.getProperties();
-    if (accessors === undefined)
-        return (0, collection_utils_1.mapMap)(map, _ => undefined);
-    return (0, collection_utils_1.mapMap)(map, (_cp, n) => lookupKey(accessors, n, language));
-}
-exports.objectPropertyNames = objectPropertyNames;
-function enumCaseNames(e, language) {
-    const accessors = exports.accessorNamesTypeAttributeKind.tryGetInAttributes(e.getAttributes());
-    if (accessors === undefined)
-        return (0, collection_utils_1.mapMap)(e.cases.entries(), _ => undefined);
-    return (0, collection_utils_1.mapMap)(e.cases.entries(), c => lookupKey(accessors, c, language));
-}
-exports.enumCaseNames = enumCaseNames;
-function getAccessorName(names, original) {
-    const maybeName = names.get(original);
-    if (maybeName === undefined)
-        return [undefined, false];
-    return maybeName;
-}
-exports.getAccessorName = getAccessorName;
-// Union members can be recombined and reordered, and unions are combined as well, so
-// we can't just store an array of accessor entries in a union, one array entry for each
-// union member.  Instead, we give each union in the origin type graph a union identifier,
-// and each union member type gets a map from union identifiers to accessor entries.
-// That way, no matter how the types are recombined, if we find a union member, we can look
-// up its union's identifier(s), and then look up the member's accessor entries for that
-// identifier.  Of course we might find more than one, potentially conflicting.
-class UnionIdentifierTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("unionIdentifier");
-    }
-    combine(arr) {
-        return (0, collection_utils_1.setUnionManyInto)(new Set(), arr);
-    }
-    makeInferred(_) {
-        return new Set();
-    }
-}
-exports.unionIdentifierTypeAttributeKind = new UnionIdentifierTypeAttributeKind();
-let nextUnionIdentifier = 0;
-function makeUnionIdentifierAttribute() {
-    const attributes = exports.unionIdentifierTypeAttributeKind.makeAttributes(new Set([nextUnionIdentifier]));
-    nextUnionIdentifier += 1;
-    return attributes;
-}
-exports.makeUnionIdentifierAttribute = makeUnionIdentifierAttribute;
-class UnionMemberNamesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("unionMemberNames");
-    }
-    combine(arr) {
-        const result = new Map();
-        for (const m of arr) {
-            (0, collection_utils_1.mapMergeInto)(result, m);
-        }
-        return result;
-    }
-}
-exports.unionMemberNamesTypeAttributeKind = new UnionMemberNamesTypeAttributeKind();
-function makeUnionMemberNamesAttribute(unionAttributes, entry) {
-    const identifiers = (0, Support_1.defined)(exports.unionIdentifierTypeAttributeKind.tryGetInAttributes(unionAttributes));
-    const map = (0, collection_utils_1.mapFromIterable)(identifiers, _ => entry);
-    return exports.unionMemberNamesTypeAttributeKind.makeAttributes(map);
-}
-exports.makeUnionMemberNamesAttribute = makeUnionMemberNamesAttribute;
-function unionMemberName(u, member, language) {
-    const identifiers = exports.unionIdentifierTypeAttributeKind.tryGetInAttributes(u.getAttributes());
-    if (identifiers === undefined)
-        return [undefined, false];
-    const memberNames = exports.unionMemberNamesTypeAttributeKind.tryGetInAttributes(member.getAttributes());
-    if (memberNames === undefined)
-        return [undefined, false];
-    const names = new Set();
-    const fixedNames = new Set();
-    for (const i of identifiers) {
-        const maybeEntry = memberNames.get(i);
-        if (maybeEntry === undefined)
-            continue;
-        const maybeName = getFromEntry(maybeEntry, language);
-        if (maybeName === undefined)
-            continue;
-        const [name, isNameFixed] = maybeName;
-        if (isNameFixed) {
-            fixedNames.add(name);
-        }
-        else {
-            names.add(name);
-        }
-    }
-    let size;
-    let isFixed;
-    let first = (0, collection_utils_1.iterableFirst)(fixedNames);
-    if (first !== undefined) {
-        size = fixedNames.size;
-        isFixed = true;
-    }
-    else {
-        first = (0, collection_utils_1.iterableFirst)(names);
-        if (first === undefined)
-            return [undefined, false];
-        size = names.size;
-        isFixed = false;
-    }
-    (0, Messages_1.messageAssert)(size === 1, "SchemaMoreThanOneUnionMemberName", { names: Array.from(names) });
-    return [first, isFixed];
-}
-exports.unionMemberName = unionMemberName;
-function isAccessorEntry(x) {
-    if (typeof x === "string") {
-        return true;
-    }
-    return (0, Support_1.isStringMap)(x, (v) => typeof v === "string");
-}
-function makeAccessorEntry(ae) {
-    if (typeof ae === "string")
-        return ae;
-    return (0, collection_utils_1.mapFromObject)(ae);
-}
-function makeAccessorNames(x) {
-    // FIXME: Do proper error reporting
-    const stringMap = (0, Support_1.checkStringMap)(x, isAccessorEntry);
-    return (0, collection_utils_1.mapMap)((0, collection_utils_1.mapFromObject)(stringMap), makeAccessorEntry);
-}
-exports.makeAccessorNames = makeAccessorNames;
-function accessorNamesAttributeProducer(schema, canonicalRef, _types, cases) {
-    if (typeof schema !== "object")
-        return undefined;
-    const maybeAccessors = schema["qt-accessors"];
-    if (maybeAccessors === undefined)
-        return undefined;
-    if (cases === undefined) {
-        return { forType: exports.accessorNamesTypeAttributeKind.makeAttributes(makeAccessorNames(maybeAccessors)) };
-    }
-    else {
-        const identifierAttribute = makeUnionIdentifierAttribute();
-        const accessors = (0, Support_1.checkArray)(maybeAccessors, isAccessorEntry);
-        (0, Messages_1.messageAssert)(cases.length === accessors.length, "SchemaWrongAccessorEntryArrayLength", {
-            operation: "oneOf",
-            ref: canonicalRef.push("oneOf")
-        });
-        const caseAttributes = accessors.map(accessor => makeUnionMemberNamesAttribute(identifierAttribute, makeAccessorEntry(accessor)));
-        return { forUnion: identifierAttribute, forCases: caseAttributes };
-    }
-}
-exports.accessorNamesAttributeProducer = accessorNamesAttributeProducer;

package/dist/quicktype-core/attributes/Constraints.d.ts

@@ -1,38 +0,0 @@
-import { Type, TypeKind } from "../Type";
-import { TypeAttributeKind } from "./TypeAttributes";
-import { JSONSchemaType, JSONSchemaAttributes, Ref } from "../input/JSONSchemaInput";
-import { JSONSchema } from "../input/JSONSchemaStore";
-export type MinMaxConstraint = [number | undefined, number | undefined];
-export declare class MinMaxConstraintTypeAttributeKind extends TypeAttributeKind<MinMaxConstraint> {
-    private _typeKinds;
-    private _minSchemaProperty;
-    private _maxSchemaProperty;
-    constructor(name: string, _typeKinds: Set<TypeKind>, _minSchemaProperty: string, _maxSchemaProperty: string);
-    get inIdentity(): boolean;
-    combine(arr: MinMaxConstraint[]): MinMaxConstraint | undefined;
-    intersect(arr: MinMaxConstraint[]): MinMaxConstraint | undefined;
-    makeInferred(_: MinMaxConstraint): undefined;
-    addToSchema(schema: {
-        [name: string]: unknown;
-    }, t: Type, attr: MinMaxConstraint): void;
-    stringify([min, max]: MinMaxConstraint): string;
-}
-export declare const minMaxTypeAttributeKind: TypeAttributeKind<MinMaxConstraint>;
-export declare const minMaxLengthTypeAttributeKind: TypeAttributeKind<MinMaxConstraint>;
-export declare function minMaxAttributeProducer(schema: JSONSchema, _ref: Ref, types: Set<JSONSchemaType>): JSONSchemaAttributes | undefined;
-export declare function minMaxLengthAttributeProducer(schema: JSONSchema, _ref: Ref, types: Set<JSONSchemaType>): JSONSchemaAttributes | undefined;
-export declare function minMaxValueForType(t: Type): MinMaxConstraint | undefined;
-export declare function minMaxLengthForType(t: Type): MinMaxConstraint | undefined;
-export declare class PatternTypeAttributeKind extends TypeAttributeKind<string> {
-    constructor();
-    get inIdentity(): boolean;
-    combine(arr: string[]): string;
-    intersect(_arr: string[]): string | undefined;
-    makeInferred(_: string): undefined;
-    addToSchema(schema: {
-        [name: string]: unknown;
-    }, t: Type, attr: string): void;
-}
-export declare const patternTypeAttributeKind: TypeAttributeKind<string>;
-export declare function patternAttributeProducer(schema: JSONSchema, _ref: Ref, types: Set<JSONSchemaType>): JSONSchemaAttributes | undefined;
-export declare function patternForType(t: Type): string | undefined;

package/dist/quicktype-core/attributes/Constraints.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patternForType = exports.patternAttributeProducer = exports.patternTypeAttributeKind = exports.PatternTypeAttributeKind = exports.minMaxLengthForType = exports.minMaxValueForType = exports.minMaxLengthAttributeProducer = exports.minMaxAttributeProducer = exports.minMaxLengthTypeAttributeKind = exports.minMaxTypeAttributeKind = exports.MinMaxConstraintTypeAttributeKind = void 0;
-const TypeAttributes_1 = require("./TypeAttributes");
-const Support_1 = require("../support/Support");
-const Messages_1 = require("../Messages");
-function checkMinMaxConstraint(minmax) {
-    const [min, max] = minmax;
-    if (typeof min === "number" && typeof max === "number" && min > max) {
-        return (0, Messages_1.messageError)("MiscInvalidMinMaxConstraint", { min, max });
-    }
-    if (min === undefined && max === undefined) {
-        return undefined;
-    }
-    return minmax;
-}
-class MinMaxConstraintTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    _typeKinds;
-    _minSchemaProperty;
-    _maxSchemaProperty;
-    constructor(name, _typeKinds, _minSchemaProperty, _maxSchemaProperty) {
-        super(name);
-        this._typeKinds = _typeKinds;
-        this._minSchemaProperty = _minSchemaProperty;
-        this._maxSchemaProperty = _maxSchemaProperty;
-    }
-    get inIdentity() {
-        return true;
-    }
-    combine(arr) {
-        (0, Support_1.assert)(arr.length > 0);
-        let [min, max] = arr[0];
-        for (let i = 1; i < arr.length; i++) {
-            const [otherMin, otherMax] = arr[i];
-            if (typeof min === "number" && typeof otherMin === "number") {
-                min = Math.min(min, otherMin);
-            }
-            else {
-                min = undefined;
-            }
-            if (typeof max === "number" && typeof otherMax === "number") {
-                max = Math.max(max, otherMax);
-            }
-            else {
-                max = undefined;
-            }
-        }
-        return checkMinMaxConstraint([min, max]);
-    }
-    intersect(arr) {
-        (0, Support_1.assert)(arr.length > 0);
-        let [min, max] = arr[0];
-        for (let i = 1; i < arr.length; i++) {
-            const [otherMin, otherMax] = arr[i];
-            if (typeof min === "number" && typeof otherMin === "number") {
-                min = Math.max(min, otherMin);
-            }
-            else if (min === undefined) {
-                min = otherMin;
-            }
-            if (typeof max === "number" && typeof otherMax === "number") {
-                max = Math.min(max, otherMax);
-            }
-            else if (max === undefined) {
-                max = otherMax;
-            }
-        }
-        return checkMinMaxConstraint([min, max]);
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-    addToSchema(schema, t, attr) {
-        if (this._typeKinds.has(t.kind))
-            return;
-        const [min, max] = attr;
-        if (min !== undefined) {
-            schema[this._minSchemaProperty] = min;
-        }
-        if (max !== undefined) {
-            schema[this._maxSchemaProperty] = max;
-        }
-    }
-    stringify([min, max]) {
-        return `${min}-${max}`;
-    }
-}
-exports.MinMaxConstraintTypeAttributeKind = MinMaxConstraintTypeAttributeKind;
-exports.minMaxTypeAttributeKind = new MinMaxConstraintTypeAttributeKind("minMax", new Set(["integer", "double"]), "minimum", "maximum");
-exports.minMaxLengthTypeAttributeKind = new MinMaxConstraintTypeAttributeKind("minMaxLength", new Set(["string"]), "minLength", "maxLength");
-function producer(schema, minProperty, maxProperty) {
-    if (!(typeof schema === "object"))
-        return undefined;
-    let min = undefined;
-    let max = undefined;
-    if (typeof schema[minProperty] === "number") {
-        min = schema[minProperty];
-    }
-    if (typeof schema[maxProperty] === "number") {
-        max = schema[maxProperty];
-    }
-    if (min === undefined && max === undefined)
-        return undefined;
-    return [min, max];
-}
-function minMaxAttributeProducer(schema, _ref, types) {
-    if (!types.has("number") && !types.has("integer"))
-        return undefined;
-    const maybeMinMax = producer(schema, "minimum", "maximum");
-    if (maybeMinMax === undefined)
-        return undefined;
-    return { forNumber: exports.minMaxTypeAttributeKind.makeAttributes(maybeMinMax) };
-}
-exports.minMaxAttributeProducer = minMaxAttributeProducer;
-function minMaxLengthAttributeProducer(schema, _ref, types) {
-    if (!types.has("string"))
-        return undefined;
-    const maybeMinMaxLength = producer(schema, "minLength", "maxLength");
-    if (maybeMinMaxLength === undefined)
-        return undefined;
-    return { forString: exports.minMaxLengthTypeAttributeKind.makeAttributes(maybeMinMaxLength) };
-}
-exports.minMaxLengthAttributeProducer = minMaxLengthAttributeProducer;
-function minMaxValueForType(t) {
-    return exports.minMaxTypeAttributeKind.tryGetInAttributes(t.getAttributes());
-}
-exports.minMaxValueForType = minMaxValueForType;
-function minMaxLengthForType(t) {
-    return exports.minMaxLengthTypeAttributeKind.tryGetInAttributes(t.getAttributes());
-}
-exports.minMaxLengthForType = minMaxLengthForType;
-class PatternTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("pattern");
-    }
-    get inIdentity() {
-        return true;
-    }
-    combine(arr) {
-        (0, Support_1.assert)(arr.length > 0);
-        return arr.map(p => `(${p})`).join("|");
-    }
-    intersect(_arr) {
-        /** FIXME!!! what is the intersection of regexps? */
-        return undefined;
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-    addToSchema(schema, t, attr) {
-        if (t.kind !== "string")
-            return;
-        schema.pattern = attr;
-    }
-}
-exports.PatternTypeAttributeKind = PatternTypeAttributeKind;
-exports.patternTypeAttributeKind = new PatternTypeAttributeKind();
-function patternAttributeProducer(schema, _ref, types) {
-    if (!(typeof schema === "object"))
-        return undefined;
-    if (!types.has("string"))
-        return undefined;
-    const patt = schema.pattern;
-    if (typeof patt !== "string")
-        return undefined;
-    return { forString: exports.patternTypeAttributeKind.makeAttributes(patt) };
-}
-exports.patternAttributeProducer = patternAttributeProducer;
-function patternForType(t) {
-    return exports.patternTypeAttributeKind.tryGetInAttributes(t.getAttributes());
-}
-exports.patternForType = patternForType;

package/dist/quicktype-core/attributes/Description.d.ts

@@ -1,9 +0,0 @@
-import { TypeAttributeKind } from "./TypeAttributes";
-import { JSONSchemaType, Ref, JSONSchemaAttributes } from "../input/JSONSchemaInput";
-import { JSONSchema } from "../input/JSONSchemaStore";
-export declare function addDescriptionToSchema(schema: {
-    [name: string]: unknown;
-}, description: Iterable<string> | undefined): void;
-export declare const descriptionTypeAttributeKind: TypeAttributeKind<ReadonlySet<string>>;
-export declare const propertyDescriptionsTypeAttributeKind: TypeAttributeKind<Map<string, ReadonlySet<string>>>;
-export declare function descriptionAttributeProducer(schema: JSONSchema, ref: Ref, types: Set<JSONSchemaType>): JSONSchemaAttributes | undefined;

package/dist/quicktype-core/attributes/Description.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.descriptionAttributeProducer = exports.propertyDescriptionsTypeAttributeKind = exports.descriptionTypeAttributeKind = exports.addDescriptionToSchema = void 0;
-const collection_utils_1 = require("collection-utils");
-const TypeAttributes_1 = require("./TypeAttributes");
-const JSONSchemaInput_1 = require("../input/JSONSchemaInput");
-function addDescriptionToSchema(schema, description) {
-    if (description === undefined)
-        return;
-    schema.description = Array.from(description).join("\n");
-}
-exports.addDescriptionToSchema = addDescriptionToSchema;
-class DescriptionTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("description");
-    }
-    combine(attrs) {
-        return (0, collection_utils_1.setUnionManyInto)(new Set(), attrs);
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-    addToSchema(schema, _t, attrs) {
-        addDescriptionToSchema(schema, attrs);
-    }
-    stringify(descriptions) {
-        let result = (0, collection_utils_1.iterableFirst)(descriptions);
-        if (result === undefined)
-            return undefined;
-        if (result.length > 5 + 3) {
-            result = `${result.slice(0, 5)}...`;
-        }
-        if (descriptions.size > 1) {
-            result = `${result}, ...`;
-        }
-        return result;
-    }
-}
-exports.descriptionTypeAttributeKind = new DescriptionTypeAttributeKind();
-class PropertyDescriptionsTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("propertyDescriptions");
-    }
-    combine(attrs) {
-        // FIXME: Implement this with mutable sets
-        const result = new Map();
-        for (const attr of attrs) {
-            (0, collection_utils_1.mapMergeWithInto)(result, (sa, sb) => (0, collection_utils_1.setUnion)(sa, sb), attr);
-        }
-        return result;
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-    stringify(propertyDescriptions) {
-        if (propertyDescriptions.size === 0)
-            return undefined;
-        return `prop descs: ${propertyDescriptions.size}`;
-    }
-}
-exports.propertyDescriptionsTypeAttributeKind = new PropertyDescriptionsTypeAttributeKind();
-function isPropertiesKey(el) {
-    return el.kind === JSONSchemaInput_1.PathElementKind.KeyOrIndex && el.key === "properties";
-}
-function descriptionAttributeProducer(schema, ref, types) {
-    if (!(typeof schema === "object"))
-        return undefined;
-    let description = TypeAttributes_1.emptyTypeAttributes;
-    let propertyDescription = TypeAttributes_1.emptyTypeAttributes;
-    const pathLength = ref.path.length;
-    if (types.has("object") ||
-        (0, collection_utils_1.setSubtract)(types, ["null"]).size > 1 ||
-        schema.enum !== undefined ||
-        pathLength < 2 ||
-        !isPropertiesKey(ref.path[pathLength - 2])) {
-        const maybeDescription = schema.description;
-        if (typeof maybeDescription === "string") {
-            description = exports.descriptionTypeAttributeKind.makeAttributes(new Set([maybeDescription]));
-        }
-    }
-    if (types.has("object") && typeof schema.properties === "object") {
-        const propertyDescriptions = (0, collection_utils_1.mapFilterMap)((0, collection_utils_1.mapFromObject)(schema.properties), propSchema => {
-            if (typeof propSchema === "object") {
-                const desc = propSchema.description;
-                if (typeof desc === "string") {
-                    return new Set([desc]);
-                }
-            }
-            return undefined;
-        });
-        if (propertyDescriptions.size > 0) {
-            propertyDescription = exports.propertyDescriptionsTypeAttributeKind.makeAttributes(propertyDescriptions);
-        }
-    }
-    return { forType: description, forObject: propertyDescription };
-}
-exports.descriptionAttributeProducer = descriptionAttributeProducer;

package/dist/quicktype-core/attributes/EnumValues.d.ts

@@ -1,8 +0,0 @@
-import { AccessorNames } from "./AccessorNames";
-import { EnumType } from "../Type";
-import { TypeAttributeKind } from "./TypeAttributes";
-import { JSONSchema } from "../input/JSONSchemaStore";
-import { Ref, JSONSchemaType, JSONSchemaAttributes } from "../input/JSONSchemaInput";
-export declare const enumValuesTypeAttributeKind: TypeAttributeKind<AccessorNames>;
-export declare function enumCaseValues(e: EnumType, language: string): Map<string, [string, boolean] | undefined>;
-export declare function enumValuesAttributeProducer(schema: JSONSchema, _canonicalRef: Ref | undefined, _types: Set<JSONSchemaType>): JSONSchemaAttributes | undefined;

package/dist/quicktype-core/attributes/EnumValues.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.enumValuesAttributeProducer = exports.enumCaseValues = exports.enumValuesTypeAttributeKind = void 0;
-const collection_utils_1 = require("collection-utils");
-const AccessorNames_1 = require("./AccessorNames");
-const TypeAttributes_1 = require("./TypeAttributes");
-class EnumValuesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("enumValues");
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-}
-exports.enumValuesTypeAttributeKind = new EnumValuesTypeAttributeKind();
-function enumCaseValues(e, language) {
-    const enumValues = exports.enumValuesTypeAttributeKind.tryGetInAttributes(e.getAttributes());
-    if (enumValues === undefined)
-        return (0, collection_utils_1.mapMap)(e.cases.entries(), _ => undefined);
-    return (0, collection_utils_1.mapMap)(e.cases.entries(), c => (0, AccessorNames_1.lookupKey)(enumValues, c, language));
-}
-exports.enumCaseValues = enumCaseValues;
-function enumValuesAttributeProducer(schema, _canonicalRef, _types) {
-    if (typeof schema !== "object")
-        return undefined;
-    const maybeEnumValues = schema["qt-enum-values"];
-    if (maybeEnumValues === undefined)
-        return undefined;
-    return { forType: exports.enumValuesTypeAttributeKind.makeAttributes((0, AccessorNames_1.makeAccessorNames)(maybeEnumValues)) };
-}
-exports.enumValuesAttributeProducer = enumValuesAttributeProducer;

package/dist/quicktype-core/attributes/StringTypes.d.ts

@@ -1,28 +0,0 @@
-import { TypeAttributeKind } from "./TypeAttributes";
-import { StringTypeMapping } from "../TypeBuilder";
-import { TransformedStringTypeKind } from "../Type";
-import { DateTimeRecognizer } from "../DateTime";
-export declare class StringTypes {
-    readonly cases: ReadonlyMap<string, number> | undefined;
-    readonly transformations: ReadonlySet<TransformedStringTypeKind>;
-    static readonly unrestricted: StringTypes;
-    static fromCase(s: string, count: number): StringTypes;
-    static fromCases(cases: string[]): StringTypes;
-    constructor(cases: ReadonlyMap<string, number> | undefined, transformations: ReadonlySet<TransformedStringTypeKind>);
-    get isRestricted(): boolean;
-    union(othersArray: StringTypes[], startIndex: number): StringTypes;
-    intersect(othersArray: StringTypes[], startIndex: number): StringTypes;
-    applyStringTypeMapping(mapping: StringTypeMapping): StringTypes;
-    equals(other: any): boolean;
-    hashCode(): number;
-    toString(): string;
-}
-export declare const stringTypesTypeAttributeKind: TypeAttributeKind<StringTypes>;
-/**
- * JSON inference calls this function to figure out whether a given string is to be
- * transformed into a higher level type.  Must return undefined if not, otherwise the
- * type kind of the transformed string type.
- *
- * @param s The string for which to determine the transformed string type kind.
- */
-export declare function inferTransformedStringTypeKindForString(s: string, recognizer: DateTimeRecognizer): TransformedStringTypeKind | undefined;