type-crafter 0.3.0 → 0.4.0

package/dist/index.js

@@ -10828,6 +10828,9 @@ function decodeTypeInfo(rawInput) {
             items: decodeTypeInfo(rawInput.items),
             format: decodeString(rawInput.format),
             $ref: decodeString(rawInput.$ref),
+            description: decodeString(rawInput.description),
+            example: decodeString(rawInput.example) ?? decodeNumber(rawInput.example),
+            oneOf: decodeArray(rawInput.oneOf, decodeTypeInfo),
             enum: _type === 'string'
                 ? decodeArray(rawInput.enum, decodeString)
                 : _type === 'number'
@@ -10877,13 +10880,17 @@ function decodeObjectTemplateInputProperty(rawInput) {
         const referenced = decodeBoolean(rawInput.referenced);
         const primitiveType = decodeString(rawInput.primitiveType);
         const composerType = decodeString(rawInput.composerType);
+        const example = decodeString(rawInput.example) ?? decodeNumber(rawInput.example);
+        const description = decodeString(rawInput.description);
         if (required !== null && _type !== null && referenced !== null && primitiveType !== null) {
             return {
                 type: _type,
                 required,
                 referenced,
                 primitiveType,
-                composerType
+                composerType,
+                example,
+                description
             };
         }
     }
@@ -19221,6 +19228,7 @@ let specFileData = null;
 let objectSyntaxTemplate = null;
 let exporterModuleSyntaxTemplate = null;
 let typesFileSyntaxTemplate = null;
+let oneOfSyntaxTemplate = null;
 let enumSyntaxTemplate = null;
 let expectedOutputFiles = null;
 function setConfig(newConfig) {
@@ -19247,6 +19255,7 @@ function compileTemplates() {
     exporterModuleSyntaxTemplate = Handlebars.compile(config.template.exporterModuleSyntax);
     typesFileSyntaxTemplate = Handlebars.compile(config.template.typesFileSyntax);
     enumSyntaxTemplate = Handlebars.compile(config.template.enumSyntax);
+    oneOfSyntaxTemplate = Handlebars.compile(config.template.oneOfSyntax);
 }
 function getObjectTemplate() {
     if (objectSyntaxTemplate === null) {
@@ -19272,6 +19281,12 @@ function getEnumTemplate() {
     }
     return enumSyntaxTemplate;
 }
+function getOneOfTemplate() {
+    if (oneOfSyntaxTemplate === null) {
+        throw new RuntimeError('OneOf template not compiled!');
+    }
+    return oneOfSyntaxTemplate;
+}
 function setExpectedOutputFiles(newExpectedOutputFiles) {
     expectedOutputFiles = newExpectedOutputFiles;
 }
@@ -19292,7 +19307,8 @@ var Runtime = {
     getTypesFileTemplate,
     getEnumTemplate,
     getExpectedOutputFiles,
-    compileTemplates
+    compileTemplates,
+    getOneOfTemplate
 };
 
 function getSourceFileDirectory() {
@@ -19432,13 +19448,20 @@ function toPascalCase(input) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join('');
 }
+function toPascalCaseHelper(input) {
+    const inputString = decodeString(input);
+    if (inputString === null) {
+        return input;
+    }
+    return toPascalCase(inputString);
+}
 function registerTemplateHelpers() {
     Handlebars.registerHelper('getOptionalKeys', getOptionalKeys);
     Handlebars.registerHelper('getRequiredKeys', getRequiredKeys);
     Handlebars.registerHelper('areRequiredKeysPresent', (object) => getRequiredKeys(object).length > 0);
     Handlebars.registerHelper('getReferencedTypes', getReferencedTypes);
     Handlebars.registerHelper('getReferencedTypeModules', getReferencedTypeModules);
-    Handlebars.registerHelper('toPascalCase', toPascalCase);
+    Handlebars.registerHelper('toPascalCase', toPascalCaseHelper);
     Handlebars.registerHelper('isNonEmptyArray', (value) => Array.isArray(value) && value.length === 0);
     Handlebars.registerHelper('eq', (value1, value2) => value1 === value2);
 }
@@ -19520,43 +19543,85 @@ function resolveAndGetReferenceName(reference) {
     return getReferenceName(reference);
 }
 function getLanguageDataType(dataType, format, items) {
+    const result = {
+        dataType,
+        references: new Set(),
+        primitives: new Set()
+    };
     const typeMapper = Runtime.getConfig().language.typeMapper ?? null;
     const mappedType = typeMapper !== null ? typeMapper[dataType] : null;
+    const itemReference = 
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    items !== null && items.$ref !== null ? resolveAndGetReferenceName(items.$ref) : null;
     const itemsType = 
     // eslint-disable-next-line
     items !== null
         ? items.type !== null
             ? getLanguageDataType(items.type, items.format, items.items)
-            : items.$ref !== null
-                ? resolveAndGetReferenceName(items.$ref)
+            : itemReference !== null
+                ? {
+                    dataType: itemReference,
+                    references: new Set([itemReference]),
+                    primitives: new Set()
+                }
                 : null
         : null;
     const fillerPatterns = [];
     if (itemsType !== null) {
-        fillerPatterns.push({ regex: /~ItemType~/g, value: itemsType });
+        fillerPatterns.push({ regex: /~ItemType~/g, value: itemsType.dataType });
     }
+    let mappedTypeWithFormat = null;
+    let defaultType = null;
     if (typeof mappedType === 'string') {
-        return fillPatterns(mappedType, fillerPatterns);
+        result.dataType = fillPatterns(mappedType, fillerPatterns);
     }
     else if (isJSON(mappedType)) {
-        const defaultType = mappedType.default;
-        const mappedTypeWithFormat = mappedType[format ?? ''] ?? defaultType;
+        defaultType = mappedType.default;
+        mappedTypeWithFormat = mappedType[format ?? ''] ?? defaultType;
         if (typeof mappedTypeWithFormat === 'string') {
-            return fillPatterns(mappedTypeWithFormat, fillerPatterns);
+            result.dataType = fillPatterns(mappedTypeWithFormat, fillerPatterns);
         }
     }
-    return dataType;
+    /**
+     * @todo: Segregate array & variable type generation
+     */
+    const primitiveElementType = items?.$ref !== null
+        ? null
+        : mappedTypeWithFormat === null
+            ? itemsType !== null
+                ? itemsType.dataType
+                : result.dataType
+            : typeof mappedType === 'string' && items?.$ref !== null
+                ? mappedType
+                : null;
+    if (itemsType !== null && primitiveElementType !== null) {
+        result.itemType = primitiveElementType;
+    }
+    else if (itemsType !== null && itemReference !== null) {
+        result.itemType = itemReference;
+    }
+    if (itemsType !== null) {
+        result.references = new Set([...result.references, ...itemsType.references]);
+        result.primitives =
+            primitiveElementType !== null
+                ? new Set([...result.primitives, primitiveElementType])
+                : result.primitives;
+    }
+    return result;
 }
 function generateObjectType(typeName, typeInfo) {
-    const result = {
-        content: '',
-        references: new Set(),
-        primitives: new Set()
-    };
     const templateInput = {
         typeName,
+        description: typeInfo.description,
+        example: typeInfo.example,
         properties: {}
     };
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set(),
+        templateInput
+    };
     let recursiveTypeGenOutput = null;
     let dynamicGeneratedType = '';
     for (const propertyName in typeInfo.properties) {
@@ -19599,7 +19664,7 @@ function generateObjectType(typeName, typeInfo) {
             }
         }
         else if (propertyType !== null) {
-            languageDataType = getLanguageDataType(propertyType, propertyFormat, propertyItems);
+            languageDataType = getLanguageDataType(propertyType, propertyFormat, propertyItems).dataType;
             result.primitives.add(propertyItems !== null ? 'Array' : languageDataType);
             if (propertyItems !== null) {
                 const itemsType = propertyItems.type ?? getReferenceName(propertyItems.$ref ?? '');
@@ -19617,7 +19682,9 @@ function generateObjectType(typeName, typeInfo) {
                 required: typeInfo.required?.includes(propertyName) ?? false,
                 referenced: isReferenced,
                 primitiveType,
-                composerType
+                composerType,
+                example: propertyDetails.example,
+                description: propertyDetails.description
             }
         };
     }
@@ -19628,31 +19695,113 @@ function generateObjectType(typeName, typeInfo) {
     return result;
 }
 function generateEnumType(typeName, typeInfo) {
+    if (typeInfo.enum === null || typeInfo.enum.length === 0 || typeInfo.type === null) {
+        throw new InvalidSpecFileError('Invalid enum type for: ' + typeName);
+    }
+    const templateInput = {
+        typeName,
+        enumType: typeInfo.type,
+        values: typeInfo.enum,
+        example: typeInfo.example,
+        description: typeInfo.description
+    };
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set(),
+        templateInput
+    };
+    result.content = Runtime.getEnumTemplate()(templateInput);
+    return result;
+}
+function generateOneOfTypes(typeName, typeInfo) {
     const result = {
         content: '',
         references: new Set(),
         primitives: new Set()
     };
-    if (typeInfo.enum === null || typeInfo.enum.length === 0 || typeInfo.type === null) {
-        throw new InvalidSpecFileError('Invalid enum type for: ' + typeName);
+    if (typeInfo.oneOf === null || typeInfo.oneOf.length === 0) {
+        throw new InvalidSpecFileError('Invalid oneOf type for: ' + typeName);
     }
     const templateInput = {
-        enumName: typeName,
-        enumType: typeInfo.type,
-        values: typeInfo.enum
+        typeName,
+        compositions: []
     };
-    result.content = Runtime.getEnumTemplate()(templateInput);
+    for (let index = 0; index < typeInfo.oneOf.length; index++) {
+        const oneOfItem = typeInfo.oneOf[index];
+        if (oneOfItem.$ref !== null) {
+            const referenceName = resolveAndGetReferenceName(oneOfItem.$ref);
+            const composition = {
+                source: 'referenced',
+                referencedType: referenceName
+            };
+            templateInput.compositions.push(composition);
+            result.references.add(referenceName);
+        }
+        else {
+            const generatedType = generateType(typeName + (index + 1), oneOfItem);
+            if (generatedType === null) {
+                throw new InvalidSpecFileError('Invalid oneOf type for: ' + typeName);
+            }
+            const composition = {
+                dataType: oneOfItem.type,
+                templateInput: generatedType.templateInput,
+                source: 'inline',
+                content: generatedType.content
+            };
+            templateInput.compositions.push(composition);
+            for (const reference of generatedType.references.values()) {
+                result.references.add(reference);
+            }
+            for (const primitive of generatedType.primitives.values()) {
+                result.primitives.add(primitive);
+            }
+        }
+    }
+    result.content = Runtime.getOneOfTemplate()(templateInput);
     return result;
 }
+function generateVariableType(typeName, typeInfo) {
+    if (typeInfo.type === null) {
+        return null;
+    }
+    const dataType = getLanguageDataType(typeInfo.type, typeInfo.format, typeInfo.items);
+    const _primitives = [...dataType.primitives];
+    if (typeInfo.type === 'array' && dataType.references.size !== 0) {
+        _primitives.push('Array');
+    }
+    else if (typeInfo.type !== 'array' && typeInfo.$ref === null) {
+        _primitives.push(dataType.dataType);
+    }
+    return {
+        content: '',
+        references: dataType.references,
+        primitives: new Set(_primitives),
+        templateInput: {
+            typeName,
+            dataType: dataType.dataType,
+            itemType: dataType.itemType,
+            primitiveType: typeInfo.type
+        }
+    };
+}
+function generateType(typeName, typeInfo) {
+    if (typeInfo.type === 'object') {
+        return generateObjectType(typeName, typeInfo);
+    }
+    if (typeInfo.enum !== null) {
+        return generateEnumType(typeName, typeInfo);
+    }
+    if (typeInfo.oneOf !== null) {
+        return generateOneOfTypes(typeName, typeInfo);
+    }
+    return generateVariableType(typeName, typeInfo);
+}
 function generateTypes(types) {
     const result = {};
     for (const type in types) {
         const typeInfo = types[type];
-        const genType = typeInfo.type === 'object'
-            ? generateObjectType(type, typeInfo)
-            : typeInfo.enum !== null
-                ? generateEnumType(type, typeInfo)
-                : null;
+        const genType = generateType(type, typeInfo);
         if (genType !== null) {
             result[type] = genType;
         }
@@ -19822,6 +19971,7 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
     const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs', devMode);
     const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript/types-file-syntax.hbs', devMode);
     const enumSyntax = await readFile(directoryPrefix + 'templates/typescript/enum-syntax.hbs', devMode);
+    const oneOfSyntax = await readFile(directoryPrefix + 'templates/typescript/oneOf-syntax.hbs', devMode);
     const config = {
         input: inputFilePath,
         output: {
@@ -19837,7 +19987,8 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
             objectSyntax,
             exporterModuleSyntax,
             typesFileSyntax,
-            enumSyntax
+            enumSyntax,
+            oneOfSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -19862,6 +20013,7 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
     const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs', devMode);
     const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/types-file-syntax.hbs', devMode);
     const enumSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/enum-syntax.hbs', devMode);
+    const oneOfSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/oneOf-syntax.hbs', devMode);
     const config = {
         input: inputFilePath,
         output: {
@@ -19877,7 +20029,8 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
             objectSyntax,
             exporterModuleSyntax,
             typesFileSyntax,
-            enumSyntax
+            enumSyntax,
+            oneOfSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -19942,7 +20095,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.3.0');
+const program = new Command().version('0.4.0');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, ObjectTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
+import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, ObjectTemplateInput, OneOfTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
 declare function setConfig(newConfig: Configuration): void;
 declare function getConfig(): Configuration;
 declare function setSpecFileData(newSpecFileData: SpecFileData): void;
@@ -8,6 +8,7 @@ declare function getObjectTemplate(): HandlebarsTemplateDelegate<ObjectTemplateI
 declare function getExporterModuleTemplate(): HandlebarsTemplateDelegate<ExporterModuleTemplateInput>;
 declare function getTypesFileTemplate(): HandlebarsTemplateDelegate<TypesFileTemplateInput>;
 declare function getEnumTemplate(): HandlebarsTemplateDelegate<EnumTemplateInput>;
+declare function getOneOfTemplate(): HandlebarsTemplateDelegate<OneOfTemplateInput>;
 declare function setExpectedOutputFiles(newExpectedOutputFiles: Map<string, TypeFilePath>): void;
 declare function getExpectedOutputFiles(): Map<string, TypeFilePath>;
 declare const _default: {
@@ -22,5 +23,6 @@ declare const _default: {
     getEnumTemplate: typeof getEnumTemplate;
     getExpectedOutputFiles: typeof getExpectedOutputFiles;
     compileTemplates: typeof compileTemplates;
+    getOneOfTemplate: typeof getOneOfTemplate;
 };
 export default _default;

package/dist/templates/typescript/enum-syntax.hbs

@@ -1,4 +1,13 @@
-export type {{enumName}} =
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
 {{#each values}}
   | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
 {{/each}};

package/dist/templates/typescript/object-syntax.hbs

@@ -1,5 +1,24 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
 export type {{typeName}} = {
   {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
   {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

package/dist/templates/typescript/oneOf-syntax.hbs

@@ -0,0 +1,19 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{#each this.templateInput.values}}
+        {{#unless @first}}|{{/unless}} {{#if (eq ../this.templateInput.enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../this.templateInput/enumType 'string')}}'{{/if}}
+      {{/each}}
+    {{else if (eq this.dataType 'object')}}
+      {
+        {{#each this.templateInput.properties}}
+        {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+        {{/each}}
+      }
+    {{else}}
+      {{this.templateInput.dataType}}
+    {{/if}}
+  {{/if}}
+{{/each}};

package/dist/templates/typescript-with-decoders/enum-syntax.hbs

@@ -1,10 +1,18 @@
-export type {{enumName}} =
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
 {{#each values}}
   | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
 {{/each}};
 
-
-export function decode{{enumName}}(rawInput: unknown): {{enumName}} | null {
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   switch (rawInput) {
     {{#each values}}
     case {{#if (eq ../enumType 'string') }}'{{/if}}{{this}}{{#if (eq ../enumType 'string')}}'{{/if}}:

package/dist/templates/typescript-with-decoders/object-syntax.hbs

@@ -1,5 +1,24 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
 export type {{typeName}} = {
   {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
   {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

package/dist/templates/typescript-with-decoders/oneOf-syntax.hbs

@@ -0,0 +1,74 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}C{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      C{{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.dataType}}
+    {{/if}}
+  {{/if}}
+{{/each}};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  const result: {{typeName}} | null =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}
+    decodeC{{referencedType}}(rawInput)
+  {{else if (eq this.dataType 'object')}}
+    decodeC{{this.templateInput.typeName}}(rawInput)
+  {{else if (eq this.templateInput.primitiveType 'array')}}
+    decodeArray(rawInput, decode{{{toPascalCase this.templateInput.itemType}}})
+  {{else if this.templateInput.values}}
+    decode{{this.templateInput.typeName}}(rawInput)
+  {{else}}
+    decode{{{toPascalCase this.templateInput.dataType}}}(rawInput)
+  {{/if}}{{#unless @last}}??{{/unless}}
+  {{/each}};
+  return result;
+}
+
+
+{{#each compositions}}
+
+{{#if this.templateInput.values}}
+{{{this.content}}}
+{{else if (eq this.source 'referenced')}}
+export class C{{referencedType}} {
+  data: {{referencedType}};
+  constructor(data: {{referencedType}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{referencedType}}(rawInput: unknown): C{{referencedType}} | null {
+  const result = decode{{referencedType}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{referencedType}}(result);
+}
+
+{{else if (eq this.dataType 'object')}}
+
+{{{this.content}}}
+
+export class C{{this.templateInput.typeName}} {
+  data: {{this.templateInput.typeName}};
+  constructor(data: {{this.templateInput.typeName}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
+  const result = decode{{this.templateInput.typeName}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{this.templateInput.typeName}}(result);
+}
+
+{{/if}}
+{{/each}}

package/dist/types/index.d.ts

@@ -21,6 +21,7 @@ export type Template = {
     exporterModuleSyntax: string;
     typesFileSyntax: string;
     enumSyntax: string;
+    oneOfSyntax: string;
 };
 export type LanguageConfig = {
     exporterModuleName: string;
@@ -55,13 +56,18 @@ export type TypeInfo = {
     items: TypeInfo | null;
     properties: TypeProperties | null;
     $ref: string | null;
+    oneOf: TypeInfo[] | null;
     enum: string[] | number[] | null;
+    description: string | null;
+    example: string | number | null;
 };
 type PropertyName = string;
 export type TypeProperties = Record<PropertyName, TypeInfo>;
 export type TypeDataType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
 export type ObjectTemplateInput = {
     typeName: string;
+    example: string | number | null;
+    description: string | null;
     properties: ObjectTemplateInputProperties;
 };
 export type ObjectTemplateInputProperties = Record<PropertyName, ObjectTemplateInputProperty>;
@@ -71,6 +77,8 @@ export type ObjectTemplateInputProperty = {
     referenced: boolean;
     primitiveType: string;
     composerType: string | null;
+    example: string | number | null;
+    description: string | null;
 };
 export type ExporterModuleTemplateInput = {
     modules: string[];
@@ -87,10 +95,30 @@ export type ReferencedModule = {
     referencedTypes: string[];
 };
 export type EnumTemplateInput = {
-    enumName: string;
+    typeName: string;
     enumType: string;
     values: string[] | number[];
+    example: string | number | null;
+    description: string | null;
+};
+export type OneOfTemplateInput = {
+    typeName: string;
+    compositions: OneOfTemplateInputComposition[];
+};
+export type OneOfTemplateInputComposition = {
+    dataType?: TypeDataType | null;
+    templateInput?: TemplateInput;
+    source: 'inline' | 'referenced';
+    referencedType?: string;
+    content?: string;
+};
+export type VariableTemplateInput = {
+    typeName: string;
+    dataType: string;
+    primitiveType: string;
+    itemType?: string;
 };
+export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | VariableTemplateInput;
 export type GenerationResult = {
     groupedTypes: GroupedTypesOutput;
     types: GeneratedTypes;
@@ -99,6 +127,7 @@ export type GeneratedType = {
     content: string;
     references: Set<string>;
     primitives: Set<string>;
+    templateInput?: TemplateInput;
 };
 export type GroupedTypesOutput = Record<GroupName, GeneratedTypes>;
 export type GeneratedTypes = Record<TypeName, GeneratedType>;

package/dist/utils/index.d.ts

@@ -7,6 +7,7 @@ export declare function getRequiredKeys(object: unknown): string[];
 export declare function getReferencedTypes(object: unknown): string[];
 export declare function getReferencedTypeModules(_referencedTypes: unknown, _writtenAt: string): unknown[];
 export declare function toPascalCase(input: string): string;
+export declare function toPascalCaseHelper(input: unknown): string | unknown;
 export declare function registerTemplateHelpers(): void;
 export declare function readNestedValue(json: JSONObject, keyPath: string[]): JSONObject;
 export declare function generateRelativePath(fromPath: string, toPath: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-crafter",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",