vovk-cli 0.0.1-draft.99 → 0.0.3

package/dist/generate/index.mjs

@@ -1,94 +1,186 @@
 import path from 'node:path';
-import fs from 'node:fs/promises';
-import ejs from 'ejs';
-import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import prettify from '../utils/prettify.mjs';
-import getClientTemplates from './getClientTemplates.mjs';
-import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-import uniq from 'lodash/uniq.js';
-export default async function generate({ projectInfo, segments, segmentsSchema, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, }) {
-    const generateFrom = templates ?? projectInfo.config.generateFrom;
-    const noClient = templates?.[0] === 'none';
-    const { config, cwd, log, clientImports, apiRoot } = projectInfo;
-    const { clientOutDirAbsolutePath, templateFiles } = getClientTemplates({ config, cwd, generateFrom });
-    // Ensure that each segment has a matching schema if it needs to be emitted:
-    for (let i = 0; i < segments.length; i++) {
-        const { segmentName } = segments[i];
-        const schema = segmentsSchema[segmentName];
-        if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+import * as chokidar from 'chokidar';
+import { getProjectFullSchema } from './getProjectFullSchema.mjs';
+import { generate } from './generate.mjs';
+import { locateSegments } from '../utils/locateSegments.mjs';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+const THROTTLE_DELAY = 5000;
+export class VovkGenerate {
+    #cliGenerateOptions;
+    #projectInfo;
+    #forceNothingWrittenLog;
+    constructor({ cliGenerateOptions, projectInfo, forceNothingWrittenLog, }) {
+        this.#cliGenerateOptions = cliGenerateOptions;
+        this.#projectInfo = projectInfo;
+        this.#forceNothingWrittenLog = forceNothingWrittenLog ?? true;
+    }
+    start() {
+        const { watch } = this.#cliGenerateOptions;
+        if (watch) {
+            const throttleDelay = typeof watch === 'boolean' ? THROTTLE_DELAY : parseFloat(watch) * 1e3 || THROTTLE_DELAY;
+            this.watch({ throttleDelay });
+        }
+        else {
+            this.generate();
         }
-        if (!schema.emitSchema)
-            continue;
     }
-    const now = Date.now();
-    // Data for the EJS templates:
-    const t = {
-        apiRoot,
-        imports: clientImports,
-        segments,
-        fullSchema: segmentsSchema,
-    };
-    // Process each template in parallel
-    const processedTemplates = noClient
-        ? []
-        : await Promise.all(templateFiles.map(async ({ templatePath, outPath, templateName }) => {
-            // Read the EJS template
-            const templateContent = await fs.readFile(templatePath, 'utf-8');
-            // Render the template
-            let rendered = templatePath.endsWith('.ejs')
-                ? ejs.render(templateContent, { t }, {
-                    filename: templatePath,
-                })
-                : templateContent;
-            // Optionally prettify
-            if (prettifyClient || config.prettifyClient) {
-                rendered = await prettify(rendered, outPath);
-            }
-            // Read existing file content to compare
-            const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
-            // Determine if we need to rewrite the file, ignore 1st line
-            const needsWriting = existingContent.trim().split('\n').slice(1).join('\n') !== rendered.trim().split('\n').slice(1).join('\n');
-            return {
-                outPath,
-                rendered,
-                needsWriting,
-                templateName,
-            };
-        }));
-    const usedTemplateNames = uniq(processedTemplates.filter(({ needsWriting }) => needsWriting).map(({ templateName }) => templateName));
-    let fullSchemaNames = [];
-    const DEFAULT_NAME = 'full-schema.json';
-    if (fullSchema) {
-        fullSchemaNames.push(typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME);
-        fullSchemaNames.push(...templateFiles
-            .filter(({ fullSchema }) => fullSchema)
-            .map(({ fullSchema }) => (typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME)));
+    async generate() {
+        const fullSchema = await this.getFullSchema();
+        const { log, config, apiDirAbsolutePath } = this.#projectInfo;
+        const locatedSegments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
+        await generate({
+            projectInfo: this.#projectInfo,
+            fullSchema,
+            forceNothingWrittenLog: this.#forceNothingWrittenLog,
+            cliGenerateOptions: this.#cliGenerateOptions,
+            locatedSegments,
+        });
     }
-    fullSchemaNames = uniq(fullSchemaNames);
-    if (fullSchemaNames.length || usedTemplateNames.length > 0) {
-        // Make sure the output directory exists
-        await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
+    async getFullSchema() {
+        const { log, config, cwd, isNextInstalled } = this.#projectInfo;
+        const { schemaPath } = this.#cliGenerateOptions;
+        const fullSchema = await getProjectFullSchema({
+            schemaOutAbsolutePath: path.resolve(cwd, schemaPath ?? config.schemaOutDir),
+            isNextInstalled,
+            log,
+            config,
+        });
+        return fullSchema;
     }
-    if (fullSchemaNames.length) {
-        await Promise.all(fullSchemaNames.map(async (name) => {
-            const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, name);
-            await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
-            log.info(`Full schema has ben written to ${fullSchemaOutAbsolutePath}`);
-        }));
+    watch({ throttleDelay }) {
+        const { openapiSpec, schemaPath } = this.#cliGenerateOptions;
+        const { log, cwd, config } = this.#projectInfo;
+        if (openapiSpec) {
+            log.debug(`Watching OpenAPI spec: ${openapiSpec}`);
+            this.watchOpenApiSpec({ openApiSpec: openapiSpec, throttleDelay });
+        }
+        else {
+            const resolvedSchemaPath = path.resolve(cwd, schemaPath ?? config.schemaOutDir);
+            log.debug(`Watching schema directory: ${resolvedSchemaPath}`);
+            this.watchSchema({ schemaPath: resolvedSchemaPath, throttleDelay });
+        }
     }
-    if (usedTemplateNames.length === 0) {
-        const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;
-        logOrDebug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
-        return { written: false, path: clientOutDirAbsolutePath };
+    watchSchema({ schemaPath, throttleDelay }) {
+        const { log } = this.#projectInfo;
+        let lastGenerationTime = 0;
+        chokidar
+            .watch(schemaPath, {
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('all', (event, path) => {
+            if (event === 'change' || event === 'add' || event === 'ready' || event === 'unlink') {
+                log.debug(`Schema file ${event}: ${path}`);
+                const now = Date.now();
+                const shouldGenerateImmediately = now - lastGenerationTime > throttleDelay;
+                const generateCode = async () => {
+                    try {
+                        lastGenerationTime = Date.now();
+                        await this.generate();
+                        log.debug(`Regenerated from schema changes`);
+                    }
+                    catch (error) {
+                        log.error(`Failed to regenerate from schema: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                };
+                // Generate immediately if it's been a while since the last generation
+                if (shouldGenerateImmediately) {
+                    generateCode();
+                }
+            }
+        });
     }
-    // Write updated files where needed
-    await Promise.all(processedTemplates.map(({ outPath, rendered, needsWriting }) => {
-        if (needsWriting) {
-            return fs.writeFile(outPath, rendered);
+    watchOpenApiSpec({ openApiSpec, throttleDelay }) {
+        const fileSpecs = openApiSpec.filter((spec) => !spec.startsWith('http://') && !spec.startsWith('https://'));
+        const remoteSpecs = openApiSpec.filter((spec) => spec.startsWith('http://') || spec.startsWith('https://'));
+        if (fileSpecs.length) {
+            this.watchOpenApiSpecLocal({
+                openApiSpecPaths: fileSpecs,
+                throttleDelay,
+            });
+        }
+        if (remoteSpecs.length) {
+            remoteSpecs.forEach((spec) => {
+                this.watchOpenApiSpecRemote({
+                    openApiSpecUrl: spec,
+                    throttleDelay,
+                });
+            });
         }
-        return null;
-    }));
-    log.info(`Client generated from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))} at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
-    return { written: true, path: clientOutDirAbsolutePath };
+    }
+    watchOpenApiSpecLocal({ openApiSpecPaths, throttleDelay }) {
+        const { log, cwd } = this.#projectInfo;
+        let lastGenerationTime = 0;
+        chokidar
+            .watch(openApiSpecPaths, {
+            cwd,
+            persistent: true,
+            ignoreInitial: false,
+        })
+            .on('all', (event, path) => {
+            if (event === 'change' || event === 'add' || event === 'ready' || event === 'unlink') {
+                log.debug(`OpenAPI spec file changed: ${path}`);
+                const now = Date.now();
+                const shouldGenerateImmediately = now - lastGenerationTime > throttleDelay;
+                const generateCode = async () => {
+                    try {
+                        lastGenerationTime = Date.now();
+                        await this.generate();
+                        log.debug(`Regenerated from OpenAPI spec changes`);
+                    }
+                    catch (error) {
+                        log.error(`Failed to regenerate from OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                };
+                // Generate immediately if it's been a while since the last generation
+                if (shouldGenerateImmediately) {
+                    generateCode();
+                }
+            }
+        });
+    }
+    watchOpenApiSpecRemote({ openApiSpecUrl, throttleDelay }) {
+        const { log } = this.#projectInfo;
+        let lastContent = null;
+        let isPolling = false;
+        log.info(`Polling remote OpenAPI spec at ${chalkHighlightThing(openApiSpecUrl)} every ${throttleDelay}ms`);
+        const pollRemoteSpec = async () => {
+            if (isPolling)
+                return;
+            isPolling = true;
+            try {
+                const response = await fetch(openApiSpecUrl, {
+                    headers: {
+                        Accept: 'application/json, application/yaml',
+                    },
+                });
+                if (!response.ok) {
+                    log.error(`Failed to fetch OpenAPI spec: ${response.status} ${response.statusText}`);
+                    return;
+                }
+                const content = await response.text();
+                if (content !== lastContent) {
+                    log.info(`Remote OpenAPI spec changed at ${chalkHighlightThing(openApiSpecUrl)}`);
+                    lastContent = content;
+                    try {
+                        await this.generate();
+                        log.debug(`Regenerated from remote OpenAPI spec changes`);
+                    }
+                    catch (error) {
+                        log.error(`Failed to regenerate from OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            catch (error) {
+                log.error(`Error polling OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                isPolling = false;
+            }
+        };
+        // Initial fetch
+        pollRemoteSpec();
+        // Set up polling
+        setInterval(pollRemoteSpec, throttleDelay);
+    }
 }

package/dist/generate/writeOneClientFile.d.mts

@@ -0,0 +1,43 @@
+import type { VovkSchema } from 'vovk';
+import { type VovkReadmeConfig, type VovkSamplesConfig, type VovkStrictConfig } from 'vovk/internal';
+import type { PackageJson } from 'type-fest';
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { ClientTemplateFile } from './getClientTemplateFiles.mjs';
+import type { Segment } from '../utils/locateSegments.mjs';
+export declare function normalizeOutTemplatePath(out: string, packageJson: PackageJson): string;
+export declare function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, templateContent, matterResult: { data, content }, openAPIObject, package: packageJson, readme, samples, reExports, isEnsuringClient, outCwdRelativeDir, templateDef, locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, vovkCliPackage, isBundle, origin, configKey, cliSchemaPath, projectConfig, }: {
+    cwd: string;
+    projectInfo: ProjectInfo;
+    clientTemplateFile: ClientTemplateFile;
+    fullSchema: VovkSchema;
+    prettifyClient: boolean;
+    segmentName: string | null;
+    templateContent: string;
+    matterResult: {
+        data: {
+            imports?: string[];
+        };
+        content: string;
+    };
+    openAPIObject: OpenAPIObject;
+    package: PackageJson;
+    readme: VovkReadmeConfig;
+    samples: VovkSamplesConfig;
+    reExports: VovkStrictConfig['outputConfig']['reExports'];
+    isEnsuringClient: boolean;
+    outCwdRelativeDir: string;
+    templateDef: VovkStrictConfig['clientTemplateDefs'][string];
+    locatedSegments: Segment[];
+    isNodeNextResolution: boolean;
+    hasMixins: boolean;
+    isVovkProject: boolean;
+    vovkCliPackage: PackageJson;
+    isBundle: boolean;
+    origin: string | null;
+    configKey: 'composedClient' | 'segmentedClient';
+    cliSchemaPath: string | null;
+    projectConfig: VovkStrictConfig;
+}): Promise<{
+    written: boolean;
+}>;

package/dist/generate/writeOneClientFile.mjs

@@ -0,0 +1,150 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ejs from 'ejs';
+import _ from 'lodash';
+import * as YAML from 'yaml';
+import TOML from '@iarna/toml';
+import { createCodeSamples, VovkSchemaIdEnum, } from 'vovk/internal';
+import { compileJSONSchemaToTypeScriptType } from '../utils/compileJSONSchemaToTypeScriptType.mjs';
+import { getTemplateClientImports } from './getTemplateClientImports.mjs';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+import { ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+import { prettify } from '../utils/prettify.mjs';
+export function normalizeOutTemplatePath(out, packageJson) {
+    return out.replace('[package_name]', packageJson.name?.replace(/-/g, '_') ?? 'my_package_name');
+}
+export async function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, 
+// imports,
+templateContent, matterResult: { data, content }, openAPIObject, package: packageJson, readme, samples, reExports, isEnsuringClient, outCwdRelativeDir, templateDef, locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, vovkCliPackage, isBundle, origin, configKey, cliSchemaPath, projectConfig, }) {
+    const { config, log } = projectInfo;
+    const { templateFilePath, relativeDir } = clientTemplateFile;
+    const locatedSegmentsByName = _.keyBy(locatedSegments, 'segmentName');
+    const outPath = normalizeOutTemplatePath(path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_FILE_NAME : '', relativeDir, path.basename(templateFilePath).replace('.ejs', '')), packageJson);
+    let placeholder = templateFilePath.endsWith('.json.ejs')
+        ? ''
+        : `// This is a temporary placeholder to avoid compilation errors if client is imported before it's generated.
+// If you still see this text, the client is not generated yet because of an unknown problem.
+// Feel free to report an issue at https://github.com/finom/vovk/issues`;
+    placeholder = outPath.endsWith('.py') ? placeholder.replace(/\/\//g, '#') : placeholder;
+    const getFirstLineBanner = (type = 'c') => {
+        const text = `Generated by vovk-cli v${vovkCliPackage.version} at ${new Date().toISOString()}`;
+        switch (type) {
+            case 'html':
+                return `<!-- ${text} -->`;
+            case 'sh':
+                return `# ${text}`;
+            case 'c':
+                return `// ${text}`;
+        }
+    };
+    reExports = _.mapValues(reExports ?? {}, (p) => p.startsWith('.')
+        ? path.relative(path.join(outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_FILE_NAME : '.'), path.resolve(cwd, p))
+        : p);
+    // Data for the EJS templates:
+    const t = {
+        _, // lodash
+        hasMixins,
+        isVovkProject,
+        package: packageJson,
+        readme,
+        samples,
+        reExports,
+        openapi: openAPIObject,
+        ROOT_SEGMENT_FILE_NAME,
+        apiRoot: origin ? `${origin}/${config.rootEntry}` : undefined,
+        imports: {},
+        schema: fullSchema,
+        config: projectConfig,
+        VovkSchemaIdEnum,
+        createCodeSamples,
+        compileJSONSchemaToTypeScriptType,
+        YAML,
+        TOML,
+        getFirstLineBanner,
+        nodeNextResolutionExt: {
+            ts: isNodeNextResolution ? '.ts' : '',
+            js: isNodeNextResolution ? '.js' : '',
+            mjs: isNodeNextResolution ? '.mjs' : '',
+        },
+        schemaOutDir: typeof segmentName === 'string'
+            ? path.relative(path.join(outCwdRelativeDir, segmentName || ROOT_SEGMENT_FILE_NAME), cliSchemaPath ?? config.schemaOutDir)
+            : path.relative(outCwdRelativeDir, cliSchemaPath ?? config.schemaOutDir),
+        commonImports: getTemplateClientImports({
+            config: projectConfig,
+            fullSchema,
+            isBundle,
+            outCwdRelativeDir,
+            segmentName,
+            outputConfigs: [templateDef.outputConfig ?? {}],
+        }).composedClient,
+        segmentImports: Object.fromEntries(Object.values(fullSchema.segments).map(({ segmentName: sName }) => {
+            const clientImports = getTemplateClientImports({
+                config: projectConfig,
+                fullSchema,
+                segmentName: sName,
+                isBundle,
+                outCwdRelativeDir,
+                outputConfigs: [projectConfig[configKey].outputConfig ?? {}, templateDef.outputConfig ?? {}],
+            });
+            const imports = configKey === 'composedClient' ? clientImports.composedClient : clientImports.segmentedClient[sName];
+            return [sName, imports];
+        })),
+        segmentMeta: Object.fromEntries(Object.values(fullSchema.segments).map(({ segmentName: sName, forceApiRoot }) => {
+            const { routeFilePath = null } = locatedSegmentsByName[sName] ?? {};
+            const segmentImportPath = routeFilePath
+                ? path.relative(path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_FILE_NAME : '.'), path.resolve(cwd, routeFilePath))
+                : null;
+            const segmentConfig = {
+                ...config.outputConfig.segments?.[sName],
+                // ...templateDef.outputConfig?.segments?.[sName],
+            };
+            const { origin: segmentConfigOrigin, rootEntry: segmentConfigRootEntry, segmentNameOverride } = segmentConfig;
+            return [
+                sName,
+                {
+                    forceApiRoot: forceApiRoot ??
+                        (segmentConfigOrigin || segmentConfigRootEntry
+                            ? `${segmentConfigOrigin ?? origin}/${segmentConfigRootEntry ?? config.rootEntry}`
+                            : null),
+                    routeFilePath,
+                    segmentImportPath,
+                    segmentNameOverride,
+                },
+            ];
+        })),
+    };
+    if (Array.isArray(data.imports)) {
+        for (const imp of data.imports) {
+            t.imports = {
+                [imp]: await import(imp),
+            };
+        }
+    }
+    // Render the template
+    let rendered = templateFilePath.endsWith('.ejs')
+        ? await ejs.render(content, { t }, {
+            filename: templateFilePath,
+            async: true,
+        })
+        : templateContent;
+    // Optionally prettify
+    if (prettifyClient) {
+        rendered = await prettify(rendered, outPath);
+    }
+    if (isEnsuringClient) {
+        rendered = `${rendered}\n\n${placeholder}`;
+    }
+    // Read existing file content to compare
+    const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => null);
+    // Determine if we need to rewrite the file, ignore 1st line
+    const needsWriting = isEnsuringClient
+        ? !existingContent
+        : !existingContent ||
+            existingContent.trim().split('\n').slice(1).join('\n') !== rendered.trim().split('\n').slice(1).join('\n');
+    if (needsWriting) {
+        log.debug(`Writing file: ${chalkHighlightThing(outPath)} ${existingContent ? '(updated)' : '(new)'}`);
+        await fs.mkdir(path.dirname(outPath), { recursive: true });
+        await fs.writeFile(outPath, rendered, 'utf-8');
+    }
+    return { written: needsWriting };
+}

package/dist/getProjectInfo/getConfig/getConfigAbsolutePaths.d.mts

@@ -0,0 +1,5 @@
+export declare function getConfigAbsolutePaths({ cwd, configPath, relativePath, }: {
+    cwd: string;
+    configPath?: string;
+    relativePath?: string;
+}): Promise<string[]>;

package/dist/getProjectInfo/{getConfigAbsolutePaths.mjs → getConfig/getConfigAbsolutePaths.mjs}

@@ -1,6 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-export default async function getConfigAbsolutePaths({ cwd, relativePath, }) {
+export async function getConfigAbsolutePaths({ cwd, configPath, relativePath, }) {
+    if (configPath) {
+        return [path.resolve(cwd, configPath)];
+    }
     const rootDir = path.resolve(cwd, relativePath || '');
     const baseName = 'vovk.config';
     const extensions = ['cjs', 'mjs', 'js'];

package/dist/getProjectInfo/getConfig/getRelativeSrcRoot.d.mts

@@ -0,0 +1,3 @@
+export declare function getRelativeSrcRoot({ cwd }: {
+    cwd: string;
+}): Promise<"." | "./src" | null>;

package/dist/getProjectInfo/{getRelativeSrcRoot.mjs → getConfig/getRelativeSrcRoot.mjs}

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
-export default async function getRelativeSrcRoot({ cwd }) {
+import { getFileSystemEntryType, FileSystemEntryType } from '../../utils/getFileSystemEntryType.mjs';
+export async function getRelativeSrcRoot({ cwd }) {
     // Next.js Docs: src/app or src/pages will be ignored if app or pages are present in the root directory.
     if ((await getFileSystemEntryType(path.join(cwd, 'app'))) === FileSystemEntryType.DIRECTORY) {
         return '.';
@@ -8,5 +8,5 @@ export default async function getRelativeSrcRoot({ cwd }) {
     else if ((await getFileSystemEntryType(path.join(cwd, 'src/app'))) === FileSystemEntryType.DIRECTORY) {
         return './src';
     }
-    throw new Error(`${cwd} Could not find app router directory. Check Next.js docs for more info.`);
+    return null;
 }

package/dist/getProjectInfo/getConfig/getTemplateDefs.d.mts

@@ -0,0 +1,25 @@
+import type { VovkStrictConfig } from 'vovk/internal';
+export declare enum BuiltInTemplateName {
+    tsBase = "tsBase",
+    jsBase = "jsBase",
+    ts = "ts",
+    js = "js",
+    schemaTs = "schemaTs",
+    schemaJs = "schemaJs",
+    schemaJson = "schemaJson",
+    openapiTs = "openapiTs",
+    openapiJs = "openapiJs",
+    openapiJson = "openapiJson",
+    readme = "readme",
+    packageJson = "packageJson",
+    mixins = "mixins",
+    rsSrc = "rsSrc",
+    rsPkg = "rsPkg",
+    rsReadme = "rsReadme",
+    rs = "rs",
+    pySrc = "pySrc",
+    pyPkg = "pyPkg",
+    pyReadme = "pyReadme",
+    py = "py"
+}
+export declare function getTemplateDefs(userTemplateDefs?: VovkStrictConfig['clientTemplateDefs']): VovkStrictConfig['clientTemplateDefs'];