type-crafter 0.12.2 → 0.13.1

package/dist/index.js

@@ -20548,23 +20548,29 @@ var YAML = /*#__PURE__*/Object.freeze({
 });
 
 function hasColorSupport() {
-    if (process.env.NO_COLOR !== undefined)
+    if (typeof process.env.NO_COLOR !== 'undefined') {
         return false;
-    if (process.env.FORCE_COLOR !== undefined)
+    }
+    if (typeof process.env.FORCE_COLOR !== 'undefined') {
         return true;
-    if (process.env.COLORTERM === 'truecolor' || process.env.COLORTERM === '24bit')
+    }
+    if (process.env.COLORTERM === 'truecolor' || process.env.COLORTERM === '24bit') {
         return true;
-    if (process.env.CI)
+    }
+    if (typeof process.env.CI !== 'undefined') {
         return true;
+    }
     const term = process.env.TERM ?? '';
-    if (term === 'dumb')
+    if (term === 'dumb') {
         return false;
+    }
     if (term.includes('256color') ||
         term.includes('color') ||
         term.includes('xterm') ||
         term.includes('screen') ||
-        term.includes('vt100'))
+        term.includes('vt100')) {
         return true;
+    }
     return process.stdout.isTTY ?? false;
 }
 const isColorSupported = hasColorSupport();
