vovk-cli 0.0.1-draft.147 → 0.0.1-draft.149

package/client-templates/{main/main.cjs.ejs → cjs/index.cjs.ejs}

@@ -3,10 +3,10 @@ const { fetcher } = require('<%= t.imports.fetcher %>');
 const { createRPC } = require('<%= t.imports.createRPC %>');
 const { fullSchema } = require('./fullSchema.cjs');
 const { validateOnClient = null } = <%- t.imports.validateOnClient ? `require('${t.imports.validateOnClient}')` : '{}'%>;
-<% Object.values(t.fullSchema.segments).forEach((segment) => { 
-  Object.keys(segment.controllers).forEach((controllerName) => { %>
-exports.<%= controllerName %> = createRPC(
-  fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { 
+  Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+exports.<%= rpcModuleName %> = createRPC(
+  fullSchema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
   <% })

package/client-templates/{module/module.d.mts.ejs → dts/index.d.ts.ejs}

@@ -3,13 +3,13 @@
 import type { VovkClientFetcher } from 'vovk';
 import type { fetcher } from '<%= t.imports.module.fetcher %>';
 import type { createRPC } from '<%= t.imports.module.createRPC %>';
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
-<% }}) %>
+<% }) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => { 
-  Object.keys(segment.controllers).forEach((controllerName) => { %>
-export const <%= controllerName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>>;
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { 
+  Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= rpcModuleName %>"], Options>>;
   <% }) 
 }) %>
 export { fullSchema } from './fullSchema.cjs';

package/client-templates/fullSchemaCjs/fullSchema.cjs.ejs

