quicktype-core

import { 
  quicktype, 
  quicktypeMultiFile,
  InputData,
  JSONInput,
  jsonInputForTargetLanguage,
  JSONSchemaInput,
  getTargetLanguage,
  type Options 
} from "quicktype-core";

const { 
  quicktype, 
  quicktypeMultiFile,
  InputData,
  JSONInput,
  jsonInputForTargetLanguage
} = require("quicktype-core");

import { quicktype, InputData, jsonInputForTargetLanguage } from "quicktype-core";

// Create input data container
const inputData = new InputData();

// Add JSON sample data  
const jsonInput = jsonInputForTargetLanguage("typescript");
await jsonInput.addSource({
  name: "Person",
  samples: ['{"name": "John", "age": 30, "active": true}']
});
inputData.addInput(jsonInput);

// Generate TypeScript code
const result = await quicktype({
  lang: "typescript",
  inputData,
  outputFilename: "Person.ts"
});

console.log(result.lines.join('\n'));

function quicktype(options: Partial<Options>): Promise<SerializedRenderResult>;
function quicktypeMultiFile(options: Partial<Options>): Promise<MultiFileRenderResult>;
function quicktypeMultiFileSync(options: Partial<Options>): MultiFileRenderResult;

interface Options extends NonInferenceOptions, InferenceFlags {
  lang: string | TargetLanguage;
  inputData: InputData;
  outputFilename: string;
  rendererOptions: RendererOptions;
  alphabetizeProperties: boolean;
  allPropertiesOptional: boolean;
}

interface SerializedRenderResult {
  lines: string[];
  annotations: Annotation[];
}

type MultiFileRenderResult = ReadonlyMap<string, SerializedRenderResult>;

class InputData {
  addInput<T>(input: Input<T>): void;
  addSource<T>(kind: string, source: T, makeInput: () => Input<T>): Promise<void>;
  addSourceSync<T>(kind: string, source: T, makeInput: () => Input<T>): void;
}

function jsonInputForTargetLanguage(
  targetLanguage: string | TargetLanguage,
  languages?: TargetLanguage[],
  handleJSONRefs?: boolean
): JSONInput<string>;

interface JSONSourceData<T> {
  name: string;
  samples: T[];
  description?: string;
}

class JSONSchemaInput {
  constructor(
    schemaStore?: JSONSchemaStore,
    additionalAttributeProducers?: JSONSchemaAttributeProducer[],
    additionalSchemaAddresses?: readonly string[]
  );
  addSource(source: JSONSchemaSourceData): Promise<void>;
}

interface JSONSchemaSourceData {
  name: string;
  uris?: string[];
  schema?: string;
  isConverted?: boolean;
}

class Ref {
  static root(address?: string): Ref;
  static parse(ref: string): Ref;
  push(...keys: string[]): Ref;
  resolveAgainst(base?: Ref): Ref;
}

abstract class Type {
  readonly kind: TypeKind;
  readonly typeRef: TypeRef;
  getChildren(): ReadonlySet<Type>;
  getAttributes(): TypeAttributes;
  getNames(): TypeNames;
  structurallyCompatible(other: Type, conflateNumbers?: boolean): boolean;
}

class TypeBuilder {
  constructor(
    stringTypeMapping: StringTypeMapping,
    canonicalOrder: boolean,
    allPropertiesOptional: boolean,
    addProvenanceAttributes: boolean,
    inheritsProvenanceAttributes: boolean
  );
  getPrimitiveType(kind: PrimitiveTypeKind, attributes?: TypeAttributes): TypeRef;
  getArrayType(attributes: TypeAttributes, items: TypeRef): TypeRef;
  getClassType(attributes: TypeAttributes, properties: ReadonlyMap<string, ClassProperty>): TypeRef;
  getEnumType(attributes: TypeAttributes, cases: ReadonlySet<string>): TypeRef;
  getUnionType(attributes: TypeAttributes, members: ReadonlySet<TypeRef>): TypeRef;
  finish(): TypeGraph;
}

type TypeKind = PrimitiveTypeKind | ObjectTypeKind | "array" | "enum" | "union" | "intersection";
type PrimitiveTypeKind = "none" | "any" | "null" | "bool" | "integer" | "double" | "string" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";

abstract class TargetLanguage {
  readonly displayName: string;
  readonly names: readonly string[];
  readonly extension: string;
  readonly stringTypeMapping: StringTypeMapping;
  readonly supportsOptionalClassProperties: boolean;
  abstract makeRenderer(renderContext: RenderContext, optionValues: RendererOptions): Renderer;
  renderGraphAndSerialize(
    typeGraph: TypeGraph,
    outputFilename: string,
    alphabetizeProperties: boolean,
    leadingComments?: Comment[],
    rendererOptions: RendererOptions,
    indentation?: string
  ): MultiFileRenderResult;
}

function getTargetLanguage(nameOrInstance: string | TargetLanguage): TargetLanguage;

interface InferenceFlags {
  inferMaps: boolean;
  inferEnums: boolean;
  inferUuids: boolean;
  inferDateTimes: boolean;
  inferIntegerStrings: boolean;
  inferBooleanStrings: boolean;
  combineClasses: boolean;
  ignoreJsonRefs: boolean;
}

const defaultInferenceFlags: InferenceFlags;
const inferenceFlags: Record<InferenceFlagName, InferenceFlag>;

class Option<Name, T> {
  definition: OptionDefinition<Name, T>;
}

interface OptionDefinition<Name, T> {
  name: Name;
  type: OptionType<T>;
  defaultValue: T;
  description: string;
  typeLabel?: string;
}

// Core utilities
function panic(message: string): never;
function assert(condition: boolean, message?: string): void;
function defined<T>(value: T | undefined): T;
function parseJSON(text: string, description: string, address?: string): any;

// String utilities  
function splitIntoWords(str: string): string[];
function capitalize(str: string): string;
function combineWords(words: string[]): string;
function firstUpperWordStyle(words: string[]): string;
function allUpperWordStyle(words: string[]): string;
function legalizeCharacters(str: string, isLegal: (char: string) => boolean): string;

// Type utilities
function removeNullFromUnion(t: Type): Type;
function matchType<T>(t: Type, matchers: Record<TypeKind, (t: Type) => T>): T;
function nullableFromUnion(t: Type): Type | null;