@@ -20579,8 +20585,9 @@ function bgRgb(r, g, b) {
     return `\x1b[48;2;${r};${g};${b}m`;
 }
 function colorize$2(text, ...codes) {
-    if (!isColorSupported)
+    if (!isColorSupported) {
         return text;
+    }
     return codes.join('') + text + RESET;
 }
 const BRAND$2 = {
@@ -20629,14 +20636,16 @@ function interpolateColor(start, end, t) {
     };
 }
 function gradientText(text, startColor, endColor) {
-    if (!isColorSupported)
+    if (!isColorSupported) {
         return text;
+    }
     // eslint-disable-next-line @typescript-eslint/no-misused-spread -- character-by-character gradient
     const chars = [...text];
     return chars
         .map((char, i) => {
-        if (char === ' ' || char === '\n')
+        if (char === ' ' || char === '\n') {
             return char;
+        }
         const t = chars.length > 1 ? i / (chars.length - 1) : 0;
         const color = interpolateColor(startColor, endColor, t);
         return rgb(color.r, color.g, color.b) + char;
@@ -20699,8 +20708,9 @@ function createSpinner(message) {
     spinnerFrame = 0;
     return {
         start: () => {
-            if (activeSpinner)
+            if (activeSpinner) {
                 clearInterval(activeSpinner);
+            }
             const render = () => {
                 clearSpinnerLine();
                 const frame = isColorSupported
@@ -20749,8 +20759,9 @@ function createSpinner(message) {
     };
 }
 function badge(text, bgColor, fgColor = FG.white) {
-    if (!isColorSupported)
+    if (!isColorSupported) {
         return `[${text}]`;
+    }
     return `${bgColor}${fgColor}${BOLD} ${text} ${RESET}`;
 }
 function logError(header, message = null) {
@@ -20883,12 +20894,26 @@ async function getExpectedWrittenPath(basePath, fileName) {
         : path.join(process.cwd(), basePath, fileName);
     return filePath;
 }
-async function writeFile(basePath, fileName, content) {
+async function safeReadContent(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch (e) {
+        return '';
+    }
+}
+async function writeFile(basePath, fileName, content, append = false) {
     const isAbsolutePath = path.isAbsolute(basePath);
     const filePath = isAbsolutePath
         ? path.join(basePath, fileName)
         : path.join(process.cwd(), basePath, fileName);
-    await fs.writeFile(filePath, content);
+    if (append) {
+        const existingData = await safeReadContent(filePath);
+        await fs.writeFile(filePath, content + existingData);
+    }
+    else {
+        await fs.writeFile(filePath, content);
+    }
 }
 async function readYaml(filePath) {
     const fileData = await readFile(filePath, true, true);
@@ -20986,7 +21011,7 @@ function handleErrors(error) {
     }
 }
 
-let config$2 = null;
+let config$3 = null;
 let specFileData = null;
 let objectSyntaxTemplate = null;
 let exporterModuleSyntaxTemplate = null;
@@ -20997,13 +21022,13 @@ let allOfSyntaxTemplate = null;
 const cachedReferencedTypes = new Map();
 let expectedOutputFiles = null;
 function setConfig(newConfig) {
-    config$2 = newConfig;
+    config$3 = newConfig;
 }
 function getConfig() {
-    if (config$2 === null) {
+    if (config$3 === null) {
         throw new RuntimeError('Failed to load configuration!');
     }
-    return config$2;
+    return config$3;
 }
 function setSpecFileData(newSpecFileData) {
     specFileData = newSpecFileData;
@@ -21072,10 +21097,10 @@ function cacheReferenceType(referencePath, generatedData) {
     cachedReferencedTypes.set(referencePath, generatedData);
 }
 function getInputFilePath(absolutePath = true) {
-    if (config$2 === null) {
+    if (config$3 === null) {
         throw new RuntimeError('Spec file path not set!');
     }
-    return absolutePath ? resolveFilePath(config$2.input) : config$2.input;
+    return absolutePath ? resolveFilePath(config$3.input) : config$3.input;
 }
 function getAllOfTemplate() {
     if (allOfSyntaxTemplate === null) {
@@ -21155,16 +21180,21 @@ function getReferencedTypeModules(_referencedTypes, _writtenAt) {
         return [];
     }
     const expectedOutputFiles = Runtime.getExpectedOutputFiles();
+    const modulePathConfig = Runtime.getConfig().language.modulePathConfig;
     const referencedTypeModules = {};
     for (const referenceType of referencedTypes) {
         const outputFile = expectedOutputFiles.get(referenceType);
         if (typeof outputFile !== 'undefined' &&
             resolveFilePath(outputFile.filePath) !== resolveFilePath(writtenAt)) {
             if (typeof referencedTypeModules[outputFile.modulePath] === 'undefined') {
+                const rawRelativePath = generateRelativePath(writtenAt, outputFile.modulePath);
+                const moduleName = outputFile.modulePath.split('/').pop() ?? '';
                 referencedTypeModules[outputFile.modulePath] = {
                     modulePath: outputFile.modulePath,
-                    moduleRelativePath: generateRelativePath(writtenAt, outputFile.modulePath),
-                    referencedTypes: [referenceType]
+                    moduleRelativePath: formatModulePath(rawRelativePath, writtenAt, modulePathConfig),
+                    referencedTypes: [referenceType],
+                    moduleName,
+                    fileBasedModules: moduleName === (modulePathConfig?.moduleFileName ?? '')
                 };
             }
             else {
@@ -21191,6 +21221,35 @@ function toPascalCaseHelper(input) {
     }
     return toPascalCase(inputString);
 }
+function toSnakeCase(input) {
+    return input
+        .replace(/[-]/g, '_')
+        .replace(/(?<upper>[A-Z]+)(?<next>[A-Z][a-z])/g, '$1_$2')
+        .replace(/(?<lower>[a-z\d])(?<cap>[A-Z])/g, '$1_$2')
+        .toLowerCase()
+        .replace(/__+/g, '_');
+}
+function toSnakeCaseHelper(input) {
+    const inputString = decodeString(input);
+    if (inputString === null) {
+        return input;
+    }
+    return toSnakeCase(inputString);
+}
+function toCamelCase(input) {
+    const pascal = toPascalCase(input);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function formatCase(input, fontCase) {
+    switch (fontCase) {
+        case 'snake_case':
+            return toSnakeCase(input);
+        case 'PascalCase':
+            return toPascalCase(input);
+        case 'camelCase':
+            return toCamelCase(input);
+    }
+}
 function refineJSONKey(input) {
     if (typeof input === 'string' && input.includes('-')) {
         return `'${input}'`;
@@ -21209,6 +21268,19 @@ function refineIndexKey(input) {
     }
     return input;
 }
+function escapeReservedWord(input) {
+    if (typeof input !== 'string') {
+        return input;
+    }
+    const config = Runtime.getConfig().language.reservedKeywords;
+    if (typeof config === 'undefined') {
+        return input;
+    }
+    if (config.words.includes(input)) {
+        return config.prefix + input;
+    }
+    return input;
+}
 function registerTemplateHelpers() {
     Handlebars.registerHelper('getOptionalKeys', getOptionalKeys);
     Handlebars.registerHelper('getRequiredKeys', getRequiredKeys);
@@ -21216,6 +21288,7 @@ function registerTemplateHelpers() {
     Handlebars.registerHelper('getReferencedTypes', getReferencedTypes);
     Handlebars.registerHelper('getReferencedTypeModules', getReferencedTypeModules);
     Handlebars.registerHelper('toPascalCase', toPascalCaseHelper);
+    Handlebars.registerHelper('toSnakeCase', toSnakeCaseHelper);
     Handlebars.registerHelper('isNonEmptyArray', (value) => Array.isArray(value) && value.length === 0);
     Handlebars.registerHelper('eq', (value1, value2) => value1 === value2);
     Handlebars.registerHelper('notEq', (value1, value2) => value1 !== value2);
@@ -21223,6 +21296,8 @@ function registerTemplateHelpers() {
     Handlebars.registerHelper('jsonKey', refineJSONKey);
     Handlebars.registerHelper('variableName', refineVariableName);
     Handlebars.registerHelper('indexKey', refineIndexKey);
+    Handlebars.registerHelper('escapeReservedWord', escapeReservedWord);
+    Handlebars.registerHelper('stringify', (value) => JSON.stringify(value));
     Handlebars.registerHelper('not', (value) => {
         if (typeof value === 'boolean') {
             return !value;
@@ -21265,6 +21340,30 @@ function generateRelativePath(fromPath, toPath) {
     pathPrefix = pathPrefix === '' ? './' : pathPrefix;
     return pathPrefix + toPathArray.slice(diffIndex).join('/');
 }
+function formatModulePath(relativePath, writtenAt, config) {
+    let path = relativePath.replace(/^\.\//, '');
+    const isModuleFile = writtenAt.endsWith('/' + config.moduleFileName) ||
+        writtenAt.endsWith('\\' + config.moduleFileName);
+    let parentCount = config.fileBasedModules && !isModuleFile ? 1 : 0;
+    while (path.startsWith('../')) {
+        parentCount++;
+        path = path.slice(3);
+    }
+    const moduleFileRegex = new RegExp(`\\/?${config.moduleFileName}$`);
+    path = path.replace(moduleFileRegex, '').replace(/\/$/, '');
+    const parentPart = parentCount > 0 ? Array(parentCount).fill(config.parentRef).join(config.separator) : '';
+    if (path === '' && parentPart === '') {
+        return config.selfRef;
+    }
+    if (path === '') {
+        return parentPart;
+    }
+    const formattedPath = path.replace(/\//g, config.separator);
+    if (parentPart === '') {
+        return formattedPath;
+    }
+    return parentPart + config.separator + formattedPath;
+}
 // #region string utils
 function stripPrefix(value, prefix) {
     return value.startsWith(prefix) ? value.slice(prefix.length) : value;
@@ -21513,8 +21612,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
             const referencedType = await generateReferencedType(propertyName, propertyDetails, parentTypes);
             recursivePropertyName = referencedType.templateInput.typeName;
             languageDataType = recursivePropertyName;
-            references.push(...referencedType.references);
-            primitives.push(...referencedType.primitives);
+            references.push(recursivePropertyName);
             isReferenced = true;
         }
         else if (enumValues !== null) {
@@ -21628,6 +21726,18 @@ async function generateArrayType(typeName, typeInfo, parentTypes) {
     }
     else {
         arrayItemsType = await generateType(typeName + 'Item', typeInfo.items, parentTypes);
+        // For referenced types (e.g. enums via $ref), use the type name as the item type
+        // identifier, consistent with how inline enums are handled above.
+        // Also only keep the direct reference — the referenced type handles its own imports.
+        // Create new objects to avoid mutating cached data from generateReferencedType.
+        if (typeInfo.items.$ref !== null) {
+            const refItemTypeName = arrayItemsType.templateInput.typeName;
+            arrayItemsType = {
+                ...arrayItemsType,
+                templateInput: { ...arrayItemsType.templateInput, type: refItemTypeName },
+                references: new Set([refItemTypeName])
+            };
+        }
     }
     if (typeof arrayItemsType.templateInput?.type === 'undefined') {
         throw new InvalidSpecFileError('Invalid array type for: ' + typeName);
@@ -21893,28 +22003,41 @@ async function generator(specFileData) {
         }
     }
     result.groupedTypes = groupedTypes;
+    // remove self references from grouped types
+    for (const groupName in result.groupedTypes) {
+        for (const typeName in result.groupedTypes[groupName]) {
+            result.groupedTypes[groupName][typeName].references.delete(typeName);
+        }
+    }
     return result;
 }
 
+function formatModuleName(name) {
+    const moduleNameCase = Runtime.getConfig().language.modulePathConfig.moduleNameCase;
+    return typeof moduleNameCase !== 'undefined' ? formatCase(name, moduleNameCase) : name;
+}
 function generateTypesOutputFiles(types, groupName = null) {
     const config = Runtime.getConfig();
     const extension = config.output.fileExtension;
     const outputDir = config.output.directory;
     const moduleFileName = config.language.exporterModuleName;
     const writerMode = groupName === null ? config.output.writerMode.types : config.output.writerMode.groupedTypes;
+    const formattedGroupName = groupName !== null ? formatModuleName(groupName) : null;
     const result = new Map();
     for (const typeName in types) {
         const typeProperties = types[typeName];
         if (typeof typeProperties !== 'undefined') {
+            const formattedTypeName = formatModuleName(typeName);
             result.set(typeName, {
                 modulePath: outputDir +
                     '/' +
-                    (writerMode === 'FolderWithFiles' ? (groupName ?? '') + '/' : '') +
-                    moduleFileName,
+                    (formattedGroupName
+                        ? formattedGroupName + (writerMode === 'FolderWithFiles' ? '/' + moduleFileName : '')
+                        : moduleFileName),
                 filePath: outputDir +
                     (writerMode === 'Files' || writerMode === 'FolderWithFiles'
-                        ? '/' + (groupName ?? '') + typeName
-                        : '/' + (groupName ?? 'types')),
+                        ? '/' + (formattedGroupName ?? '') + formattedTypeName
+                        : '/' + (formattedGroupName ?? 'types')),
                 extension
             });
         }
@@ -21935,7 +22058,8 @@ function generateExpectedOutputFile() {
     // Generating expect writing types for referenced types
     let referredGroups = {};
     for (const generatedRefData of Runtime.getCachedReferencedTypes().values()) {
-        if (typeof generatedRefData.sourceFile !== 'undefined' &&
+        if (generatedRefData.type !== 'local' &&
+            typeof generatedRefData.sourceFile !== 'undefined' &&
             generatedRefData.completeSource !== Runtime.getInputFilePath() // Preventing new file creation for remote references from base file
         ) {
             const groupName = toPascalCase(generatedRefData.sourceFile.replace('.yaml', ''));
@@ -21971,7 +22095,7 @@ async function writeTypesToFiles(config, types, folderName = '') {
     const typeNames = Object.keys(types);
     for (const typeName in types) {
         const typeData = types[typeName];
-        const file = typeName + config.output.fileExtension;
+        const file = formatModuleName(typeName) + config.output.fileExtension;
         const references = filterReferences
             ? [...types[typeName].references].filter((x) => !typeNames.includes(x))
             : [...types[typeName].references];
@@ -21990,7 +22114,7 @@ async function writeTypesToFiles(config, types, folderName = '') {
     }
     return result;
 }
-async function writeTypesToFile(config, types, fileName = 'types') {
+async function writeTypesToFile(config, types, fileName) {
     const templateInput = {
         referencedTypes: [],
         primitives: [],
@@ -22020,7 +22144,13 @@ async function writeExporterModules(files, folder) {
     const exporterModuleContent = Runtime.getExporterModuleTemplate()({
         modules: [...files].map((file) => file.replace(Runtime.getConfig().output.fileExtension, ''))
     });
-    await writeFile(folder, Runtime.getConfig().language.exporterModuleName + Runtime.getConfig().output.fileExtension, exporterModuleContent);
+    const config = Runtime.getConfig();
+    // Merging the contents of exporter module & types file in case their names are same.
+    const typesFileName = Runtime.getConfig().output.typesFileName;
+    const moduleExporterFileName = Runtime.getConfig().language.exporterModuleName;
+    const writingTypesFile = files.has(typesFileName + config.output.fileExtension);
+    const appendContent = writingTypesFile && typesFileName === moduleExporterFileName;
+    await writeFile(folder, Runtime.getConfig().language.exporterModuleName + Runtime.getConfig().output.fileExtension, exporterModuleContent, appendContent);
 }
 async function writeOutput(generationResult) {
     const config = Runtime.getConfig();
@@ -22031,28 +22161,30 @@ async function writeOutput(generationResult) {
     const writtenFiles = new Map();
     // pre compute all the folders and files that will be written
     Runtime.setExpectedOutputFiles(generateExpectedOutputFile());
-    // writing types to output directory
+    // #region writing types to output directory
     let typesFilesWritten = null;
     if (Object.keys(generationResult.types).length > 0) {
         if (config.output.writerMode.types === 'Files') {
             typesFilesWritten = await writeTypesToFiles(config, generationResult.types);
         }
         else if (config.output.writerMode.types === 'SingleFile') {
-            typesFilesWritten = await writeTypesToFile(config, generationResult.types);
+            typesFilesWritten = await writeTypesToFile(config, generationResult.types, Runtime.getConfig().output.typesFileName);
         }
     }
     if (typesFilesWritten !== null) {
         addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(typesFilesWritten.folderName), typesFilesWritten.files);
     }
-    // writing grouped types to output directory
+    // #endregion
+    // #region writing grouped types to output directory
     if (config.output.writerMode.groupedTypes === 'FolderWithFiles') {
         for (const groupName in generationResult.groupedTypes) {
             let groupFilesWritten = null;
-            await createFolderWithBasePath(config.output.directory, groupName);
+            const formattedGroupName = formatModuleName(groupName);
+            await createFolderWithBasePath(config.output.directory, formattedGroupName);
             addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(config.output.directory), [
-                groupName
+                formattedGroupName
             ]);
-            groupFilesWritten = await writeTypesToFiles(config, generationResult.groupedTypes[groupName], groupName);
+            groupFilesWritten = await writeTypesToFiles(config, generationResult.groupedTypes[groupName], formattedGroupName);
             if (groupFilesWritten !== null) {
                 addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(groupFilesWritten.folderName), groupFilesWritten.files);
             }
@@ -22061,18 +22193,19 @@ async function writeOutput(generationResult) {
     else if (config.output.writerMode.groupedTypes === 'SingleFile') {
         for (const groupName in generationResult.groupedTypes) {
             let groupFilesWritten = null;
-            groupFilesWritten = await writeTypesToFile(config, generationResult.groupedTypes[groupName], groupName);
+            groupFilesWritten = await writeTypesToFile(config, generationResult.groupedTypes[groupName], formatModuleName(groupName));
             if (groupFilesWritten !== null) {
                 addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(groupFilesWritten.folderName), groupFilesWritten.files);
             }
         }
     }
+    // #endregion
     writtenFiles.forEach((files, folder) => {
         void writeExporterModules(files, folder);
     });
 }
 
-async function config$1(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
+async function config$2(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
     const devMode = 'PRODUCTION'.includes('DEVELOPMENT');
     // PRODUCTION will be replaced with PRODUCTION when package is built.
     const directoryPrefix = devMode ? 'src/' : './';
@@ -22088,6 +22221,7 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
             cleanWrite: true,
             fileExtension: '.ts',
             directory: outputDirectory,
+            typesFileName: 'types',
             writerMode: {
                 groupedTypes: groupedTypesWriterMode,
                 types: typesWriterMode
@@ -22111,13 +22245,20 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
                 array: '~ItemType~[]',
                 object: 'type',
                 unknown: 'unknown'
+            },
+            modulePathConfig: {
+                separator: '/',
+                parentRef: '..',
+                selfRef: '.',
+                moduleFileName: 'index',
+                fileBasedModules: false
             }
         }
     };
     return config;
 }
 
-async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
+async function config$1(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
     const devMode = 'PRODUCTION'.includes('DEVELOPMENT');
     const directoryPrefix = devMode ? 'src/' : './';
     const objectSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/object-syntax.hbs', devMode);
@@ -22132,6 +22273,7 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
             cleanWrite: true,
             fileExtension: '.ts',
             directory: outputDirectory,
+            typesFileName: 'types',
             writerMode: {
                 groupedTypes: groupedTypesWriterMode,
                 types: typesWriterMode
@@ -22155,6 +22297,123 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
                 array: '~ItemType~[]',
                 object: 'type',
                 unknown: 'unknown'
+            },
+            modulePathConfig: {
+                separator: '/',
+                parentRef: '..',
+                selfRef: '.',
+                moduleFileName: 'index',
+                fileBasedModules: false
+            }
+        }
+    };
+    return config;
+}
+
+async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
+    const devMode = 'PRODUCTION'.includes('DEVELOPMENT');
+    // PRODUCTION will be replaced with PRODUCTION when package is built.
+    const directoryPrefix = devMode ? 'src/' : './';
+    const objectSyntax = await readFile(directoryPrefix + 'templates/rust/object-syntax.hbs', devMode);
+    const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/rust/exporter-module-syntax.hbs', devMode);
+    const typesFileSyntax = await readFile(directoryPrefix + 'templates/rust/types-file-syntax.hbs', devMode);
+    const enumSyntax = await readFile(directoryPrefix + 'templates/rust/enum-syntax.hbs', devMode);
+    const oneOfSyntax = await readFile(directoryPrefix + 'templates/rust/oneOf-syntax.hbs', devMode);
+    const allOfSyntax = await readFile(directoryPrefix + 'templates/rust/allOf-syntax.hbs', devMode);
+    const config = {
+        input: inputFilePath,
+        output: {
+            cleanWrite: true,
+            fileExtension: '.rs',
+            directory: outputDirectory,
+            typesFileName: 'mod',
+            writerMode: {
+                groupedTypes: groupedTypesWriterMode,
+                types: typesWriterMode
+            }
+        },
+        template: {
+            objectSyntax,
+            exporterModuleSyntax,
+            typesFileSyntax,
+            enumSyntax,
+            oneOfSyntax,
+            allOfSyntax
+        },
+        language: {
+            exporterModuleName: 'mod',
+            typeMapper: {
+                string: { default: 'String' },
+                number: { default: 'i32' },
+                integer: { default: 'i32' },
+                boolean: 'bool',
+                array: 'Vec<~ItemType~>',
+                object: 'type',
+                unknown: 'String'
+            },
+            modulePathConfig: {
+                separator: '::',
+                parentRef: 'super',
+                selfRef: 'self',
+                moduleFileName: 'mod',
+                fileBasedModules: true,
+                moduleNameCase: 'snake_case'
+            },
+            reservedKeywords: {
+                prefix: 'r#',
+                words: [
+                    'as',
+                    'break',
+                    'const',
+                    'continue',
+                    'crate',
+                    'else',
+                    'enum',
+                    'extern',
+                    'false',
+                    'fn',
+                    'for',
+                    'if',
+                    'impl',
+                    'in',
+                    'let',
+                    'loop',
+                    'match',
+                    'mod',
+                    'move',
+                    'mut',
+                    'pub',
+                    'ref',
+                    'return',
+                    'self',
+                    'Self',
+                    'static',
+                    'struct',
+                    'super',
+                    'trait',
+                    'true',
+                    'type',
+                    'unsafe',
+                    'use',
+                    'where',
+                    'while',
+                    'async',
+                    'await',
+                    'dyn',
+                    'abstract',
+                    'become',
+                    'box',
+                    'do',
+                    'final',
+                    'macro',
+                    'override',
+                    'priv',
+                    'typeof',
+                    'unsized',
+                    'virtual',
+                    'yield',
+                    'try'
+                ]
             }
         }
     };
@@ -22192,9 +22451,12 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
         let generatorConfig = null;
         switch (language.toLowerCase()) {
             case 'typescript':
-                generatorConfig = await config$1(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode);
+                generatorConfig = await config$2(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode);
                 break;
             case 'typescript-with-decoders':
+                generatorConfig = await config$1(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode);
+                break;
+            case 'rust':
                 generatorConfig = await config(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode);
                 break;
             default:
@@ -22224,7 +22486,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.12.2');
+const program = new Command().version('0.13.1');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

package/dist/templates/index.d.ts

@@ -1,2 +1,3 @@
 export * as typescript from './typescript';
 export * as typescriptWithDecoders from './typescript-with-decoders';
+export * as rust from './rust';

package/dist/templates/rust/allOf-syntax.hbs

@@ -0,0 +1,26 @@
+{{#if description}}
+/// {{{description}}}
+{{/if}}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct {{typeName}} {
+{{#each compositions}}
+{{#if (eq this.source 'referenced')}}
+    #[serde(flatten)]
+    pub {{escapeReservedWord (toSnakeCase this.referencedType)}}: {{this.referencedType}},
+{{else if (eq this.source 'inline')}}
+{{#if (eq this.dataType 'object')}}
+    #[serde(flatten)]
+    pub {{escapeReservedWord (toSnakeCase this.templateInput.typeName)}}: {{this.templateInput.typeName}},
+{{else}}
+    pub {{escapeReservedWord (toSnakeCase this.templateInput.typeName)}}: {{{this.templateInput.type}}},
+{{/if}}
+{{/if}}
+{{/each}}
+}
+{{#each compositions}}
+{{#if (eq this.source 'inline')}}
+{{#if (eq this.dataType 'object')}}
+{{{this.content}}}
+{{/if}}
+{{/if}}
+{{/each}}

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

@@ -0,0 +1,17 @@
+{{#if description}}
+/// {{{description}}}
+{{/if}}
+{{#if example}}
+/// Example: {{{example}}}
+{{/if}}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum {{typeName}} {
+{{#each values}}
+{{#if (eq ../type 'string')}}
+    #[serde(rename = "{{this}}")]
+    {{{toPascalCase this}}},
+{{else}}
+    Value{{{this}}},
+{{/if}}
+{{/each}}
+}

package/dist/templates/rust/exporter-module-syntax.hbs

@@ -0,0 +1,3 @@
+{{#each modules}}
+pub mod {{this}};
+{{/each}}

package/dist/templates/rust/index.d.ts

@@ -0,0 +1,2 @@
+import type { Configuration, TypesWriterMode, GroupedTypesWriterMode } from '$types';
+export declare function config(inputFilePath: string, outputDirectory: string, typesWriterMode: TypesWriterMode, groupedTypesWriterMode: GroupedTypesWriterMode): Promise<Configuration>;

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

@@ -0,0 +1,23 @@
+{{#if description}}
+/// {{{description}}}
+{{/if}}
+{{#if example}}
+/// Example: {{{example}}}
+{{/if}}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct {{typeName}} {
+{{#each properties}}
+{{#if this.description}}
+    /// {{{this.description}}}
+{{/if}}
+    #[serde(rename = "{{@key}}")]
+{{#unless this.required}}
+    #[serde(skip_serializing_if = "Option::is_none")]
+{{/unless}}
+    pub {{escapeReservedWord (toSnakeCase @key)}}: {{#unless this.required}}Option<{{/unless}}{{{this.type}}}{{#unless this.required}}>{{/unless}},
+{{/each}}
+{{#if additionalProperties}}
+    #[serde(flatten)]
+    pub additional_properties: std::collections::HashMap<{{{additionalProperties.keyType}}}, {{{additionalProperties.valueType}}}>,
+{{/if}}
+}

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

@@ -0,0 +1,25 @@
+{{#if description}}
+/// {{{description}}}
+{{/if}}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum {{typeName}} {
+{{#each compositions}}
+{{#if (eq this.source 'referenced')}}
+    {{this.referencedType}}({{this.referencedType}}),
+{{else if (eq this.source 'inline')}}
+{{#if this.templateInput.values}}
+    {{this.templateInput.typeName}}({{this.templateInput.typeName}}),
+{{else if (eq this.dataType 'object')}}
+    {{this.templateInput.typeName}}({{this.templateInput.typeName}}),
+{{else}}
+    {{this.templateInput.typeName}}({{{this.templateInput.type}}}),
+{{/if}}
+{{/if}}
+{{/each}}
+}
+{{#each compositions}}
+{{#if (eq this.source 'inline')}}
+{{{this.content}}}
+{{/if}}
+{{/each}}

package/dist/templates/rust/types-file-syntax.hbs

@@ -0,0 +1,12 @@
+use serde::{Serialize, Deserialize};
+{{#each (getReferencedTypeModules referencedTypes writtenAt)}}
+{{#each this.referencedTypes}}
+{{#if ../fileBasedModules}}
+use {{{../moduleRelativePath}}}::{{toSnakeCase this}}::{{this}};
+{{else}}
+use {{{../moduleRelativePath}}}::{{this}};
+{{/if}}
+{{/each}}
+{{/each}}
+
+{{{typesContent}}}

package/dist/types/index.d.ts

@@ -9,6 +9,7 @@ export type OutputConfig = {
     cleanWrite: boolean;
     fileExtension: string;
     directory: string;
+    typesFileName: string;
     writerMode: {
         groupedTypes: GroupedTypesWriterMode;
         types: TypesWriterMode;
@@ -24,9 +25,24 @@ export type Template = {
     oneOfSyntax: string;
     allOfSyntax: string;
 };
+export type FontCase = 'snake_case' | 'PascalCase' | 'camelCase';
+export type ModulePathConfig = {
+    separator: string;
+    parentRef: string;
+    selfRef: string;
+    moduleFileName: string;
+    fileBasedModules: boolean;
+    moduleNameCase?: FontCase;
+};
+export type ReservedKeywordsConfig = {
+    words: string[];
+    prefix: string;
+};
 export type LanguageConfig = {
     exporterModuleName: string;
     typeMapper: LanguageTypeMapper;
+    modulePathConfig: ModulePathConfig;
+    reservedKeywords?: ReservedKeywordsConfig;
 };
 /**
  * @description Mappers for all the types supported by OpenAPI 3.0.0
@@ -139,6 +155,8 @@ export type ReferencedModule = {
     modulePath: string;
     moduleRelativePath: string;
     referencedTypes: string[];
+    moduleName: string;
+    fileBasedModules: boolean;
 };
 export type EnumTemplateInput = TypeDescriptors & {
     typeName: string;

package/dist/utils/file-system.d.ts

@@ -5,5 +5,5 @@ export declare function createFolder(folderPath: string): Promise<void>;
 export declare function deleteFolder(folderPath: string): Promise<void>;
 export declare function getCompleteFolderPath(folderName: string): Promise<string>;
 export declare function getExpectedWrittenPath(basePath: string, fileName: string): Promise<string>;
-export declare function writeFile(basePath: string, fileName: string, content: string): Promise<void>;
+export declare function writeFile(basePath: string, fileName: string, content: string, append?: boolean): Promise<void>;
 export declare function readYaml(filePath: string): Promise<unknown>;

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { type TypeInfo, type TypeDataType } from '$types';
+import { type ModulePathConfig, type FontCase, type TypeInfo, type TypeDataType } from '$types';
 import { type JSONObject } from 'type-decoder';
 export * from './file-system';
 export * from './logger';
@@ -9,12 +9,18 @@ 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 toSnakeCase(input: string): string;
+export declare function toSnakeCaseHelper(input: unknown): string | unknown;
+export declare function toCamelCase(input: string): string;
+export declare function formatCase(input: string, fontCase: FontCase): string;
 export declare function refineJSONKey(input: unknown): unknown;
 export declare function refineVariableName(input: unknown): unknown;
 export declare function refineIndexKey(input: unknown): unknown;
+export declare function escapeReservedWord(input: unknown): unknown;
 export declare function registerTemplateHelpers(): void;
 export declare function readNestedValue(json: unknown, keyPath: string[]): JSONObject;
 export declare function generateRelativePath(fromPath: string, toPath: string): string;
+export declare function formatModulePath(relativePath: string, writtenAt: string, config: ModulePathConfig): string;
 export declare function stripPrefix(value: string, prefix: string): string;
 export declare function isPrimitiveType(typeInfo: TypeInfo): boolean;
 export declare function isSimplePrimitiveType(type: TypeDataType | null): boolean;

package/dist/writer/helpers.d.ts

@@ -1,3 +1,4 @@
 import { type TypeFilePath, type Types } from '$types';
+export declare function formatModuleName(name: string): string;
 export declare function generateTypesOutputFiles(types: Types | null, groupName?: string | null): Map<string, TypeFilePath>;
 export declare function generateExpectedOutputFile(): Map<string, TypeFilePath>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-crafter",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",
@@ -15,8 +15,8 @@
   ],
   "scripts": {
     "dev": "tsc --watch",
-    "format:all": "npx prettier --write .",
-    "lint:all": "eslint src",
+    "format": "npx prettier --write .",
+    "lint": "eslint src",
     "clean:output": "rm -rf dist",
     "build": "npm run clean:output && rollup --config rollup.config.js"
   },
@@ -49,12 +49,12 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "^25.2.0",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
+    "@types/node": "^25.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
     "commander": "^14.0.3",
-    "eslint": "^9.39.2",
-    "eslint-config-love": "^149.0.0",
+    "eslint": "^10.0.0",
+    "eslint-config-love": "^150.0.0",
     "eslint-config-prettier": "^10.1.8",
     "handlebars": "^4.7.8",
     "husky": "^9.1.7",
@@ -62,7 +62,7 @@
     "rollup": "^4.57.1",
     "rollup-plugin-copy": "^3.5.0",
     "tslib": "^2.8.1",
-    "type-decoder": "^2.2.0",
+    "type-decoder": "^2.3.0",
     "typescript": "^5.9.3",
     "yaml": "^2.8.2"
   }