@@ -1,9 +1,7 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 const config = require('./<%= t.schemaOutDir %>/config.json');
-const segments = {
-  <% Object.values(t.fullSchema.segments).forEach((segment) => { %>
-    '<%= segment.segmentName %>': require('./<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json'),
-  <% }) %>
+const segments = {<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
+    '<%= segment.segmentName %>': require('./<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json'),<% }) %>
 };
 const fullSchema = {
   config,

package/client-templates/fullSchemaCjs/fullSchema.d.cts.ejs

@@ -3,9 +3,7 @@ import type { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
 
 export const fullSchema: {
     config: Partial<VovkStrictConfig>;
-    segments: {
-      <% Object.values(t.fullSchema.segments).forEach((segment) => { %>
-      '<%= segment.segmentName %>': VovkSegmentSchema;
-      <% }) %>
+    segments: {<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
+      '<%= segment.segmentName %>': VovkSegmentSchema;<% }) %>
     };
 };

package/client-templates/fullSchemaTs/fullSchema.ts.ejs

@@ -1,15 +1,10 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
-import type { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
 import config from './<%= t.schemaOutDir %>/config.json' with { type: "json" };
-
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
-  import segment<%= i %> from './<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json' with { type: "json" };
-<% }}) %>
-
-const segments = {
-  <% Object.values(t.fullSchema.segments).forEach((segment, i) => { %>
-    '<%= segment.segmentName %>': segment<%= i %>,
-  <% }) %>
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+import segment<%= i %> from './<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json' with { type: "json" };
+<% }) %>
+const segments = {<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+  '<%= segment.segmentName %>': segment<%= i %>,<% }) %>
 };
 
 export const fullSchema = {

package/client-templates/{module/module.mjs.ejs → mjs/index.mjs.ejs}

@@ -7,10 +7,10 @@ import { validateOnClient } from '<%= t.imports.module.validateOnClient %>';
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => {
-  Object.keys(segment.controllers).forEach((controllerName) => { %>
-export const <%= controllerName %> = createRPC(
-  fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => {
+  Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %> = createRPC(
+  fullSchema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
 <% 

package/client-templates/readme/README.md.ejs

@@ -0,0 +1,41 @@
+---
+imports: ['vovk-openapi']
+---
+<% const vars = {
+    createCodeExamples: t.imports['vovk-openapi'].createCodeExamples,
+}; %>
+
+# <%= t.package.name %> v<%= t.package.version %>
+
+<%- t.package.description ? `> ${t.package.description}` : '' %>
+
+<%- t.package.license ? `License: **${t.package.license}**` : '' %>
+
+```bash
+# Install the package
+npm install <%= t.package.name.replace(/-/g, '_') %>
+```
+
+<% Object.entries(t.fullSchema.segments).forEach(([segmentName, segment]) => {
+    Object.values(segment.controllers).forEach((controllerSchema) => { %>
+
+## <%= controllerSchema.rpcModuleName %>
+        <% Object.entries(controllerSchema.handlers).forEach(([handlerName, handlerSchema]) => { %>
+### <%= controllerSchema.rpcModuleName %>.<%= handlerName %>
+<%- handlerSchema.openapi?.summary ? `> ${handlerSchema.openapi.summary}` : '' %>
+
+<%- handlerSchema.openapi?.description ? `${handlerSchema.openapi.description}` : '' %>
+
+Endpoint: <%= t.apiRoot %>/<%= segmentName %>/<%= controllerSchema.prefix %>/<%= handlerSchema.path %>
+
+```ts
+<%- vars.createCodeExamples({
+    handlerSchema,
+    handlerName,
+    controllerSchema,
+    package: t.package,
+}).ts %>
+```
+        <% }) %>
+    <% }) %>
+<% }) %>

package/client-templates/ts/index.ts.ejs

@@ -3,19 +3,19 @@ import type { VovkClientFetcher } from 'vovk';
 import { fetcher } from '<%= t.imports.fetcher %>';
 import { createRPC } from '<%= t.imports.createRPC %>';
 import { fullSchema } from './fullSchema.ts';
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
-<% }}) %>
+<% }) %>
 <% if (t.imports.validateOnClient) { %>
 import { validateOnClient } from '<%= t.imports.validateOnClient %>';
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => { %>
-  <% Object.keys(segment.controllers).forEach((controllerName) => { %>
-export const <%= controllerName %> = createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>(
-  fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
+<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+  <% Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %> = createRPC<Controllers<%= i %>["<%= rpcModuleName %>"], Options>(
+  fullSchema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
   <% }) %>

package/dist/bundle/index.d.mts

@@ -0,0 +1,8 @@
+import type { VovkFullSchema } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { BundleOptions } from '../types.mjs';
+export default function bundle({ projectInfo, fullSchema, cliBundleOptions, }: {
+    projectInfo: ProjectInfo;
+    fullSchema: VovkFullSchema;
+    cliBundleOptions?: BundleOptions;
+}): Promise<void>;

package/dist/bundle/index.mjs

@@ -0,0 +1,27 @@
+import path from 'node:path';
+import generate from '../generate/index.mjs';
+import { BuiltInTemplateName } from '../getProjectInfo/getConfig/getTemplateDefs.mjs';
+import { rollupBundle } from './rollupBundle.mjs';
+export default async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
+    const cwd = process.cwd();
+    const tsFullClientOutAbsoluteDirInput = path.join(cwd, projectInfo.config.bundle.tsClientOutDir);
+    await generate({
+        isEnsuringClient: false,
+        projectInfo,
+        forceNothingWrittenLog: true,
+        fullSchema,
+        cliGenerateOptions: {
+            fullClientFrom: [BuiltInTemplateName.ts],
+            fullClientOut: projectInfo.config.bundle.tsClientOutDir,
+        },
+    });
+    const outDir = cliBundleOptions?.outDir ?? projectInfo.config.bundle.outDir;
+    if (!outDir) {
+        throw new Error('No output directory specified for bundling');
+    }
+    await rollupBundle({
+        tsFullClientOutAbsoluteDirInput,
+        outDir,
+        cwd,
+    });
+}

package/dist/bundle/rollupBundle.d.mts

@@ -0,0 +1,5 @@
+export declare function rollupBundle({ tsFullClientOutAbsoluteDirInput, outDir, cwd, }: {
+    tsFullClientOutAbsoluteDirInput: string;
+    outDir: string;
+    cwd: string;
+}): Promise<void>;

package/dist/bundle/rollupBundle.mjs

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { rollup } from 'rollup';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import typescript from '@rollup/plugin-typescript';
+import json from '@rollup/plugin-json';
+function getRollupConfig({ tsFullClientOutAbsoluteDirInput, outDir, cwd, }) {
+    const out = path.join(cwd, outDir);
+    const config = {
+        input: path.join(tsFullClientOutAbsoluteDirInput, './index.ts'),
+        output: [
+            {
+                file: path.join(out, './index.cjs'),
+                format: 'cjs',
+                sourcemap: true,
+            },
+            {
+                file: path.join(out, './index.mjs'),
+                format: 'esm',
+                sourcemap: true,
+            },
+        ],
+        plugins: [
+            resolve(),
+            commonjs(),
+            json(),
+            typescript({
+                declaration: true,
+                declarationDir: out,
+                outDir: cwd,
+                rootDir: tsFullClientOutAbsoluteDirInput,
+                module: 'ESNext',
+                target: 'ESNext',
+                experimentalDecorators: true,
+                emitDecoratorMetadata: true,
+                allowImportingTsExtensions: true,
+                noForceEmit: false,
+            }),
+        ],
+    };
+    return config;
+}
+export async function rollupBundle({ tsFullClientOutAbsoluteDirInput, outDir, cwd, }) {
+    const { output, ...input } = getRollupConfig({
+        tsFullClientOutAbsoluteDirInput,
+        outDir,
+        cwd,
+    });
+    console.log({ input });
+    const bundle = await rollup(input);
+    for (const outputOption of output) {
+        await bundle.write(outputOption);
+    }
+    await bundle.close();
+}

package/dist/generate/getClientTemplateFiles.d.mts

@@ -1,6 +1,6 @@
 import type { VovkStrictConfig } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-import { type GenerateOptions } from '../types.mjs';
+import type { GenerateOptions } from '../types.mjs';
 export interface ClientTemplateFile {
     templateName: string;
     templateFilePath: string;
@@ -8,10 +8,13 @@ export interface ClientTemplateFile {
     outCwdRelativeDir: string;
     templateDef: VovkStrictConfig['clientTemplateDefs'][string];
 }
-export default function getClientTemplateFiles({ config, cwd, log, configKey, cliOptions, }: {
+export default function getClientTemplateFiles({ config, cwd, log, configKey, cliGenerateOptions, }: {
     config: VovkStrictConfig;
     cwd: string;
     log: ProjectInfo['log'];
     configKey: 'fullClient' | 'segmentedClient';
-    cliOptions?: GenerateOptions;
-}): Promise<ClientTemplateFile[]>;
+    cliGenerateOptions?: GenerateOptions;
+}): Promise<{
+    fromTemplates: string[];
+    templateFiles: ClientTemplateFile[];
+}>;

package/dist/generate/getClientTemplateFiles.mjs

@@ -2,14 +2,18 @@ import path from 'node:path';
 import { glob } from 'glob';
 import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
 import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
-export default async function getClientTemplateFiles({ config, cwd, log, configKey, cliOptions, }) {
+export default async function getClientTemplateFiles({ config, cwd, log, configKey, cliGenerateOptions, }) {
     const usedTemplateDefs = {};
     const fromTemplates = configKey === 'fullClient'
-        ? (cliOptions?.fullClientFrom ?? config.fullClient.fromTemplates)
-        : (cliOptions?.segmentedClientFrom ?? config.segmentedClient.fromTemplates);
+        ? cliGenerateOptions?.fullClientFrom || cliGenerateOptions?.segmentedClientFrom
+            ? (cliGenerateOptions?.fullClientFrom ?? [])
+            : config.fullClient.fromTemplates
+        : cliGenerateOptions?.fullClientFrom || cliGenerateOptions?.segmentedClientFrom
+            ? (cliGenerateOptions?.segmentedClientFrom ?? [])
+            : config.segmentedClient.fromTemplates;
     const outDir = configKey === 'fullClient'
-        ? (cliOptions?.fullClientOut ?? config.fullClient.outDir)
-        : (cliOptions?.segmentedClientOut ?? config.segmentedClient.outDir);
+        ? (cliGenerateOptions?.fullClientOut ?? config.fullClient.outDir)
+        : (cliGenerateOptions?.segmentedClientOut ?? config.segmentedClient.outDir);
     for (const templateName of fromTemplates) {
         if (!(templateName in config.clientTemplateDefs)) {
             throw new Error(`Unknown template name: ${templateName}`);
@@ -20,42 +24,46 @@ export default async function getClientTemplateFiles({ config, cwd, log, configK
     const entries = Object.entries(usedTemplateDefs);
     for (let i = 0; i < entries.length; i++) {
         const [templateName, templateDef, forceOutCwdRelativeDir] = entries[i];
-        const templateAbsolutePath = resolveAbsoluteModulePath(templateDef.templatePath, cwd);
-        const entryType = await getFileSystemEntryType(templateDef.templatePath);
-        if (!entryType)
+        const templateAbsolutePath = templateDef.templatePath
+            ? resolveAbsoluteModulePath(templateDef.templatePath, cwd)
+            : null;
+        const entryType = templateDef.templatePath ? await getFileSystemEntryType(templateDef.templatePath) : null;
+        if (templateAbsolutePath && !entryType)
             throw new Error(`Unable to locate template path ${templateDef.templatePath}`);
         const defOutDir = configKey === 'fullClient' ? templateDef.fullClient?.outDir : templateDef.segmentedClient?.outDir;
-        let files;
-        if (entryType === FileSystemEntryType.FILE) {
-            files = [templateAbsolutePath];
-        }
-        else {
-            const globPath = path.join(templateAbsolutePath, '**/*.*');
-            files = await glob(globPath);
-        }
-        if (files.length === 0) {
-            log.error(`Template "${templateAbsolutePath}" not found`);
-            continue;
-        }
-        const outCwdRelativeDir = forceOutCwdRelativeDir ?? defOutDir ?? outDir;
-        for (const filePath of files) {
-            templateFiles.push({
-                templateName,
-                templateFilePath: filePath,
-                relativeDir: path.relative(templateAbsolutePath, path.dirname(filePath)),
-                outCwdRelativeDir,
-                templateDef,
-            });
-        }
-        if (templateDef.requires) {
-            for (const [tName, reqRelativeDir] of Object.entries(templateDef.requires)) {
-                const def = config.clientTemplateDefs[tName];
-                if (!def) {
-                    throw new Error(`Template "${tName}" required by "${templateName}" not found`);
+        let files = [];
+        if (templateAbsolutePath) {
+            if (entryType === FileSystemEntryType.FILE) {
+                files = [templateAbsolutePath];
+            }
+            else {
+                const globPath = path.join(templateAbsolutePath, '**/*.*');
+                files = await glob(globPath);
+            }
+            if (files.length === 0) {
+                log.error(`Template "${templateAbsolutePath}" not found`);
+                continue;
+            }
+            const outCwdRelativeDir = forceOutCwdRelativeDir ?? defOutDir ?? outDir;
+            for (const filePath of files) {
+                templateFiles.push({
+                    templateName,
+                    templateFilePath: filePath,
+                    relativeDir: path.relative(templateAbsolutePath, path.dirname(filePath) + '/'),
+                    outCwdRelativeDir,
+                    templateDef,
+                });
+            }
+            if (templateDef.requires) {
+                for (const [tName, reqRelativeDir] of Object.entries(templateDef.requires)) {
+                    const def = config.clientTemplateDefs[tName];
+                    if (!def) {
+                        throw new Error(`Template "${tName}" required by "${templateName}" not found`);
+                    }
+                    entries.push([tName, def, path.join(outCwdRelativeDir, reqRelativeDir)]);
                 }
-                entries.push([tName, def, path.join(outCwdRelativeDir, reqRelativeDir)]);
             }
         }
     }
-    return templateFiles;
+    return { fromTemplates, templateFiles };
 }

package/dist/generate/index.d.mts

@@ -1,10 +1,10 @@
 import type { VovkFullSchema } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 import type { GenerateOptions } from '../types.mjs';
-export default function generate({ isEnsuringClient, projectInfo, forceNothingWrittenLog, fullSchema, cliOptions, }: {
+export default function generate({ isEnsuringClient, projectInfo, forceNothingWrittenLog, fullSchema, cliGenerateOptions, }: {
     isEnsuringClient?: boolean;
     projectInfo: ProjectInfo;
     forceNothingWrittenLog?: boolean;
     fullSchema: VovkFullSchema;
-    cliOptions?: GenerateOptions;
+    cliGenerateOptions?: GenerateOptions;
 }): Promise<void>;

package/dist/generate/index.mjs

@@ -32,7 +32,7 @@ const getIncludedSegmentNames = (config, segments, configKey) => {
             : segments.map(({ segmentName }) => segmentName);
     return includedSegmentNames;
 };
-function logClientGenerationResults({ results, log, isEnsuringClient = false, forceNothingWrittenLog = false, clientType = 'Full', startTime, }) {
+function logClientGenerationResults({ results, log, isEnsuringClient = false, forceNothingWrittenLog = false, clientType = 'Full', startTime, fromTemplates, }) {
     const writtenResults = results.filter(({ written }) => written);
     const duration = Date.now() - startTime;
     if (writtenResults.length) {
@@ -42,12 +42,12 @@ function logClientGenerationResults({ results, log, isEnsuringClient = false, fo
             log.info(`${clientType} client${isEnsuringClient ? ' placeholder' : ''} is generated to ${chalkHighlightThing(outAbsoluteDir)} from template${templateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(templateNames.map((s) => `"${s}"`).join(', '))} in ${duration}ms`);
         }
     }
-    else if (!isEnsuringClient) {
+    else if (!isEnsuringClient && fromTemplates.length) {
         const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;
         logOrDebug(`${clientType} client is up to date and doesn't need to be regenerated (${duration}ms)`);
     }
 }
-export default async function generate({ isEnsuringClient = false, projectInfo, forceNothingWrittenLog, fullSchema, cliOptions, }) {
+export default async function generate({ isEnsuringClient = false, projectInfo, forceNothingWrittenLog, fullSchema, cliGenerateOptions, }) {
     const { config, cwd, log, segments } = projectInfo;
     // Ensure that each segment has a matching schema if it needs to be emitted:
     for (let i = 0; i < segments.length; i++) {
@@ -62,11 +62,11 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
     if (config.fullClient.enabled) {
         const now = Date.now();
         const segmentNames = getIncludedSegmentNames(config, segments, 'fullClient');
-        const fullClientTemplateFiles = await getClientTemplateFiles({
+        const { templateFiles: fullClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
             config,
             cwd,
             log,
-            cliOptions,
+            cliGenerateOptions,
             configKey: 'fullClient',
         });
         const fullClientResults = await Promise.all(fullClientTemplateFiles.map(async (clientTemplateFile) => {
@@ -115,16 +115,17 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
             forceNothingWrittenLog,
             clientType: 'Full',
             startTime: now,
+            fromTemplates,
         });
     }
     if (config.segmentedClient.enabled) {
         const now = Date.now();
         const segmentNames = getIncludedSegmentNames(config, segments, 'segmentedClient');
-        const segmentedClientTemplateFiles = await getClientTemplateFiles({
+        const { templateFiles: segmentedClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
             config,
             cwd,
             log,
-            cliOptions,
+            cliGenerateOptions,
             configKey: 'segmentedClient',
         });
         const segmentedClientResults = await Promise.all(segmentedClientTemplateFiles.map(async (clientTemplateFile) => {
@@ -184,6 +185,7 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
             forceNothingWrittenLog,
             clientType: 'Segmented',
             startTime: now,
+            fromTemplates,
         });
     }
 }

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

@@ -1,9 +1,11 @@
 import type { VovkStrictConfig } from 'vovk';
 export declare enum BuiltInTemplateName {
     ts = "ts",
-    main = "main",
-    module = "module",
-    package = "package",
+    cjs = "cjs",
+    mjs = "mjs",
+    dts = "dts",
+    readme = "readme",
+    packageJson = "packageJson",
     fullSchemaTs = "fullSchemaTs",
     fullSchemaCjs = "fullSchemaCjs",
     fullSchemaJson = "fullSchemaJson"

package/dist/getProjectInfo/getConfig/getTemplateDefs.mjs

@@ -2,9 +2,11 @@ import path from 'node:path';
 export var BuiltInTemplateName;
 (function (BuiltInTemplateName) {
     BuiltInTemplateName["ts"] = "ts";
-    BuiltInTemplateName["main"] = "main";
-    BuiltInTemplateName["module"] = "module";
-    BuiltInTemplateName["package"] = "package";
+    BuiltInTemplateName["cjs"] = "cjs";
+    BuiltInTemplateName["mjs"] = "mjs";
+    BuiltInTemplateName["dts"] = "dts";
+    BuiltInTemplateName["readme"] = "readme";
+    BuiltInTemplateName["packageJson"] = "packageJson";
     BuiltInTemplateName["fullSchemaTs"] = "fullSchemaTs";
     BuiltInTemplateName["fullSchemaCjs"] = "fullSchemaCjs";
     BuiltInTemplateName["fullSchemaJson"] = "fullSchemaJson";
@@ -18,18 +20,27 @@ export default function getTemplateDefs(userTemplateDefs = {}) {
             origin: null,
             requires: { [BuiltInTemplateName.fullSchemaTs]: '.' },
         },
-        [BuiltInTemplateName.main]: {
-            templatePath: path.resolve(templatesDir, 'main/'),
+        [BuiltInTemplateName.cjs]: {
+            templatePath: path.resolve(templatesDir, 'cjs/'),
             origin: null,
-            requires: { [BuiltInTemplateName.fullSchemaCjs]: '.' },
+            requires: { [BuiltInTemplateName.fullSchemaCjs]: '.', [BuiltInTemplateName.dts]: '.' },
+        },
+        [BuiltInTemplateName.mjs]: {
+            templatePath: path.resolve(templatesDir, 'mjs/'),
+            origin: null,
+            requires: { [BuiltInTemplateName.fullSchemaCjs]: '.', [BuiltInTemplateName.dts]: '.' },
         },
-        [BuiltInTemplateName.module]: {
-            templatePath: path.resolve(templatesDir, 'module/'),
+        [BuiltInTemplateName.dts]: {
+            templatePath: path.resolve(templatesDir, 'mjs/'),
             origin: null,
             requires: { [BuiltInTemplateName.fullSchemaCjs]: '.' },
         },
-        [BuiltInTemplateName.package]: {
-            templatePath: path.resolve(templatesDir, 'package/'),
+        [BuiltInTemplateName.readme]: {
+            templatePath: path.resolve(templatesDir, 'readme/'),
+            origin: null,
+        },
+        [BuiltInTemplateName.packageJson]: {
+            templatePath: path.resolve(templatesDir, 'packageJson/'),
             origin: null,
         },
         [BuiltInTemplateName.fullSchemaTs]: {

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

@@ -1,7 +1,8 @@
 import type { VovkStrictConfig } from 'vovk';
-import type { GenerateOptions } from '../../types.mjs';
-export default function getConfig({ cliOptions, cwd }: {
-    cliOptions?: GenerateOptions;
+import type { BundleOptions, GenerateOptions } from '../../types.mjs';
+export default function getConfig({ cliGenerateOptions, cliBundleOptions, cwd, }: {
+    cliGenerateOptions?: GenerateOptions;
+    cliBundleOptions?: BundleOptions;
     cwd: string;
 }): Promise<{
     config: VovkStrictConfig;

package/dist/getProjectInfo/getConfig/index.mjs

@@ -2,8 +2,11 @@ import path from 'node:path';
 import getUserConfig from '../getUserConfig.mjs';
 import getRelativeSrcRoot from '../getRelativeSrcRoot.mjs';
 import getTemplateDefs from './getTemplateDefs.mjs';
-export default async function getConfig({ cliOptions, cwd }) {
-    const { configAbsolutePaths, error, userConfig } = await getUserConfig({ configPath: cliOptions?.config, cwd });
+export default async function getConfig({ cliGenerateOptions, cliBundleOptions, cwd, }) {
+    const { configAbsolutePaths, error, userConfig } = await getUserConfig({
+        configPath: cliGenerateOptions?.config,
+        cwd,
+    });
     const conf = userConfig ?? {};
     const env = process.env;
     const clientTemplateDefs = getTemplateDefs(conf.clientTemplateDefs);
@@ -25,14 +28,21 @@ export default async function getConfig({ cliOptions, cwd }) {
         fullClient: {
             enabled: true,
             ...conf.fullClient,
-            fromTemplates: cliOptions?.fullClientFrom ?? conf.fullClient?.fromTemplates ?? ['module', 'main'],
-            outDir: cliOptions?.fullClientOut ?? conf.fullClient?.outDir ?? './node_modules/.vovk-client',
+            fromTemplates: cliGenerateOptions?.fullClientFrom ?? conf.fullClient?.fromTemplates ?? ['mjs', 'cjs'],
+            outDir: cliGenerateOptions?.fullClientOut ?? conf.fullClient?.outDir ?? './node_modules/.vovk-client',
         },
         segmentedClient: {
             enabled: false,
             ...conf.segmentedClient,
-            fromTemplates: cliOptions?.segmentedClientFrom ?? conf.segmentedClient?.fromTemplates ?? ['ts'],
-            outDir: cliOptions?.segmentedClientOut ?? conf.segmentedClient?.outDir ?? path.join(srcRoot, 'client'),
+            fromTemplates: cliGenerateOptions?.segmentedClientFrom ?? conf.segmentedClient?.fromTemplates ?? ['ts'],
+            outDir: cliGenerateOptions?.segmentedClientOut ?? conf.segmentedClient?.outDir ?? path.join(srcRoot, 'client'),
+        },
+        bundle: {
+            outDir: cliBundleOptions?.outDir ?? conf.bundle?.outDir ?? path.join(srcRoot, 'dist'),
+            tsClientOutDir: cliBundleOptions?.tsClientOutDir ?? conf.bundle?.tsClientOutDir ?? '.tmp-ts-rpc',
+            dontDeleteTsClientOutDirAfter: cliBundleOptions?.dontDeleteTsClientOutDirAfter ?? conf.bundle?.dontDeleteTsClientOutDirAfter ?? true,
+            noReadme: cliBundleOptions?.noReadme ?? conf.bundle?.noReadme ?? false,
+            noPackage: cliBundleOptions?.noPackage ?? conf.bundle?.noPackage ?? false,
         },
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',

package/dist/getProjectInfo/importUncachedModule.mjs

@@ -1,14 +1,11 @@
 // importUncachedModule.js
 import { Worker } from 'node:worker_threads';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import './importUncachedModuleWorker.mjs'; // required for TS compilation
 function importUncachedModule(modulePath) {
     return new Promise((resolve, reject) => {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
         // Resolve the path to the worker script
-        const workerPath = path.resolve(__dirname, 'importUncachedModuleWorker.mjs');
+        const workerPath = path.resolve(import.meta.dirname, 'importUncachedModuleWorker.mjs');
         // Initialize the worker thread
         const worker = new Worker(workerPath, {
             workerData: { modulePath },

package/dist/getProjectInfo/index.d.mts

@@ -1,9 +1,10 @@
-import type { GenerateOptions } from '../types.mjs';
+import type { BundleOptions, GenerateOptions } from '../types.mjs';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, cwd, cliOptions, }?: {
+export default function getProjectInfo({ port: givenPort, cwd, cliGenerateOptions, cliBundleOptions, }?: {
     port?: number;
     cwd?: string;
-    cliOptions?: GenerateOptions;
+    cliGenerateOptions?: GenerateOptions;
+    cliBundleOptions?: BundleOptions;
 }): Promise<{
     cwd: string;
     port: string;

package/dist/getProjectInfo/index.mjs

@@ -2,12 +2,13 @@ import path from 'node:path';
 import getConfig from './getConfig/index.mjs';
 import getLogger from '../utils/getLogger.mjs';
 import locateSegments from '../locateSegments.mjs';
-export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), cliOptions, } = {}) {
+export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), cliGenerateOptions, cliBundleOptions, } = {}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
     const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({
-        cliOptions,
+        cliGenerateOptions,
+        cliBundleOptions,
         cwd,
     });
     const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;

package/dist/index.d.mts

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
 import 'dotenv/config';
+import type { VovkEnv } from './types.mjs';
+export type { VovkEnv };

package/dist/index.mjs

@@ -7,6 +7,7 @@ import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
 import generate from './generate/index.mjs';
+import bundle from './bundle/index.mjs';
 import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
 import initProgram from './initProgram.mjs';
@@ -78,8 +79,8 @@ program
     .option('--segment-client-from <templates...>', 'client template names for segment client')
     .option('--prettify', 'prettify output files')
     .option('--config <config>', 'path to config file')
-    .action(async (cliOptions) => {
-    const projectInfo = await getProjectInfo({ cliOptions });
+    .action(async (cliGenerateOptions) => {
+    const projectInfo = await getProjectInfo({ cliGenerateOptions });
     const { cwd, config } = projectInfo;
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
     const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
@@ -87,7 +88,28 @@ program
         projectInfo,
         fullSchema,
         forceNothingWrittenLog: true,
-        cliOptions,
+        cliGenerateOptions,
+    });
+});
+program
+    .command('bundle')
+    .alias('b')
+    .description('Generate TypeScrtipt RPC and bundle it')
+    .option('--out, --out-dir <path>', 'path to output directory for bundle')
+    .option('--ts-client-out-dir <path>', 'path to output directory for TypeScript client')
+    .option('--no-readme', 'do not generate README file')
+    .option('--no-package', 'do not generate package.json file')
+    .option('--dont-delete-ts-client-out-dir-after', 'do not delete TypeScript client output directory after bundling')
+    .option('--config <config>', 'path to config file')
+    .action(async (cliBundleOptions) => {
+    const projectInfo = await getProjectInfo({ cliBundleOptions });
+    const { cwd, config } = projectInfo;
+    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
+    const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
+    await bundle({
+        projectInfo,
+        fullSchema,
+        cliBundleOptions,
     });
 });
 program
@@ -100,7 +122,8 @@ program
     .option('--empty', 'create an empty module')
     .option('--no-segment-update', 'do not update segment files when creating a new module')
     .option('--dry-run', 'do not write files to disk')
-    .action((components, options) => newComponents(components, options));
+    .option('--static', 'if the segment is static')
+    .action((components, newOptions) => newComponents(components, newOptions));
 program
     .command('help')
     .description('Show help message')

package/dist/init/createConfig.mjs

@@ -17,10 +17,7 @@ export default async function createConfig({ root, log, options: { validationLib
     };
     if (validationLibrary) {
         config.imports ??= {};
-        config.imports.validateOnClient =
-            {
-                'vovk-dto': `vovk-dto/validateOnClient.js`,
-            }[validationLibrary] ?? 'vovk-ajv';
+        config.imports.validateOnClient = 'vovk-ajv';
         try {
             const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
             Object.assign(moduleTemplates, validationTemplates);
@@ -35,7 +32,7 @@ export default async function createConfig({ root, log, options: { validationLib
     }
     config.moduleTemplates = moduleTemplates;
     const configStr = await prettify(`// @ts-check
-/** @type {import('vovk-cli').VovkConfig} */
+/** @type {import('vovk').VovkConfig} */
 const config = ${JSON.stringify(config, null, 2)};
 ${isModule ? '\nexport default config;' : 'module.exports = config;'}`, configAbsolutePath);
     if (!dryRun)

package/dist/init/getTemplateFilesFromPackage.mjs

@@ -2,7 +2,6 @@ import { Readable } from 'node:stream';
 import { createGunzip } from 'node:zlib';
 import tar from 'tar-stream';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
-// Crereated with AI
 /**
  * Retrieves a list of files in the 'templates' folder of an NPM package.
  * @param packageName - The name of the NPM package.

package/dist/new/index.d.mts

@@ -1,2 +1,2 @@
 import type { NewOptions } from '../types.mjs';
-export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }: NewOptions): Promise<void>;
+export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }: NewOptions): Promise<void>;

package/dist/new/index.mjs

@@ -1,6 +1,6 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }) {
+export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]
         let segmentNames = components
@@ -10,7 +10,7 @@ export default async function newComponents(components, { dryRun, dir, templates
             segmentNames = [''];
         }
         for (const segmentName of segmentNames) {
-            await newSegment({ segmentName, overwrite, dryRun });
+            await newSegment({ segmentName, isStaticSegment, overwrite, dryRun });
         }
     }
     else {

package/dist/new/newModule.mjs

@@ -93,7 +93,9 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(path.dirname(routeFilePath), absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            const importPath = path
+                .relative(path.dirname(routeFilePath) + '/', absoluteModulePath)
+                .replace(/\.(ts|tsx)$/, '');
             if (!noSegmentUpdate) {
                 const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
                     sourceName,

package/dist/new/newSegment.d.mts

@@ -1,5 +1,6 @@
-export default function newSegment({ segmentName, overwrite, dryRun, }: {
+export default function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }: {
     segmentName: string;
+    isStaticSegment?: boolean;
     overwrite?: boolean;
     dryRun?: boolean;
 }): Promise<void>;

package/dist/new/newSegment.mjs

@@ -6,20 +6,24 @@ import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
 import chalk from 'chalk';
-export default async function newSegment({ segmentName, overwrite, dryRun, }) {
+export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
     const { apiDir, cwd, log } = await getProjectInfo();
     const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
     if (!overwrite && (await getFileSystemEntryType(absoluteSegmentRoutePath))) {
         throw new Error(`Unable to create new segment. ${formatLoggedSegmentName(segmentName, { upperFirst: true })} already exists.`);
     }
-    const code = await prettify(`import { initVovk } from 'vovk';
+    const code = await prettify(`import { initVovk${isStaticSegment ? ', generateStaticAPI' : ''} } from 'vovk';
 
 export const runtime = 'edge';
 
 const controllers = {};
 
 export type Controllers = typeof controllers;
-
+${isStaticSegment
+        ? `export function generateStaticParams() {
+  return generateStaticAPI(controllers);
+}`
+        : ''}
 export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
   controllers,

package/dist/types.d.mts

@@ -1,4 +1,5 @@
 import type { LogLevelNames } from 'loglevel';
+import type { VovkStrictConfig } from 'vovk';
 export type VovkModuleRenderResult = {
     fileName: string;
     dir: string;
@@ -18,6 +19,9 @@ export interface GenerateOptions {
     segmentedClientFrom?: string[];
     segmentedClientOut?: string;
 }
+export interface BundleOptions extends Partial<VovkStrictConfig['bundle']> {
+    config?: string;
+}
 export interface InitOptions {
     yes?: boolean;
     logLevel: LogLevelNames;
@@ -40,4 +44,22 @@ export interface NewOptions {
     overwrite?: boolean;
     noSegmentUpdate?: boolean;
     empty?: boolean;
+    static?: boolean;
 }
+export type VovkEnv = {
+    PORT?: string;
+    VOVK_SCHEMA_OUT_DIR?: string;
+    VOVK_IMPORTS_FETCHER?: string;
+    VOVK_IMPORTS_VALIDATE_ON_CLIENT?: string;
+    VOVK_IMPORTS_CREATE_RPC?: string;
+    VOVK_MODULES_DIR?: string;
+    VOVK_ORIGIN?: string;
+    VOVK_ROOT_ENTRY?: string;
+    VOVK_API_ENTRY_POINT?: string;
+    VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
+    VOVK_LOG_LEVEL?: LogLevelNames;
+    VOVK_PRETTIFY_CLIENT?: string;
+    VOVK_DEV_HTTPS?: string;
+    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_EXIT__?: 'true' | 'false';
+};

package/module-templates/controller.ts.ejs

@@ -1,11 +1,11 @@
 <% const vars = { 
-  ControllerName: t.TheThing + 'Controller',
+  rpcModuleName: t.TheThing + 'Controller',
   ServiceName: t.TheThing + 'Service',
 }; %>
 ---
 dir: <%= t.defaultDir %>
-fileName: <%= vars.ControllerName + '.ts' %>
-sourceName: <%= vars.ControllerName %>
+fileName: <%= vars.rpcModuleName + '.ts' %>
+sourceName: <%= vars.rpcModuleName %>
 compiledName: <%= t.TheThing + 'RPC' %>
 ---
 
@@ -15,7 +15,7 @@ import <%= vars.ServiceName %> from './<%= vars.ServiceName %>';
 <% } %>
 
 @prefix('<%= t['the-things'] %>')
-export default class <%= vars.ControllerName %> {
+export default class <%= vars.rpcModuleName %> {
     @get()
     static get<%= t.TheThings %> = async (req: VovkRequest<null, { search: string }>) => {
         const search = req.nextUrl.searchParams.get('search');

package/module-templates/service.ts.ejs

@@ -1,5 +1,5 @@
 <% const vars = {
-  ControllerName: t.TheThing + 'Controller',
+  rpcModuleName: t.TheThing + 'Controller',
   ServiceName: t.TheThing + 'Service',
 }; %>
 ---
@@ -9,17 +9,17 @@ sourceName: <%= vars.ServiceName %>
 ---
 
 import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
-import type <%= vars.ControllerName %> from './<%= vars.ControllerName %>';
+import type <%= vars.rpcModuleName %> from './<%= vars.rpcModuleName %>';
 
 export default class <%= vars.ServiceName %> {
-  static get<%= t.TheThings %> = (search: VovkControllerQuery<typeof <%= vars.ControllerName %>.get<%= t.TheThings %>>['search']) => {
+  static get<%= t.TheThings %> = (search: VovkControllerQuery<typeof <%= vars.rpcModuleName %>.get<%= t.TheThings %>>['search']) => {
     return { results: [], search };
   };
 
   static update<%= t.TheThing %> = (
     id: string,
-    q: VovkControllerQuery<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>['q'],
-    body: VovkControllerBody<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>
+    q: VovkControllerQuery<typeof <%= vars.rpcModuleName %>.update<%= t.TheThing %>>['q'],
+    body: VovkControllerBody<typeof <%= vars.rpcModuleName %>.update<%= t.TheThing %>>
   ) => {
     return { id, q, body };
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.147",
+  "version": "0.0.1-draft.149",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,7 +35,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.119"
+    "vovk": "^3.0.0-draft.120"
   },
   "optionalDependencies": {
     "vovk-python-client": "^0.0.1-draft.15"
@@ -43,6 +43,10 @@
   "dependencies": {
     "@inquirer/prompts": "^7.5.0",
     "@npmcli/package-json": "^6.1.1",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
@@ -57,10 +61,13 @@
     "loglevel": "^1.9.2",
     "pluralize": "^8.0.0",
     "prettier": "^3.5.3",
+    "rollup": "^4.40.2",
     "tar-stream": "^3.1.7",
     "ts-morph": "^25.0.1",
+    "tsdown": "^0.11.5",
+    "type-fest": "^4.41.0",
     "undici": "^7.8.0",
-    "type-fest": "^4.40.1"
+    "vovk-openapi": "*"
   },
   "devDependencies": {
     "@types/concat-stream": "^2.0.3",
@@ -69,7 +76,7 @@
     "@types/pluralize": "^0.0.33",
     "@types/tar-stream": "^3.1.3",
     "concat-stream": "^2.0.0",
-    "create-next-app": "^15.3.1",
+    "create-next-app": "^15.3.2",
     "node-pty": "^1.0.0"
   }
 }

package/client-templates/main/main.d.cts.ejs

@@ -1,15 +0,0 @@
-
-<%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
-import type { VovkClientFetcher } from 'vovk';
-import type { fetcher } from '<%= t.imports.fetcher %>';
-import type { createRPC } from '<%= t.imports.createRPC %>';
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
-import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
-<% }}) %>
-type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% Object.values(t.fullSchema.segments).forEach((segment, i) => {
-  Object.keys(segment.controllers).forEach((controllerName) => { %>
-export const <%= controllerName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>>;
-  <% }) 
-}) %>
-export { fullSchema } from './fullSchema.cjs';