vovk-cli 0.0.1-draft.13 → 0.0.1-draft.130

package/dist/new/newModule.d.mts

@@ -1,4 +1,4 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirNameFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }: {
+export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
     what: string[];
     moduleNameWithOptionalSegment: string;
     dryRun?: boolean;
@@ -6,4 +6,5 @@ export default function newModule({ what, moduleNameWithOptionalSegment, dryRun,
     templates?: string[];
     noSegmentUpdate?: boolean;
     overwrite?: boolean;
+    empty?: boolean;
 }): Promise<void>;

package/dist/new/newModule.mjs

@@ -8,6 +8,7 @@ import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import prettify from '../utils/prettify.mjs';
+import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
 function splitByLast(str, delimiter = '/') {
     const index = str.lastIndexOf(delimiter);
     if (index === -1) {
@@ -18,19 +19,17 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirNameFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }) {
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
     const { config, log, apiDir, cwd } = await getProjectInfo();
     let templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
-    // replace c by controller, s by service, w by worker, everything else keeps the same
+    // replace c by controller, s by service, everything else keeps the same
     what = what.map((s) => {
         switch (s) {
             case 'c':
                 return 'controller';
             case 's':
                 return 'service';
-            case 'w':
-                return 'worker';
             default:
                 return s;
         }
@@ -49,32 +48,32 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments(apiDir);
+    const segments = await locateSegments({ dir: apiDir, config });
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
         throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);
     }
     for (const type of what) {
         const templatePath = templates[type];
-        const templateAbsolutePath = templatePath.startsWith('/') || templatePath.startsWith('.')
-            ? path.resolve(cwd, templatePath)
-            : path.resolve(cwd, './node_modules', templatePath);
+        const templateAbsolutePath = resolveAbsoluteModulePath(templatePath, cwd);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
-        const { dirName: renderedDirName, fileName, sourceName, compiledName, code, } = await render(templateCode, {
+        const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
             cwd,
             config,
             withService: what.includes('service'),
             segmentName,
             moduleName,
+            empty,
+            templateFileName: templateAbsolutePath,
         });
-        const dirName = dirNameFlag || renderedDirName;
-        if (!dirName) {
-            throw new Error(`The template for "${type}" does not provide a dirName`);
+        const dir = dirFlag || renderedDir;
+        if (!dir) {
+            throw new Error(`The template for "${type}" does not provide a dir`);
         }
         if (!fileName) {
             throw new Error(`The template for "${type}" does not provide a fileName`);
         }
-        const absoluteModuleDir = path.join(cwd, dirName);
+        const absoluteModuleDir = path.join(cwd, dir);
         const absoluteModulePath = path.join(absoluteModuleDir, fileName);
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
@@ -87,12 +86,12 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                 log.info(`Created ${chalkHighlightThing(fileName)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
-        if (type === 'controller' || type === 'worker') {
+        if (type === 'controller') {
             if (!sourceName) {
                 throw new Error(`The template for "${type}" does not provide a sourceName`);
             }
             if (!compiledName) {
-                throw new Error('The template for "${type}" does not provide a compiledName');
+                throw new Error(`The template for "${type}" does not provide a compiledName`);
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
@@ -101,7 +100,6 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                 const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
                     sourceName,
                     compiledName,
-                    type,
                     importPath,
                 }), routeFilePath);
                 if (!dryRun) {

package/dist/new/newSegment.mjs

@@ -5,6 +5,7 @@ import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 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, }) {
     const { apiDir, cwd, log } = await getProjectInfo();
     const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
@@ -13,15 +14,14 @@ export default async function newSegment({ segmentName, overwrite, dryRun, }) {
     }
     const code = await prettify(`import { initVovk } from 'vovk';
 
+export const runtime = 'edge';
+
 const controllers = {};
-const workers = {};
 
 export type Controllers = typeof controllers;
-export type Workers = typeof workers;
 
 export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
-  workers,
   controllers,
 });
 `, absoluteSegmentRoutePath);
@@ -29,5 +29,7 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
     }
-    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`vovk new controller ${[segmentName, 'someName'].filter(Boolean).join('/')}`)} to create a new controller`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}.`);
+    const dir = chalk.cyanBright([segmentName, 'thing'].filter(Boolean).join('/'));
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at modules/${dir} folder for this segment`);
 }

package/dist/new/render.d.mts

