quicktype-core 23.0.175 → 23.1.0

package/dist/Messages.d.ts

@@ -276,10 +276,8 @@ export type ErrorProperties = {
         message: string;
     };
 };
-export type ErrorKinds = ErrorProperties extends {
-    kind: infer K;
-} ? K : never;
-export type ErrorPropertiesForName<K> = Extract<ErrorProperties, {
+export type ErrorKinds = ErrorProperties["kind"];
+export type ErrorPropertiesForKind<K extends ErrorKinds = ErrorKinds> = Extract<ErrorProperties, {
     kind: K;
 }> extends {
     properties: infer P;
@@ -291,5 +289,5 @@ export declare class QuickTypeError extends Error {
     readonly properties: StringMap;
     constructor(errorMessage: string, messageName: string, userMessage: string, properties: StringMap);
 }
-export declare function messageError<N extends ErrorKinds>(kind: N, properties: ErrorPropertiesForName<N>): never;
-export declare function messageAssert<N extends ErrorKinds>(assertion: boolean, kind: N, properties: ErrorPropertiesForName<N>): void;
+export declare function messageError<Kind extends ErrorKinds>(kind: Kind, properties: ErrorPropertiesForKind<Kind>): never;
+export declare function messageAssert<Kind extends ErrorKinds>(assertion: boolean, kind: Kind, properties: ErrorPropertiesForKind<Kind>): void;

package/dist/Messages.js

@@ -78,21 +78,20 @@ exports.QuickTypeError = QuickTypeError;
 function messageError(kind, properties) {
     const message = errorMessages[kind];
     let userMessage = message;
-    const propertiesMap = properties;
-    for (const name of Object.getOwnPropertyNames(propertiesMap)) {
-        let value = propertiesMap[name];
-        if (typeof value === "object" && typeof value.toString === "function") {
-            value = value.toString();
+    for (const [name, value] of Object.entries(properties)) {
+        let valueString = "";
+        if (typeof value === "object" && typeof (value === null || value === void 0 ? void 0 : value.toString) === "function") {
+            valueString = value.toString();
         }
-        else if (typeof value.message === "string") {
-            value = value.message;
+        else if (typeof (value === null || value === void 0 ? void 0 : value.message) === "string") {
+            valueString = value.message;
         }
         else if (typeof value !== "string") {
-            value = JSON.stringify(value);
+            valueString = JSON.stringify(value);
         }
-        userMessage = userMessage.replace("${" + name + "}", value);
+        userMessage = userMessage.replace("${" + name + "}", valueString);
     }
-    throw new QuickTypeError(message, kind, userMessage, propertiesMap);
+    throw new QuickTypeError(message, kind, userMessage, properties);
 }
 exports.messageError = messageError;
 function messageAssert(assertion, kind, properties) {

package/dist/RendererOptions/index.d.ts

@@ -0,0 +1,43 @@
+import { type FixMeOptionsType, type NoInfer } from "../types";
+import type { OptionDefinition, OptionKind, OptionValues } from "./types";
+export * from "./types";
+/**
+ * The superclass for target language options.  You probably want to use one of its
+ * subclasses, `BooleanOption`, `EnumOption`, or `StringOption`.
+ */
+export declare abstract class Option<Name extends string, T> {
+    readonly definition: OptionDefinition<Name, T>;
+    constructor(definition: OptionDefinition<Name, T>);
+    get name(): Name;
+    getValue(values: Record<string, unknown>): T;
+    get cliDefinitions(): {
+        actual: Array<OptionDefinition<Name, T>>;
+        display: Array<OptionDefinition<Name, T>>;
+    };
+}
+export declare function getOptionValues<Name extends string, T, Options extends Record<string, Option<Name, T>>>(options: Options, untypedOptionValues: FixMeOptionsType): OptionValues<Options>;
+/**
+ * A target language option that allows setting a boolean flag.
+ */
+export declare class BooleanOption<Name extends string> extends Option<Name, boolean> {
+    /**
+     * @param name The shorthand name.
+     * @param description Short-ish description of the option.
+     * @param defaultValue The default value.
+     * @param kind Whether it's a primary or secondary option.
+     */
+    constructor(name: Name, description: string, defaultValue: boolean, kind?: OptionKind);
+    get cliDefinitions(): {
+        actual: Array<OptionDefinition<Name, boolean>>;
+        display: Array<OptionDefinition<Name, boolean>>;
+    };
+    getValue(values: Record<string, unknown>): boolean;
+}
+export declare class StringOption<Name extends string> extends Option<Name, string> {
+    constructor(name: Name, description: string, typeLabel: string, defaultValue: string, kind?: OptionKind);
+}
+export declare class EnumOption<Name extends string, EnumMap extends Record<string, unknown>, EnumKey extends Extract<keyof EnumMap, string> = Extract<keyof EnumMap, string>> extends Option<Name, EnumKey> {
+    private readonly _values;
+    constructor(name: Name, description: string, values: EnumMap, defaultValue: NoInfer<EnumKey>, kind?: OptionKind);
+    getEnumValue<Key extends EnumKey>(name: Key): EnumMap[Key];
+}

package/dist/{RendererOptions.js → RendererOptions/index.js}

@@ -1,26 +1,38 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumOption = exports.StringOption = exports.BooleanOption = exports.getOptionValues = exports.Option = void 0;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-const collection_utils_1 = require("collection-utils");
-const Messages_1 = require("./Messages");
-const Support_1 = require("./support/Support");
+const Messages_1 = require("../Messages");
+const Support_1 = require("../support/Support");
+__exportStar(require("./types"), exports);
 /**
  * The superclass for target language options.  You probably want to use one of its
  * subclasses, `BooleanOption`, `EnumOption`, or `StringOption`.
  */
 class Option {
     constructor(definition) {
-        definition.renderer = true;
         this.definition = definition;
         (0, Support_1.assert)(definition.kind !== undefined, "Renderer option kind must be defined");
     }
+    get name() {
+        return this.definition.name;
+    }
     getValue(values) {
-        const value = values[this.definition.name];
-        if (value === undefined) {
-            return this.definition.defaultValue;
-        }
-        return value;
+        var _a;
+        return ((_a = values[this.name]) !== null && _a !== void 0 ? _a : this.definition.defaultValue);
     }
     get cliDefinitions() {
         return { actual: [this.definition], display: [this.definition] };
@@ -29,8 +41,14 @@ class Option {
 exports.Option = Option;
 function getOptionValues(options, untypedOptionValues) {
     const optionValues = {};
-    for (const name of Object.getOwnPropertyNames(options)) {
-        optionValues[name] = options[name].getValue(untypedOptionValues);
+    for (const [key, option] of Object.entries(options)) {
+        const value = option.getValue(untypedOptionValues);
+        if (option instanceof EnumOption) {
+            optionValues[key] = option.getEnumValue(value);
+        }
+        else {
+            optionValues[key] = value;
+        }
     }
     return optionValues;
 }
@@ -56,11 +74,11 @@ class BooleanOption extends Option {
     }
     get cliDefinitions() {
         const negated = Object.assign({}, this.definition, {
-            name: `no-${this.definition.name}`,
+            name: `no-${this.name}`,
             defaultValue: !this.definition.defaultValue
         });
         const display = Object.assign({}, this.definition, {
-            name: `[no-]${this.definition.name}`,
+            name: `[no-]${this.name}`,
             description: `${this.definition.description} (${this.definition.defaultValue ? "on" : "off"} by default)`
         });
         return {
@@ -69,11 +87,11 @@ class BooleanOption extends Option {
         };
     }
     getValue(values) {
-        let value = values[this.definition.name];
+        let value = values[this.name];
         if (value === undefined) {
             value = this.definition.defaultValue;
         }
-        let negated = values[`no-${this.definition.name}`];
+        let negated = values[`no-${this.name}`];
         if (negated === undefined) {
             negated = !this.definition.defaultValue;
         }
@@ -84,10 +102,10 @@ class BooleanOption extends Option {
             value = false;
         }
         if (this.definition.defaultValue) {
-            return value && !negated;
+            return (value && !negated);
         }
         else {
-            return value || !negated;
+            return (value || !negated);
         }
     }
 }
@@ -106,33 +124,27 @@ class StringOption extends Option {
     }
 }
 exports.StringOption = StringOption;
+// FIXME: use const generics here
 class EnumOption extends Option {
-    constructor(name, description, values, defaultValue = undefined, kind = "primary") {
-        if (defaultValue === undefined) {
-            defaultValue = values[0][0];
-        }
+    constructor(name, description, values, defaultValue, kind = "primary") {
         const definition = {
             name,
             kind,
             type: String,
             description,
-            typeLabel: values.map(([n, _]) => n).join("|"),
-            legalValues: values.map(([n, _]) => n),
+            typeLabel: Object.keys(values).join("|"),
             defaultValue
         };
         super(definition);
-        this._values = {};
-        for (const [n, v] of values) {
-            this._values[n] = v;
-        }
+        this._values = values;
     }
-    getValue(values) {
-        let name = values[this.definition.name];
-        if (name === undefined) {
-            name = this.definition.defaultValue;
+    getEnumValue(name) {
+        if (!name) {
+            const defaultKey = this.definition.defaultValue;
+            return this._values[defaultKey];
         }
-        if (!(0, collection_utils_1.hasOwnProperty)(this._values, name)) {
-            return (0, Messages_1.messageError)("RendererUnknownOptionValue", { value: name, name: this.definition.name });
+        if (!(name in this._values)) {
+            return (0, Messages_1.messageError)("RendererUnknownOptionValue", { value: name, name: this.name });
         }
         return this._values[name];
     }

package/dist/RendererOptions/types.d.ts

@@ -0,0 +1,26 @@
+import type { EnumOption, Option } from "./index";
+/**
+ * Primary options show up in the web UI in the "Language" settings tab,
+ * secondary options in "Other".
+ */
+export type OptionKind = "primary" | "secondary";
+export interface OptionDefinition<Name extends string = string, T = unknown> {
+    alias?: string;
+    defaultOption?: boolean;
+    defaultValue?: T;
+    description: string;
+    kind?: OptionKind;
+    multiple?: boolean;
+    name: Name;
+    type: StringConstructor | BooleanConstructor;
+    typeLabel?: string;
+}
+export type OptionName<O> = O extends Option<infer Name, unknown> ? Name : never;
+export type OptionValue<O> = O extends EnumOption<string, infer EnumMap, infer EnumKey> ? EnumMap[EnumKey] : O extends Option<string, infer Value> ? Value : never;
+export type OptionKey<O> = O extends EnumOption<string, Record<string, unknown>, infer EnumKey> ? EnumKey : O;
+export type OptionMap<T> = {
+    [K in keyof T as OptionName<T[K]>]: OptionKey<T[K]>;
+};
+export type OptionValues<T> = {
+    [K in keyof T]: OptionValue<T[K]>;
+};

package/dist/RendererOptions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Run.d.ts

@@ -1,13 +1,12 @@
 import { InputData } from "./input/Inputs";
+import type { RendererOptions } from "./language/options.types";
+import type { LanguageName } from "./language/types";
 import { type SerializedRenderResult } from "./Source";
 import { type Comment } from "./support/Comments";
 import { type MultiFileRenderResult, type TargetLanguage } from "./TargetLanguage";
 import { type TransformedStringTypeKind } from "./Type";
 import { type StringTypeMapping } from "./TypeBuilder";
-export declare function getTargetLanguage(nameOrInstance: string | TargetLanguage): TargetLanguage;
-export interface RendererOptions {
-    [name: string]: string | boolean;
-}
+export declare function getTargetLanguage(nameOrInstance: LanguageName | TargetLanguage): TargetLanguage;
 export interface InferenceFlag {
     description: string;
     explanation: string;
@@ -89,7 +88,7 @@ export type InferenceFlags = {
  * The options type for the main quicktype entry points,
  * `quicktypeMultiFile` and `quicktype`.
  */
-export interface NonInferenceOptions {
+export interface NonInferenceOptions<Lang extends LanguageName = LanguageName> {
     /** Make all class property optional */
     allPropertiesOptional: boolean;
     /** Put class properties in alphabetical order, instead of in the order found in the JSON */
@@ -128,7 +127,7 @@ export interface NonInferenceOptions {
      * or a string specifying one of the names for quicktype's built-in target languages.  For example,
      * both `cs` and `csharp` will generate C#.
      */
-    lang: string | TargetLanguage;
+    lang: Lang | TargetLanguage;
     /** If given, output these comments at the beginning of the main output file */
     leadingComments?: Comment[];
     /** Don't render output.  This is mainly useful for benchmarking. */
@@ -138,7 +137,7 @@ export interface NonInferenceOptions {
      */
     outputFilename: string;
     /** Options for the target language's renderer */
-    rendererOptions: RendererOptions;
+    rendererOptions: RendererOptions<Lang>;
 }
 export type Options = NonInferenceOptions & InferenceFlags;
 export interface RunContext {

package/dist/TargetLanguage.d.ts

@@ -6,20 +6,25 @@ import { type Comment } from "./support/Comments";
 import { type Type } from "./Type";
 import { type StringTypeMapping } from "./TypeBuilder";
 import { type TypeGraph } from "./TypeGraph";
-import { type FixMeOptionsAnyType, type FixMeOptionsType } from "./types";
+import { type FixMeOptionsType } from "./types";
 export type MultiFileRenderResult = ReadonlyMap<string, SerializedRenderResult>;
-export declare abstract class TargetLanguage {
+export interface LanguageConfig {
     readonly displayName: string;
-    readonly names: string[];
     readonly extension: string;
-    constructor(displayName: string, names: string[], extension: string);
-    protected abstract getOptions(): Array<Option<FixMeOptionsAnyType>>;
-    get optionDefinitions(): OptionDefinition[];
+    readonly names: readonly string[];
+}
+export declare abstract class TargetLanguage<Config extends LanguageConfig = LanguageConfig> {
+    readonly displayName: Config["displayName"];
+    readonly names: Config["names"];
+    readonly extension: Config["extension"];
+    constructor({ displayName, names, extension }: Config);
+    protected abstract getOptions(): Record<string, Option<string, unknown>>;
+    get optionDefinitions(): Array<OptionDefinition<string, unknown>>;
     get cliOptionDefinitions(): {
-        actual: OptionDefinition[];
-        display: OptionDefinition[];
+        actual: Array<OptionDefinition<string, unknown>>;
+        display: Array<OptionDefinition<string, unknown>>;
     };
-    get name(): string;
+    get name(): (typeof this.names)[0];
     protected abstract makeRenderer(renderContext: RenderContext, optionValues: FixMeOptionsType): Renderer;
     renderGraphAndSerialize(typeGraph: TypeGraph, givenOutputFilename: string, alphabetizeProperties: boolean, leadingComments: Comment[] | undefined, rendererOptions: FixMeOptionsType, indentation?: string): MultiFileRenderResult;
     protected get defaultIndentation(): string;

package/dist/TargetLanguage.js

@@ -7,18 +7,18 @@ const DateTime_1 = require("./DateTime");
 const Source_1 = require("./Source");
 const Support_1 = require("./support/Support");
 class TargetLanguage {
-    constructor(displayName, names, extension) {
+    constructor({ displayName, names, extension }) {
         this.displayName = displayName;
         this.names = names;
         this.extension = extension;
     }
     get optionDefinitions() {
-        return this.getOptions().map(o => o.definition);
+        return Object.values(this.getOptions()).map(o => o.definition);
     }
     get cliOptionDefinitions() {
         let actual = [];
         let display = [];
-        for (const { cliDefinitions } of this.getOptions()) {
+        for (const { cliDefinitions } of Object.values(this.getOptions())) {
             actual = actual.concat(cliDefinitions.actual);
             display = display.concat(cliDefinitions.display);
         }

package/dist/TypeUtils.d.ts

@@ -1,6 +1,6 @@
+import { type StringTypes } from "./attributes/StringTypes";
 import { type CombinationKind, type TypeAttributes } from "./attributes/TypeAttributes";
 import { ArrayType, type ClassProperty, ClassType, EnumType, MapType, ObjectType, type PrimitiveType, type SetOperationType, type Type, UnionType } from "./Type";
-import { type StringTypes } from "./attributes/StringTypes";
 export declare function assertIsObject(t: Type): ObjectType;
 export declare function assertIsClass(t: Type): ClassType;
 export declare function setOperationMembersRecursively<T extends SetOperationType>(setOperations: T | T[], combinationKind: CombinationKind | undefined): [ReadonlySet<Type>, TypeAttributes];

package/dist/TypeUtils.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchCompoundType = exports.matchType = exports.matchTypeExhaustive = exports.stringTypesForType = exports.directlyReachableSingleNamedType = exports.directlyReachableTypes = exports.separateNamedTypes = exports.isNamedType = exports.getNullAsOptional = exports.nonNullTypeCases = exports.nullableFromUnion = exports.removeNullFromType = exports.removeNullFromUnion = exports.isAnyOrNull = exports.combineTypeAttributesOfTypes = exports.makeGroupsToFlatten = exports.setOperationMembersRecursively = exports.assertIsClass = exports.assertIsObject = void 0;
 const collection_utils_1 = require("collection-utils");
+// eslint-disable-next-line import/no-cycle
+const StringTypes_1 = require("./attributes/StringTypes");
 const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
-// eslint-disable-next-line import/no-cycle
 const Type_1 = require("./Type");
-// String types should be imported last to avoid circular dependency issues.
-// eslint-disable-next-line import/order
-const StringTypes_1 = require("./attributes/StringTypes");
 function assertIsObject(t) {
     if (t instanceof Type_1.ObjectType) {
         return t;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type Options, type RendererOptions, getTargetLanguage, quicktypeMultiFile, quicktypeMultiFileSync, quicktype, combineRenderResults, inferenceFlags, inferenceFlagNames, defaultInferenceFlags, inferenceFlagsObject, type InferenceFlags, type InferenceFlagName, type RunContext } from "./Run";
+export { type Options, getTargetLanguage, quicktypeMultiFile, quicktypeMultiFileSync, quicktype, combineRenderResults, inferenceFlags, inferenceFlagNames, defaultInferenceFlags, inferenceFlagsObject, type InferenceFlags, type InferenceFlagName, type RunContext } from "./Run";
 export { CompressedJSON, type Value } from "./input/CompressedJSON";
 export { type Input, InputData, JSONInput, type JSONSourceData, jsonInputForTargetLanguage } from "./input/Inputs";
 export { JSONSchemaInput, type JSONSchemaSourceData } from "./input/JSONSchemaInput";
@@ -6,7 +6,6 @@ export { Ref, type JSONSchemaType, type JSONSchemaAttributes } from "./input/JSO
 export type { RenderContext } from "./Renderer";
 export { Option, type OptionDefinition, getOptionValues, type OptionValues } from "./RendererOptions";
 export { TargetLanguage, type MultiFileRenderResult } from "./TargetLanguage";
-export { all as defaultTargetLanguages, languageNamed } from "./language/All";
 export { type MultiWord, type Sourcelike, type SerializedRenderResult, type Annotation, modifySource, singleWord, parenIfNeeded } from "./Source";
 export { Name, funPrefixNamer, Namer } from "./Naming";
 export { IssueAnnotationData } from "./Annotation";

package/dist/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassType = exports.ArrayType = exports.PrimitiveType = exports.Type = exports.messageAssert = exports.messageError = exports.QuickTypeError = exports.trainMarkovChain = exports.isLetterOrDigit = exports.legalizeCharacters = exports.allUpperWordStyle = exports.firstUpperWordStyle = exports.combineWords = exports.capitalize = exports.splitIntoWords = exports.inflateBase64 = exports.checkArray = exports.checkStringMap = exports.parseJSON = exports.assertNever = exports.defined = exports.assert = exports.panic = exports.IssueAnnotationData = exports.Namer = exports.funPrefixNamer = exports.Name = exports.parenIfNeeded = exports.singleWord = exports.modifySource = exports.languageNamed = exports.defaultTargetLanguages = exports.TargetLanguage = exports.getOptionValues = exports.Option = exports.Ref = exports.JSONSchemaInput = exports.jsonInputForTargetLanguage = exports.JSONInput = exports.InputData = exports.CompressedJSON = exports.inferenceFlagsObject = exports.defaultInferenceFlags = exports.inferenceFlagNames = exports.inferenceFlags = exports.combineRenderResults = exports.quicktype = exports.quicktypeMultiFileSync = exports.quicktypeMultiFile = exports.getTargetLanguage = void 0;
-exports.uriTypeAttributeKind = exports.ConvenienceRenderer = exports.nullableFromUnion = exports.matchType = exports.removeNullFromUnion = exports.StringTypes = exports.namesTypeAttributeKind = exports.makeNamesTypeAttributes = exports.TypeNames = exports.emptyTypeAttributes = exports.TypeAttributeKind = exports.derefTypeRef = exports.TypeBuilder = exports.sourcesFromPostmanCollection = exports.JSONSchemaStore = exports.FetchingJSONSchemaStore = exports.readFromFileOrURL = exports.readableFromFileOrURL = exports.getStream = exports.ObjectType = exports.UnionType = exports.MapType = exports.EnumType = exports.ClassProperty = void 0;
+exports.EnumType = exports.ClassProperty = exports.ClassType = exports.ArrayType = exports.PrimitiveType = exports.Type = exports.messageAssert = exports.messageError = exports.QuickTypeError = exports.trainMarkovChain = exports.isLetterOrDigit = exports.legalizeCharacters = exports.allUpperWordStyle = exports.firstUpperWordStyle = exports.combineWords = exports.capitalize = exports.splitIntoWords = exports.inflateBase64 = exports.checkArray = exports.checkStringMap = exports.parseJSON = exports.assertNever = exports.defined = exports.assert = exports.panic = exports.IssueAnnotationData = exports.Namer = exports.funPrefixNamer = exports.Name = exports.parenIfNeeded = exports.singleWord = exports.modifySource = exports.TargetLanguage = exports.getOptionValues = exports.Option = exports.Ref = exports.JSONSchemaInput = exports.jsonInputForTargetLanguage = exports.JSONInput = exports.InputData = exports.CompressedJSON = exports.inferenceFlagsObject = exports.defaultInferenceFlags = exports.inferenceFlagNames = exports.inferenceFlags = exports.combineRenderResults = exports.quicktype = exports.quicktypeMultiFileSync = exports.quicktypeMultiFile = exports.getTargetLanguage = void 0;
+exports.uriTypeAttributeKind = exports.ConvenienceRenderer = exports.nullableFromUnion = exports.matchType = exports.removeNullFromUnion = exports.StringTypes = exports.namesTypeAttributeKind = exports.makeNamesTypeAttributes = exports.TypeNames = exports.emptyTypeAttributes = exports.TypeAttributeKind = exports.derefTypeRef = exports.TypeBuilder = exports.sourcesFromPostmanCollection = exports.JSONSchemaStore = exports.FetchingJSONSchemaStore = exports.readFromFileOrURL = exports.readableFromFileOrURL = exports.getStream = exports.ObjectType = exports.UnionType = exports.MapType = void 0;
 var Run_1 = require("./Run");
 Object.defineProperty(exports, "getTargetLanguage", { enumerable: true, get: function () { return Run_1.getTargetLanguage; } });
 Object.defineProperty(exports, "quicktypeMultiFile", { enumerable: true, get: function () { return Run_1.quicktypeMultiFile; } });
@@ -41,9 +41,6 @@ Object.defineProperty(exports, "Option", { enumerable: true, get: function () {
 Object.defineProperty(exports, "getOptionValues", { enumerable: true, get: function () { return RendererOptions_1.getOptionValues; } });
 var TargetLanguage_1 = require("./TargetLanguage");
 Object.defineProperty(exports, "TargetLanguage", { enumerable: true, get: function () { return TargetLanguage_1.TargetLanguage; } });
-var All_1 = require("./language/All");
-Object.defineProperty(exports, "defaultTargetLanguages", { enumerable: true, get: function () { return All_1.all; } });
-Object.defineProperty(exports, "languageNamed", { enumerable: true, get: function () { return All_1.languageNamed; } });
 var Source_1 = require("./Source");
 Object.defineProperty(exports, "modifySource", { enumerable: true, get: function () { return Source_1.modifySource; } });
 Object.defineProperty(exports, "singleWord", { enumerable: true, get: function () { return Source_1.singleWord; } });

package/dist/input/Inputs.d.ts

@@ -1,6 +1,7 @@
 import { type RunContext } from "../Run";
 import { type TargetLanguage } from "../TargetLanguage";
 import { type TypeBuilder } from "../TypeBuilder";
+import { type LanguageName } from "../types";
 import { type CompressedJSON } from "./CompressedJSON";
 export interface Input<T> {
     addSource: (source: T) => Promise<void>;
@@ -33,7 +34,7 @@ export declare class JSONInput<T> implements Input<JSONSourceData<T>> {
     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 function jsonInputForTargetLanguage(targetLanguage: LanguageName | TargetLanguage, languages?: TargetLanguage[], handleJSONRefs?: boolean): JSONInput<string>;
 export declare class InputData {
     private _inputs;
     addInput<T>(input: Input<T>): void;

package/dist/language/All.d.ts

@@ -1,3 +1,32 @@
 import { type TargetLanguage } from "../TargetLanguage";
-export declare const all: TargetLanguage[];
-export declare function languageNamed(name: string, targetLanguages?: TargetLanguage[]): TargetLanguage | undefined;
+import { CJSONTargetLanguage } from "./CJSON";
+import { CPlusPlusTargetLanguage } from "./CPlusPlus";
+import { CrystalTargetLanguage } from "./Crystal";
+import { CSharpTargetLanguage } from "./CSharp";
+import { DartTargetLanguage } from "./Dart";
+import { ElixirTargetLanguage } from "./Elixir";
+import { ElmTargetLanguage } from "./Elm";
+import { GoTargetLanguage } from "./Golang";
+import { HaskellTargetLanguage } from "./Haskell";
+import { JavaTargetLanguage } from "./Java";
+import { JavaScriptTargetLanguage } from "./JavaScript";
+import { JavaScriptPropTypesTargetLanguage } from "./JavaScriptPropTypes";
+import { JSONSchemaTargetLanguage } from "./JSONSchema";
+import { KotlinTargetLanguage } from "./Kotlin";
+import { ObjectiveCTargetLanguage } from "./Objective-C";
+import { PhpTargetLanguage } from "./Php";
+import { PikeTargetLanguage } from "./Pike";
+import { PythonTargetLanguage } from "./Python";
+import { RubyTargetLanguage } from "./Ruby";
+import { RustTargetLanguage } from "./Rust";
+import { Scala3TargetLanguage } from "./Scala3";
+import { SmithyTargetLanguage } from "./Smithy4s";
+import { SwiftTargetLanguage } from "./Swift";
+import { type LanguageDisplayName, type LanguageName, type LanguageNameMap } from "./types";
+import { TypeScriptEffectSchemaTargetLanguage } from "./TypeScriptEffectSchema";
+import { FlowTargetLanguage, TypeScriptTargetLanguage } from "./TypeScriptFlow";
+import { TypeScriptZodTargetLanguage } from "./TypeScriptZod";
+export declare const all: readonly [CJSONTargetLanguage, CPlusPlusTargetLanguage, CrystalTargetLanguage, CSharpTargetLanguage, DartTargetLanguage, ElixirTargetLanguage, ElmTargetLanguage, FlowTargetLanguage, GoTargetLanguage, HaskellTargetLanguage, JavaTargetLanguage, JavaScriptTargetLanguage, JavaScriptPropTypesTargetLanguage, JSONSchemaTargetLanguage, KotlinTargetLanguage, ObjectiveCTargetLanguage, PhpTargetLanguage, PikeTargetLanguage, PythonTargetLanguage, RubyTargetLanguage, RustTargetLanguage, Scala3TargetLanguage, SmithyTargetLanguage, SwiftTargetLanguage, TypeScriptTargetLanguage, TypeScriptEffectSchemaTargetLanguage, TypeScriptZodTargetLanguage];
+export declare function languageNamed<Name extends LanguageName>(name: Name, targetLanguages?: readonly TargetLanguage[]): LanguageNameMap[Name];
+export declare function isLanguageName(maybeName: string): maybeName is LanguageName;
+export declare function isLanguageDisplayName(maybeName: string): maybeName is LanguageDisplayName;

package/dist/language/All.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.languageNamed = exports.all = void 0;
-const collection_utils_1 = require("collection-utils");
+exports.isLanguageDisplayName = exports.isLanguageName = exports.languageNamed = exports.all = void 0;
 const CJSON_1 = require("./CJSON");
 const CPlusPlus_1 = require("./CPlusPlus");
 const Crystal_1 = require("./Crystal");
@@ -47,7 +46,7 @@ exports.all = [
     new Objective_C_1.ObjectiveCTargetLanguage(),
     new Php_1.PhpTargetLanguage(),
     new Pike_1.PikeTargetLanguage(),
-    new Python_1.PythonTargetLanguage("Python", ["python", "py"], "py"),
+    new Python_1.PythonTargetLanguage(),
     new Ruby_1.RubyTargetLanguage(),
     new Rust_1.RustTargetLanguage(),
     new Scala3_1.Scala3TargetLanguage(),
@@ -57,13 +56,26 @@ exports.all = [
     new TypeScriptEffectSchema_1.TypeScriptEffectSchemaTargetLanguage(),
     new TypeScriptZod_1.TypeScriptZodTargetLanguage()
 ];
-function languageNamed(name, targetLanguages) {
-    if (targetLanguages === undefined) {
-        targetLanguages = exports.all;
+exports.all;
+function languageNamed(name, targetLanguages = exports.all) {
+    const foundLanguage = targetLanguages.find(language => language.names.includes(name));
+    if (!foundLanguage) {
+        throw new Error(`Unknown language name: ${name}`);
     }
-    const maybeTargetLanguage = (0, collection_utils_1.iterableFind)(targetLanguages, l => l.names.includes(name) || l.displayName === name);
-    if (maybeTargetLanguage !== undefined)
-        return maybeTargetLanguage;
-    return (0, collection_utils_1.iterableFind)(targetLanguages, l => l.extension === name);
+    return foundLanguage;
 }
 exports.languageNamed = languageNamed;
+function isLanguageName(maybeName) {
+    if (exports.all.some(lang => lang.names.includes(maybeName))) {
+        return true;
+    }
+    return false;
+}
+exports.isLanguageName = isLanguageName;
+function isLanguageDisplayName(maybeName) {
+    if (exports.all.some(lang => lang.displayName === maybeName)) {
+        return true;
+    }
+    return false;
+}
+exports.isLanguageDisplayName = isLanguageDisplayName;