@currentjs/gen 0.1.1

package/dist/commands/generateAll.js

@@ -0,0 +1,305 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGenerateAll = handleGenerateAll;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cliUtils_1 = require("../utils/cliUtils");
+const yaml_1 = require("yaml");
+const domainModelGenerator_1 = require("../generators/domainModelGenerator");
+const validationGenerator_1 = require("../generators/validationGenerator");
+const serviceGenerator_1 = require("../generators/serviceGenerator");
+const controllerGenerator_1 = require("../generators/controllerGenerator");
+const storeGenerator_1 = require("../generators/storeGenerator");
+const templateGenerator_1 = require("../generators/templateGenerator");
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const constants_1 = require("../utils/constants");
+async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
+    var _a, _b;
+    const appYamlPath = (0, cliUtils_1.resolveYamlPath)(yamlPathArg);
+    (0, generationRegistry_1.initGenerationRegistry)(process.cwd());
+    const raw = fs.readFileSync(appYamlPath, 'utf8');
+    const appConfig = (0, yaml_1.parse)(raw);
+    const modulesList = ((_a = appConfig === null || appConfig === void 0 ? void 0 : appConfig.modules) !== null && _a !== void 0 ? _a : []).map(m => (typeof m === 'string' ? m : m.module));
+    const providersConfig = appConfig === null || appConfig === void 0 ? void 0 : appConfig.providers;
+    const databaseProviderName = appConfig === null || appConfig === void 0 ? void 0 : appConfig.database;
+    const shouldIncludeModule = (moduleYamlRel) => {
+        if (!moduleName || moduleName === '*')
+            return true;
+        const moduleNameLc = moduleName.toLowerCase();
+        const relNormalized = moduleYamlRel.replace(/\\/g, '/').toLowerCase();
+        if (relNormalized.endsWith(`/${moduleNameLc}.yaml`))
+            return true;
+        const moduleYamlPath = path.isAbsolute(moduleYamlRel)
+            ? moduleYamlRel
+            : path.resolve(process.cwd(), moduleYamlRel);
+        const dirName = path.basename(path.dirname(moduleYamlPath)).toLowerCase();
+        if (dirName === moduleNameLc)
+            return true;
+        // Allow passing a path fragment
+        if (relNormalized.includes(`/${moduleNameLc}/`) || relNormalized.endsWith(`/${moduleNameLc}`))
+            return true;
+        return false;
+    };
+    const filteredModules = modulesList.filter(shouldIncludeModule);
+    if (filteredModules.length === 0) {
+        // eslint-disable-next-line no-console
+        console.warn(colors_1.colors.yellow(`No modules matched: ${moduleName}`));
+        return;
+    }
+    const domainGen = new domainModelGenerator_1.DomainModelGenerator();
+    const valGen = new validationGenerator_1.ValidationGenerator();
+    const svcGen = new serviceGenerator_1.ServiceGenerator();
+    const ctrlGen = new controllerGenerator_1.ControllerGenerator();
+    const storeGen = new storeGenerator_1.StoreGenerator();
+    const tplGen = new templateGenerator_1.TemplateGenerator();
+    const initsBySrcDir = new Map();
+    // Run modules sequentially to avoid overlapping interactive prompts
+    for (const moduleYamlRel of filteredModules) {
+        const moduleYamlPath = path.isAbsolute(moduleYamlRel)
+            ? moduleYamlRel
+            : path.resolve(process.cwd(), moduleYamlRel);
+        if (!fs.existsSync(moduleYamlPath)) {
+            // eslint-disable-next-line no-console
+            console.warn(colors_1.colors.yellow(`Module YAML not found: ${moduleYamlPath}`));
+            continue;
+        }
+        const moduleDir = path.dirname(moduleYamlPath);
+        // Output folders inside module structure
+        const domainOut = path.join(moduleDir, 'domain', 'entities');
+        const appOut = path.join(moduleDir, 'application');
+        const infraOut = path.join(moduleDir, 'infrastructure');
+        fs.mkdirSync(domainOut, { recursive: true });
+        fs.mkdirSync(appOut, { recursive: true });
+        fs.mkdirSync(infraOut, { recursive: true });
+        // Domain entities
+        // eslint-disable-next-line no-await-in-loop
+        await domainGen.generateAndSaveFiles(moduleYamlPath, domainOut, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
+        // Generate and save via per-generator write logic
+        // eslint-disable-next-line no-await-in-loop
+        await valGen.generateAndSaveFiles(moduleYamlPath, appOut, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
+        await svcGen.generateAndSaveFiles(moduleYamlPath, appOut, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
+        const generatedControllers = await ctrlGen.generateAndSaveFiles(moduleYamlPath, infraOut, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
+        await tplGen.generateAndSaveFiles(moduleYamlPath, undefined, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
+        // Find nearest ancestor containing src/app.ts and collect controller inits for a single write later
+        let probeDir = moduleDir;
+        let srcDir = null;
+        for (let i = 0; i < 6; i += 1) {
+            const candidate = path.join(probeDir, 'src', constants_1.COMMON_FILES.APP_TS);
+            if (fs.existsSync(candidate)) {
+                srcDir = path.join(probeDir, 'src');
+                break;
+            }
+            const parent = path.dirname(probeDir);
+            if (parent === probeDir)
+                break;
+            probeDir = parent;
+        }
+        if (!srcDir)
+            continue;
+        const list = (_b = initsBySrcDir.get(srcDir)) !== null && _b !== void 0 ? _b : [];
+        for (const filePath of generatedControllers) {
+            const rel = path
+                .relative(srcDir, filePath)
+                .replace(/\\/g, '/')
+                .replace(/\.ts$/, '');
+            const ctrlName = path.basename(rel);
+            const importPath = rel.startsWith('.') ? rel : `./${rel}`;
+            const baseEntityName = ctrlName.endsWith('ApiController')
+                ? ctrlName.slice(0, -'ApiController'.length)
+                : ctrlName.endsWith('WebController')
+                    ? ctrlName.slice(0, -'WebController'.length)
+                    : ctrlName.replace('Controller', '');
+            const entityName = baseEntityName;
+            const entityVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+            const m = rel.match(/modules\/([^/]+)\/infrastructure\/controllers\//);
+            const moduleFolder = m ? m[1] : undefined;
+            if (!moduleFolder)
+                continue;
+            const storeImportPath = `${constants_1.PATH_PATTERNS.MODULES_RELATIVE}${moduleFolder}/${constants_1.PATH_PATTERNS.INFRASTRUCTURE}/${constants_1.PATH_PATTERNS.STORES}/${entityName}${constants_1.GENERATOR_SUFFIXES.STORE}`;
+            const serviceImportPath = `${constants_1.PATH_PATTERNS.MODULES_RELATIVE}${moduleFolder}/${constants_1.PATH_PATTERNS.APPLICATION}/${constants_1.PATH_PATTERNS.SERVICES}/${entityName}${constants_1.GENERATOR_SUFFIXES.SERVICE}`;
+            //const authImportPath = `./modules/${moduleFolder}/application/auth/AuthService`;
+            // const hasAuth = true;//fs.existsSync(path.join(srcDir, authImportPath + '.ts'));
+            const init = {
+                ctrlName,
+                entityName,
+                entityVar,
+                importController: `import { ${ctrlName} } from '${importPath}';`,
+                importStore: `import { ${entityName}Store } from '${storeImportPath}';`,
+                importService: `import { ${entityName}Service } from '${serviceImportPath}';`,
+                importAuth: undefined, //hasAuth ? `import { AuthService } from '${authImportPath}';` : undefined,
+                wiring: [
+                    `const ${entityVar}Store = new ${entityName}Store(db);`,
+                    `const ${entityVar}Service = new ${entityName}Service(${entityVar}Store);`
+                ],
+                registration: `new ${ctrlName}(${entityVar}Service)`
+            };
+            // Avoid duplicates by controller (keep both Api/Web), dedupe wiring later by entityName
+            if (!list.find((x) => x.ctrlName === init.ctrlName))
+                list.push(init);
+        }
+        initsBySrcDir.set(srcDir, list);
+        await storeGen.generateAndSaveFiles(moduleYamlPath, infraOut, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
+    }
+    // Single write per app: inject imports and rewrite block between markers
+    let isIProviderImported = false;
+    for (const [srcDir, controllerInits] of initsBySrcDir.entries()) {
+        try {
+            const appTsPath = path.join(srcDir, constants_1.COMMON_FILES.APP_TS);
+            if (!fs.existsSync(appTsPath))
+                continue;
+            let appTs = fs.readFileSync(appTsPath, 'utf8');
+            // Build providers import and initialization from app.yaml providers section
+            const importLines = [];
+            const providerInitLines = [];
+            const providersArrayEntries = [];
+            if (providersConfig && Object.keys(providersConfig).length > 0) {
+                for (const [provName, mod] of Object.entries(providersConfig)) {
+                    if (!mod)
+                        continue;
+                    // Assume default import name from module spec after last '/'
+                    const baseName = mod.split('/').pop() || 'provider';
+                    const className = baseName
+                        .replace(/^[^a-zA-Z_]*/g, '')
+                        .split(/[-_]/)
+                        .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+                        .join('');
+                    importLines.push(`import { ${className}${!isIProviderImported ? ', IProvider, ISqlProvider' : ''} } from '${mod}';`);
+                    if (!isIProviderImported)
+                        isIProviderImported = true;
+                    // Read provider configuration from env by name, parse JSON if possible, pass as is
+                    providerInitLines.push(`  ${provName}: new ${className}((() => {
+    const raw = process.env.${provName.toUpperCase()} || '';
+    try { return raw ? JSON.parse(raw) : undefined; } catch { return raw; }
+  })())`);
+                    providersArrayEntries.push(provName);
+                }
+            }
+            else {
+                // Fallback to MySQL provider if no providers configured
+                importLines.push(`import { ProviderMysql, ISqlProvider } from '@currentjs/provider-mysql';`);
+                providerInitLines.push(`  mysql: new ProviderMysql((() => {
+    const raw = process.env.MYSQL || '';
+    try { return raw ? JSON.parse(raw) : undefined; } catch { return raw; }
+  })())`);
+                providersArrayEntries.push('mysql');
+            }
+            const ensureDbLine = `const providers: Record<string, IProvider> = {\n${providerInitLines.join(',\n')}\n};\nconst db = providers['${databaseProviderName || providersArrayEntries[0]}'] as ISqlProvider;`;
+            // Ensure router import for server (app template already imports templating)
+            if (!appTs.includes("from '@currentjs/router'")) {
+                importLines.push(`import { createWebServer, createStaticServer } from '@currentjs/router';`);
+            }
+            for (const il of importLines) {
+                if (!appTs.includes(il)) {
+                    appTs = il + '\n' + appTs;
+                }
+            }
+            // Ensure MySQL provider import exists
+            if (!appTs.includes("from '@currentjs/provider-mysql'")) {
+                importLines.push(`import { ProviderMysql } from '@currentjs/provider-mysql';`);
+            }
+            for (const init of controllerInits) {
+                const maybe = [init.importController, init.importStore, init.importService];
+                if (init.importAuth)
+                    maybe.push(init.importAuth);
+                for (const line of maybe) {
+                    if (!appTs.includes(line) && !importLines.includes(line))
+                        importLines.push(line);
+                }
+            }
+            if (importLines.length) {
+                const existingImports = new Set();
+                const importRegex = /^import[^;]+;$/gm;
+                const currentImports = appTs.match(importRegex) || [];
+                currentImports.forEach(line => existingImports.add(line.trim()));
+                const toAdd = importLines.filter(line => !existingImports.has(line.trim()));
+                if (toAdd.length)
+                    appTs = toAdd.join('\n') + '\n' + appTs;
+            }
+            // Compose fresh block content
+            const wiringLines = [];
+            // DB placeholder once
+            wiringLines.push(ensureDbLine);
+            const wiredEntities = new Set();
+            for (const init of controllerInits) {
+                if (!wiredEntities.has(init.entityName)) {
+                    wiringLines.push(...init.wiring);
+                    wiredEntities.add(init.entityName);
+                }
+            }
+            const registrations = controllerInits.map((i) => i.registration);
+            wiringLines.push('const controllers = [');
+            wiringLines.push(`  ${registrations.join(',\n  ')}`);
+            wiringLines.push('];');
+            const startMarker = constants_1.GENERATOR_MARKERS.CONTROLLERS_START;
+            const endMarker = constants_1.GENERATOR_MARKERS.CONTROLLERS_END;
+            const startIdx = appTs.indexOf(startMarker);
+            const endIdx = appTs.indexOf(endMarker);
+            if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+                const before = appTs.slice(0, startIdx + startMarker.length);
+                const after = appTs.slice(endIdx);
+                const block = '\n' + wiringLines.join('\n') + '\n';
+                appTs = before + block + after;
+            }
+            // Ensure the createWebServer call includes renderer in options
+            // Case 1: createWebServer(controllers, { ... })
+            const withOptionsRegex = /createWebServer\(\s*controllers\s*,\s*\{([\s\S]*?)\}\s*\)/m;
+            if (withOptionsRegex.test(appTs)) {
+                appTs = appTs.replace(withOptionsRegex, (full, inner) => {
+                    if (/\brenderer\b\s*:/.test(inner))
+                        return full; // already present
+                    const trimmed = inner.trim();
+                    const prefix = trimmed.length ? inner.replace(trimmed, '') : '';
+                    const suffix = inner.endsWith(trimmed) ? '' : inner.slice(inner.indexOf(trimmed) + trimmed.length);
+                    const sep = trimmed.length ? ', ' : '';
+                    return full.replace(inner, `${prefix}${trimmed}${sep}renderer` + `: renderer${suffix}`);
+                });
+            }
+            else {
+                // Case 2: createWebServer(controllers)
+                const noOptionsRegex = /createWebServer\(\s*controllers\s*\)/m;
+                if (noOptionsRegex.test(appTs)) {
+                    appTs = appTs.replace(noOptionsRegex, 'createWebServer(controllers, { renderer })');
+                }
+            }
+            fs.writeFileSync(appTsPath, appTs, 'utf8');
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn(colors_1.colors.yellow(`Could not update app.ts with controllers: ${e instanceof Error ? e.message : String(e)}`));
+        }
+    }
+}

package/dist/commands/infer.d.ts

@@ -0,0 +1 @@
+export declare function handleInfer(entityFileArg?: string, write?: boolean): void;

package/dist/commands/infer.js

@@ -0,0 +1,179 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInfer = handleInfer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+const cliUtils_1 = require("../utils/cliUtils");
+function reverseType(tsType) {
+    const t = tsType.trim();
+    if (t === 'string')
+        return 'string';
+    if (t === 'number')
+        return 'number';
+    if (t === 'boolean')
+        return 'boolean';
+    if (t === 'Date')
+        return 'datetime';
+    if (t === 'any[]')
+        return 'array';
+    if (t === 'object')
+        return 'object';
+    if (t === 'any')
+        return 'json';
+    return 'json';
+}
+function inferFromConstructorParams(paramsSrc) {
+    // Remove newlines to simplify parsing
+    const src = paramsSrc.replace(/\n/g, ' ');
+    const fields = [];
+    const regex = /public\s+(\w+)(\?)?\s*:\s*([^=,]+)(\s*=\s*([^,]+))?/g;
+    let match;
+    let index = 0;
+    while ((match = regex.exec(src))) {
+        const name = match[1];
+        const optionalMark = !!match[2];
+        const tsType = match[3].trim();
+        const hasDefault = !!match[4];
+        if (index === 0 && name === 'id') {
+            // Skip id
+            index += 1;
+            continue;
+        }
+        const yamlType = reverseType(tsType);
+        const field = { name, type: yamlType };
+        if (hasDefault)
+            field.auto = true;
+        // required: if optional mark present then not required; if auto true, mark not required as well
+        if (optionalMark || hasDefault)
+            field.required = false;
+        else
+            field.required = true;
+        fields.push(field);
+        index += 1;
+    }
+    return fields;
+}
+function parseEntity(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const classMatch = content.match(/export\s+class\s+(\w+)\s*\{/);
+    if (!classMatch) {
+        throw new Error(`Cannot find exported class in ${filePath}`);
+    }
+    const entityName = classMatch[1];
+    // Extract constructor params
+    const ctorMatch = content.match(/constructor\s*\(([^)]*)\)/s);
+    if (!ctorMatch) {
+        throw new Error(`Cannot find constructor in ${filePath}`);
+    }
+    const paramsSrc = ctorMatch[1];
+    const fields = inferFromConstructorParams(paramsSrc);
+    return { entityName, fields };
+}
+function findModuleYamlForEntity(entityFile) {
+    const abs = (0, cliUtils_1.toAbsolute)(entityFile);
+    // Expect .../src/modules/<ModuleName>/domain/entities/<Entity>.ts
+    const parts = abs.split(path.sep);
+    const idx = parts.lastIndexOf('modules');
+    if (idx === -1 || idx + 1 >= parts.length)
+        return null;
+    const moduleName = parts[idx + 1];
+    // Build absolute module dir (handle leading path segment on POSIX correctly)
+    const moduleDir = path.isAbsolute(abs)
+        ? path.join(path.sep, ...parts.slice(1, idx + 2))
+        : path.join(...parts.slice(0, idx + 2));
+    // Try to find any yaml in module dir (prefer one matching module name)
+    try {
+        const entries = fs.readdirSync(moduleDir);
+        const yamls = entries.filter(e => e.toLowerCase().endsWith('.yaml'));
+        if (yamls.length > 0) {
+            const preferred = yamls.find(y => y.toLowerCase() === `${moduleName.toLowerCase()}.yaml`);
+            const chosen = preferred !== null && preferred !== void 0 ? preferred : yamls[0];
+            return path.join(moduleDir, chosen);
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Fallback to conventional name
+    const moduleYaml = path.join(moduleDir, `${moduleName.toLowerCase()}.yaml`);
+    return moduleYaml;
+}
+function handleInfer(entityFileArg, write) {
+    if (!entityFileArg) {
+        throw new Error('Usage: currentjs infer --file <path/to/Entity.ts> [--write]');
+    }
+    const entityFile = (0, cliUtils_1.toAbsolute)(entityFileArg);
+    if (!fs.existsSync(entityFile)) {
+        throw new Error(`Entity file not found: ${entityFile}`);
+    }
+    const { entityName, fields } = parseEntity(entityFile);
+    const modelDesc = {
+        name: entityName,
+        fields
+    };
+    if (!write) {
+        // Print a YAML snippet for the model only
+        // eslint-disable-next-line no-console
+        console.log((0, yaml_1.stringify)({ models: [modelDesc] }));
+        return;
+    }
+    const moduleYamlPath = findModuleYamlForEntity(entityFile);
+    if (!moduleYamlPath) {
+        throw new Error('Could not determine module YAML path from entity file location. Use --write only within a module structure.');
+    }
+    let config = {};
+    if (fs.existsSync(moduleYamlPath)) {
+        try {
+            config = (0, yaml_1.parse)(fs.readFileSync(moduleYamlPath, 'utf8')) || {};
+        }
+        catch {
+            config = {};
+        }
+    }
+    if (!config.models)
+        config.models = [];
+    const idx = config.models.findIndex((m) => m && m.name === entityName);
+    if (idx === -1)
+        config.models.push(modelDesc);
+    else
+        config.models[idx] = modelDesc;
+    fs.mkdirSync(path.dirname(moduleYamlPath), { recursive: true });
+    const yamlOut = (0, yaml_1.stringify)(config);
+    fs.writeFileSync(moduleYamlPath, yamlOut, 'utf8');
+    // eslint-disable-next-line no-console
+    console.log(`Updated ${path.relative(process.cwd(), path.resolve(moduleYamlPath))} with model ${entityName}`);
+}

package/dist/generators/controllerGenerator.d.ts

@@ -0,0 +1,20 @@
+export declare class ControllerGenerator {
+    private hasPermissions;
+    private getActionPermissions;
+    private shouldGenerateMethod;
+    private needsUserParam;
+    private getHttpMethodName;
+    private getHttpDecorator;
+    private generateMethodImplementation;
+    private replaceTemplateVars;
+    private generateControllerMethod;
+    private getWebMethodName;
+    private getPathSuffix;
+    private getReturnType;
+    private generateController;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath?: string, outputDir?: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<string[]>;
+}