@@ -1,8 +1,11 @@
-import type { VovkConfig, VovkModuleRenderResult } from '../types.mjs';
-export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, }: {
+import type { VovkStrictConfig } from 'vovk';
+import type { VovkModuleRenderResult } from '../types.mjs';
+export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, empty, templateFileName, }: {
     cwd: string;
-    config: VovkConfig;
+    config: VovkStrictConfig;
     withService: boolean;
     segmentName: string;
     moduleName: string;
+    empty?: boolean;
+    templateFileName: string;
 }): Promise<VovkModuleRenderResult>;

package/dist/new/render.mjs

@@ -4,30 +4,42 @@ import _ from 'lodash';
 import pluralize from 'pluralize';
 import addCommonTerms from './addCommonTerms.mjs';
 addCommonTerms();
-export default async function render(codeTemplate, { config, withService, segmentName, moduleName, }) {
+export default async function render(codeTemplate, { config, withService, segmentName, moduleName, empty, templateFileName, }) {
     const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
         .filter(Boolean)
         .join('/');
-    const templateVars = {
-        // input
+    const theThing = _.camelCase(moduleName);
+    const TheThing = _.upperFirst(theThing);
+    const the_thing = _.snakeCase(moduleName);
+    const THE_THING = _.toUpper(the_thing);
+    const the__thing = _.kebabCase(moduleName);
+    const t = {
+        // module name variations
+        moduleName,
+        theThing,
+        theThings: pluralize(theThing),
+        TheThing,
+        TheThings: pluralize(TheThing),
+        the_thing,
+        the_things: pluralize(the_thing),
+        THE_THING,
+        THE_THINGS: pluralize(THE_THING),
+        'the-thing': the__thing,
+        'the-things': pluralize(the__thing),
+        // data
         config,
         withService,
         segmentName,
-        moduleName,
-        // utils
-        getModuleDirName,
+        defaultDir: getModuleDirName(segmentName, theThing),
         // libraries
         _, // lodash
         pluralize,
     };
-    // first, render the front matter because it can use ejs variables
-    const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
-    const { dirName, fileName, sourceName, compiledName } = parsed.data;
-    const code = parsed.content;
-    // const templateContent = parsed.content; TODO
-    // const code = await ejs.render(templateContent, templateVars, { async: true });
+    const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
+    const { dir, fileName, sourceName, compiledName } = parsed.data;
+    const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;
     return {
-        dirName,
+        dir,
         fileName,
         sourceName,
         compiledName,

package/dist/types.d.mts

@@ -1,55 +1,21 @@
 import type { LogLevelNames } from 'loglevel';
-export type KnownAny = any;
-export type VovkEnv = {
-    PORT?: string;
-    VOVK_CLIENT_OUT_DIR?: string;
-    VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER?: string;
-    VOVK_VALIDATE_ON_CLIENT?: string;
-    VOVK_MODULES_DIR?: string;
-    VOVK_VALIDATION_LIBRARY?: 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';
-};
-export type VovkConfig = {
-    clientOutDir?: string;
-    schemaOutDir?: string;
-    fetcher?: string;
-    validateOnClient?: string | null;
-    modulesDir?: string;
-    validationLibrary?: string | null;
-    rootEntry?: string;
-    origin?: string;
-    rootSegmentModulesDirName?: string;
-    logLevel?: LogLevelNames;
-    prettifyClient?: boolean;
-    devHttps?: boolean;
-    templates?: {
-        service?: string;
-        controller?: string;
-        worker?: string;
-        [key: string]: string | undefined;
-    };
-};
 export type VovkModuleRenderResult = {
     fileName: string;
-    dirName: string;
+    dir: string;
     sourceName?: string;
     compiledName?: string;
     code: string;
 };
 export interface DevOptions {
-    clientOut?: string;
     nextDev?: boolean;
+    exit?: boolean;
 }
 export interface GenerateOptions {
-    clientOut?: string;
+    clientOutDir?: string;
+    templates?: string[];
+    prettify?: boolean;
+    emitFullSchema?: string | boolean;
+    config?: string;
 }
 export interface InitOptions {
     yes?: boolean;
@@ -62,7 +28,7 @@ export interface InitOptions {
     updateTsConfig?: boolean;
     updateScripts?: 'implicit' | 'explicit';
     validationLibrary?: string | null;
-    validateOnClient?: boolean;
+    reactQuery?: boolean;
     dryRun?: boolean;
     channel?: 'latest' | 'beta' | 'draft';
 }
@@ -72,4 +38,5 @@ export interface NewOptions {
     dir?: string;
     overwrite?: boolean;
     noSegmentUpdate?: boolean;
+    empty?: boolean;
 }

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1,2 @@
-import { KnownAny } from '../types.mjs';
-export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;
+import type { KnownAny } from 'vovk';
+export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;

package/dist/utils/debounceWithArgs.mjs

@@ -1,14 +1,29 @@
-import debounce from 'lodash/debounce.js';
-export default function debounceWithArgs(fn, wait) {
-    const debouncedFunctions = new Map();
+export default function debounceWithArgs(callback, wait) {
+    // Stores timeouts keyed by the stringified arguments
+    const timeouts = new Map();
     return (...args) => {
+        // Convert arguments to a JSON string (or any other stable key generation)
         const key = JSON.stringify(args);
-        if (!debouncedFunctions.has(key)) {
-            debouncedFunctions.set(key, debounce(fn, wait));
-        }
-        const debouncedFn = debouncedFunctions.get(key);
-        if (debouncedFn) {
-            debouncedFn(...args);
+        // Clear any existing timer for this specific key
+        if (timeouts.has(key)) {
+            clearTimeout(timeouts.get(key));
         }
+        // Return a promise that resolves/rejects after the debounce delay
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(async () => {
+                try {
+                    const result = await callback(...args);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    // Remove the entry once the callback is invoked
+                    timeouts.delete(key);
+                }
+            }, wait);
+            timeouts.set(key, timeoutId);
+        });
     };
 }

package/dist/utils/getAvailablePort.mjs

@@ -1,5 +1,5 @@
 import net from 'node:net';
-// TODO check comments
+// Created with AI
 /**
  * Checks if a port is available.
  * @param {number} port - The port to check.

package/dist/utils/resolveAbsoluteModulePath.d.mts

@@ -0,0 +1 @@
+export default function resolveAbsoluteModulePath(modulePath: string, cwd: string): string;

package/dist/utils/resolveAbsoluteModulePath.mjs

@@ -0,0 +1,6 @@
+import path from 'node:path';
+export default function resolveAbsoluteModulePath(modulePath, cwd) {
+    return modulePath.startsWith('/') || modulePath.startsWith('.')
+        ? path.resolve(cwd, modulePath)
+        : path.resolve(cwd, './node_modules', modulePath);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.13",
+  "version": "0.0.1-draft.130",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -10,12 +10,12 @@
   "prefix": ".",
   "scripts": {
     "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -P tsconfig.build.json",
-    "build-test": "rm -rf test_dist && tsc -P tsconfig.test.json",
-    "pre-test": "npm run build && chmod +x ./dist/index.mjs && npm run build-test",
-    "test-only": "npm run pre-test && node --test --test-only test_dist/test/**/*.mjs",
-    "test": "npm run pre-test && node --test --test-concurrency=1 test_dist/test/**/*.mjs",
+    "postbuild": "chmod +x ./dist/index.mjs",
+    "pre-test": "npm run build",
+    "test-only": "npm run pre-test && node --experimental-transform-types --experimental-strip-types --test --test-only test/spec/**/*.mts",
+    "test": "npm run pre-test && node --experimental-transform-types --experimental-strip-types --test --test-concurrency=1 test/spec/**/*.mts",
     "tsc": "tsc --noEmit",
-    "ncu": "npm-check-updates -u",
+    "ncu": "npm-check-updates -u -x commander",
     "npm-publish": "npm publish"
   },
   "repository": {
@@ -28,34 +28,38 @@
     "cli",
     "vovk"
   ],
-  "author": "Andrii Gubanov",
+  "author": "Andrey Gubanov",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/finom/vovk/issues"
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.13"
+    "vovk": "^3.0.0-draft.109"
+  },
+  "optionalDependencies": {
+    "vovk-python-client": "*"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.0.1",
-    "@npmcli/package-json": "^6.0.1",
-    "chalk": "^5.3.0",
-    "chokidar": "^4.0.1",
-    "commander": "^12.1.0",
-    "concurrently": "^9.0.1",
-    "dotenv": "^16.4.5",
+    "@inquirer/prompts": "^7.3.1",
+    "@npmcli/package-json": "^6.1.1",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "concurrently": "^9.1.2",
+    "dotenv": "^16.4.7",
     "ejs": "^3.1.10",
+    "glob": "^11.0.1",
     "gray-matter": "^4.0.3",
-    "inflection": "^3.0.0",
+    "inflection": "^3.0.2",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.2",
     "pluralize": "^8.0.0",
-    "prettier": "^3.3.3",
+    "prettier": "^3.4.2",
     "tar-stream": "^3.1.7",
-    "ts-morph": "^24.0.0",
-    "undici": "^6.20.1"
+    "ts-morph": "^25.0.0",
+    "undici": "^7.3.0"
   },
   "devDependencies": {
     "@types/concat-stream": "^2.0.3",
@@ -64,8 +68,8 @@
     "@types/pluralize": "^0.0.33",
     "@types/tar-stream": "^3.1.3",
     "concat-stream": "^2.0.0",
-    "create-next-app": "^15.0.2",
+    "create-next-app": "^15.1.6",
     "node-pty": "^1.0.0",
-    "type-fest": "^4.26.1"
+    "type-fest": "^4.33.0"
   }
 }

package/templates/controller.ejs

@@ -1,51 +1,50 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-<% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var controllerName = modulePascalName + 'Controller'; %>
-<% var compiledName = modulePascalName + 'RPC'; %>
-<% var serviceName = modulePascalName + 'Service'; %>
+<% const vars = { 
+  ControllerName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
 ---
-dirName: <%= getModuleDirName(segmentName, moduleName) %>
-fileName: <%= controllerName + '.ts' %>
-sourceName: <%= controllerName %>
-compiledName: <%= compiledName %>
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ControllerName + '.ts' %>
+sourceName: <%= vars.ControllerName %>
+compiledName: <%= t.TheThing + 'RPC' %>
 ---
 
 import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
-<% if(withService) { %>
-import <%= serviceName %> from './<%= serviceName %>';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %>';
 <% } %>
 
-@prefix('<%= _.kebabCase(moduleName).toLowerCase() %>')
-export default class <%= controllerName %> {
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ControllerName %> {
     @get()
-    static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { search: string }>) => {
+    static get<%= t.TheThings %> = async (req: VovkRequest<null, { search: string }>) => {
         const search = req.nextUrl.searchParams.get('search');
-        <% if(withService) { %>
-        return <%= serviceName %>.get<%= modulePascalNamePlural %>(search);
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
         <% } else { %>
         return { results: [], search };
         <% } %>
     }
 
     @put(':id')
-    static update<%= modulePascalName %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
+    static update<%= t.TheThing %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
         const { id } = params;
         const body = await req.json();
         const q = req.nextUrl.searchParams.get('q');
-        <% if(withService) { %>
-        return <%= serviceName %>.update<%= modulePascalName %>(id, q, body);
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
         <% } else { %>
         return { id, body, q };
         <% } %>
     };
 
     @post()
-    static create<%= modulePascalName %> = () => {
+    static create<%= t.TheThing %> = () => {
         // ...
     };
 
     @del(':id')
-    static delete<%= modulePascalName %> = () => {
+    static delete<%= t.TheThing %> = () => {
         // ...
     };
 }

package/templates/service.ejs

@@ -1,24 +1,24 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-<% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var serviceName = modulePascalName + 'Service'; %>
-<% var controllerName = modulePascalName + 'Controller'; %>
+<% const vars = {
+  ControllerName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
 ---
-dirName: <%= getModuleDirName(segmentName, moduleName) %>
-fileName: <%= serviceName + '.ts' %>
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ServiceName + '.ts' %>
 ---
 
 import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
-import type <%= controllerName %> from './<%= controllerName %>';
+import type <%= vars.ControllerName %> from './<%= vars.ControllerName %>';
 
-export default class <%= serviceName %> {
-  static get<%= modulePascalNamePlural %> = (search: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>['search']) => {
+export default class <%= vars.ServiceName %> {
+  static get<%= t.TheThings %> = (search: VovkControllerQuery<typeof <%= vars.ControllerName %>.get<%= t.TheThings %>>['search']) => {
     return { results: [], search };
   };
 
-  static update<%= modulePascalName %> = (
+  static update<%= t.TheThing %> = (
     id: string,
-    q: VovkControllerQuery<typeof <%= controllerName %>.update<%= modulePascalName %>>['q'],
-    body: VovkControllerBody<typeof <%= controllerName %>.update<%= modulePascalName %>>
+    q: VovkControllerQuery<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>['q'],
+    body: VovkControllerBody<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>
   ) => {
     return { id, q, body };
   };

package/dist/generateClient.d.mts

@@ -1,7 +0,0 @@
-import type { VovkSchema } from 'vovk';
-import type { ProjectInfo } from './getProjectInfo/index.mjs';
-import type { Segment } from './locateSegments.mjs';
-export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsSchema: Record<string, VovkSchema>): Promise<{
-    written: boolean;
-    path: string;
-}>;