@appweaver/cli 1.0.0

package/LICENSE

@@ -0,0 +1 @@
+UNLICENSED

package/README.md

@@ -0,0 +1,7 @@
+# Appweaver - CLI
+
+> Simple, fast, and reliable web application builder tool.
+
+## License
+
+UNLICENSED

package/build/build-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function buildCommand(program: Command): void;

package/build/build-command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommand = buildCommand;
+const build_project_1 = require("./build-project");
+function buildCommand(program) {
+    program
+        .command('build')
+        .alias('b')
+        .description('Build the application.')
+        .option('-p, --project [path]', 'TypeScript project config file.', 'tsconfig.build.json')
+        .action(async (_, command) => {
+        const projectFile = command.getOptionValue('project');
+        process.exit(await (0, build_project_1.buildProject)(projectFile));
+    });
+}

package/build/build-project.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Builds the project by compiling TypeScript files and replacing alias paths.
+ *
+ * @param {string} projectFile - The path to the TypeScript project configuration file.
+ * @return {Promise<number>} A promise that resolves to the status code of the TypeScript compilation process.
+ * Returns 0 if the compilation process is successful.
+ */
+export declare function buildProject(projectFile: string): Promise<number>;

package/build/build-project.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProject = buildProject;
+const tsc_alias_1 = require("tsc-alias");
+const common_1 = require("@appweaver/common");
+const utils_1 = require("../utils");
+/**
+ * Builds the project by compiling TypeScript files and replacing alias paths.
+ *
+ * @param {string} projectFile - The path to the TypeScript project configuration file.
+ * @return {Promise<number>} A promise that resolves to the status code of the TypeScript compilation process.
+ * Returns 0 if the compilation process is successful.
+ */
+async function buildProject(projectFile) {
+    await (0, utils_1.rimrafPath)(common_1.config.APP_BUILD_PATH, true);
+    const tscStatus = await (0, utils_1.runProcess)('tsc', ['-p', projectFile]);
+    await (0, tsc_alias_1.replaceTscAliasPaths)({ configFile: projectFile });
+    return tscStatus || 0;
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from './build-command';
+export * from './build-project';

package/build/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./build-command"), exports);
+__exportStar(require("./build-project"), exports);

package/generate/generate-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateCommand(program: Command): void;

package/generate/generate-command.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const common_1 = require("@appweaver/common");
+const generate_types_1 = require("./generate-types");
+const generate_schema_1 = require("./generate-schema");
+const utils_1 = require("../utils");
+function generateCommand(program) {
+    program
+        .command('generate')
+        .alias('g')
+        .description('Generate application types and/or schemas.')
+        .option('-t, --types', 'Generate TypeScript types.')
+        .option('-s, --schema', 'Generate Prisma schema.')
+        .option('--modelPattern [pattern]', 'Glob pattern for finding model files. (default: from config or env).')
+        .option('--typesPath [path]', 'Output path for generated types. (default: from config or env).')
+        .option('--schemaPath [path]', 'Output path for generated Prisma schema. (default: from config or env).')
+        .option('--clientPath [path]', 'Output path for generated Prisma client (default: from config or env).')
+        .option('--verbose', 'Print verbose output.')
+        .action(async (_, command) => {
+        const quiet = !command.getOptionValue('verbose');
+        const generateAll = !command.getOptionValue('types') && !command.getOptionValue('schema');
+        const models = await (0, utils_1.loadModels)(command.getOptionValue('modelPattern') ?? common_1.config.RESOURCE_MODEL_PATTERN);
+        let typeGenerateResult = 0;
+        if (command.getOptionValue('types') || generateAll) {
+            typeGenerateResult = await (0, generate_types_1.generateTypes)(models, command.getOptionValue('typesPath') ??
+                common_1.config.RESOURCE_GENERATED_TYPES_PATH, quiet);
+        }
+        let schemaGenerateResult = 0;
+        if (command.getOptionValue('schema') || generateAll) {
+            schemaGenerateResult = await (0, generate_schema_1.generateSchema)(models, command.getOptionValue('schemaPath') ?? common_1.config.DATABASE_SCHEMA_PATH, command.getOptionValue('clientPath') ??
+                common_1.config.DATABASE_CLIENT_OUTPUT_DIR_PATH, quiet);
+        }
+        if (typeGenerateResult !== 0 || schemaGenerateResult !== 0) {
+            process.exit(typeGenerateResult || schemaGenerateResult);
+        }
+    });
+}

package/generate/generate-schema.d.ts

@@ -0,0 +1,12 @@
+import { ResourceModel } from '@appweaver/common';
+/**
+ * Generates a Prisma schema file based on the provided resource models and saves it to the specified file path.
+ *
+ * @param {Record<string, ResourceModel>} models - An object containing resource model configurations, where each key is
+ * the model name.
+ * @param {string} schemaPath - The file path where the generated Prisma schema should be stored.
+ * @param {string} clientPath - The file path where the Prisma client output should be generated.
+ * @param {boolean} [quiet=false] - Optional flag to suppress logs. Default is false.
+ * @return {Promise<number>} A promise that resolves to the number of models processed for the schema generation.
+ */
+export declare function generateSchema(models: Record<string, ResourceModel>, schemaPath: string, clientPath: string, quiet?: boolean): Promise<number>;

package/generate/generate-schema.js

@@ -0,0 +1,475 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchema = generateSchema;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const common_1 = require("@appweaver/common");
+const utils_1 = require("../utils");
+/**
+ * Generates a Prisma schema file based on the provided resource models and saves it to the specified file path.
+ *
+ * @param {Record<string, ResourceModel>} models - An object containing resource model configurations, where each key is
+ * the model name.
+ * @param {string} schemaPath - The file path where the generated Prisma schema should be stored.
+ * @param {string} clientPath - The file path where the Prisma client output should be generated.
+ * @param {boolean} [quiet=false] - Optional flag to suppress logs. Default is false.
+ * @return {Promise<number>} A promise that resolves to the number of models processed for the schema generation.
+ */
+async function generateSchema(models, schemaPath, clientPath, quiet = false) {
+    const cwd = process.cwd();
+    try {
+        await (0, utils_1.ensureDirExists)(node_path_1.default.join(cwd, schemaPath));
+        const prismaModels = {};
+        const prismaEnums = {};
+        const dbType = databaseType();
+        const relativeOutputPath = (0, utils_1.relativePathFrom)(schemaPath, clientPath);
+        const schemaContent = [
+            `// This is your Prisma schema file,`,
+            `// learn more about it in the docs: https://pris.ly/d/prisma-schema`,
+            ``,
+            `// Generated by Appweaver. Please do not edit this file manually.`,
+            ``,
+            `datasource db {`,
+            `  provider = "${dbType}"`,
+            `}`,
+            ``,
+            `generator client {`,
+            `  provider = "prisma-client"`,
+            `  output   = "${relativeOutputPath}"`,
+            common_1.config.APP_RUNTIME === common_1.Runtime.Bun ? '  runtime  = "bun"' : undefined,
+            `}`,
+            ``
+        ].filter((l) => l !== undefined);
+        let authModel;
+        for (const model of Object.values(models)) {
+            if ((0, common_1.isResourceAuthModel)(model)) {
+                authModel = model;
+                break;
+            }
+        }
+        // Create Prisma models and enums from resource model config
+        for (const [name, schema] of Object.entries(models)) {
+            if (schema.config.generateSchema === false) {
+                continue;
+            }
+            prismaModels[name] = {
+                id: createIdSchema(schema.config.id),
+                scalars: createScalarsSchema(name, schema.config.scalars),
+                relations: createRelationsSchema(name, schema.config.relations),
+                files: createFilesSchema(name, schema.config.files),
+                audit: createAuditSchema(name, authModel, schema.config.audit),
+                index: createIndexSchema(schema.config.index),
+                tableName: schema.config.tableName
+            };
+            for (const [fieldName, scalar] of Object.entries(schema.config.scalars ?? {})) {
+                if (scalar.type === 'enum' && scalar.values?.length) {
+                    prismaEnums[`${name}${(0, common_1.capitalize)(fieldName)}`] = scalar.values;
+                }
+            }
+        }
+        // Resolve model relations to match Prisma schema relationship convention
+        const createdByAuthUser = [];
+        const fileFields = [];
+        for (const [name, model] of Object.entries(prismaModels)) {
+            const modelSchema = Object.entries(models).find(([key]) => key === name)?.[1];
+            for (const relation of model.relations) {
+                if (relation.type.startsWith('Int')) {
+                    continue;
+                }
+                const relationConfig = modelSchema?.config.relations?.[relation.name];
+                const referencedName = relation.type
+                    .replaceAll('[]', '')
+                    .replaceAll('?', '');
+                const referencedModel = prismaModels[referencedName];
+                const mappedField = referencedModel.relations.find((r) => r.name === relationConfig?.mappedBy);
+                if (mappedField?.type.startsWith('Int')) {
+                    continue;
+                }
+                if (mappedField && mappedField.attributes?.length) {
+                    // Ensure that mapped fields have the same reference name
+                    const relationAttribute = mappedField.attributes[0];
+                    const relationParts = relationAttribute.split('"');
+                    const referenceName = relation.attributes?.[0].split('"')[1];
+                    relationParts.splice(1, 1, `${referenceName}`);
+                    if (relationConfig?.unique) {
+                        mappedField.attributes[0] = `@relation("${referenceName}")`;
+                    }
+                    else {
+                        mappedField.attributes[0] = relationParts.join('"');
+                    }
+                }
+                else {
+                    // For unmapped relations add a default relation field using the same
+                    // reference name
+                    const refName = (0, common_1.uncapitalize)((0, common_1.plural)(name));
+                    if (!referencedModel.relations.some((r) => r.name === refName)) {
+                        referencedModel.relations.push({
+                            name: (0, common_1.uncapitalize)((0, common_1.plural)(name)),
+                            type: `${name}[]`,
+                            attributes: relation.attributes
+                        });
+                    }
+                }
+            }
+            for (const auditField of model.audit) {
+                if (auditField.name === 'createdBy') {
+                    const referenceName = auditField.attributes?.[0].split('"')[1];
+                    createdByAuthUser.push({
+                        name: `created${(0, common_1.plural)(name)}`,
+                        type: `${name}[]`,
+                        attributes: [`@relation("${referenceName}")`]
+                    });
+                }
+            }
+            for (const fileField of model.files) {
+                const referenceName = fileField.attributes?.[0].split('"')[1];
+                if (referenceName) {
+                    fileFields.push({
+                        name: `${fileField.name}${(0, common_1.plural)(name)}`,
+                        type: `${name}[]`,
+                        attributes: [`@relation("${referenceName}")`]
+                    });
+                }
+            }
+        }
+        // Add auth model ownership relations
+        const authUserModel = prismaModels[authModel?.name ?? ''];
+        if (authUserModel) {
+            authUserModel.extra = {
+                'Ownership models referenced with createdById column': createdByAuthUser
+            };
+        }
+        // Add file fields relations
+        const fileModel = prismaModels['File'];
+        if (fileModel) {
+            fileModel.extra = {
+                'Related models with file columns': fileFields
+            };
+        }
+        // Add Prisma models to the schema content
+        for (const [name, model] of Object.entries(prismaModels)) {
+            schemaContent.push(`model ${name} {`);
+            // Group 1: id + scalars
+            const initialFields = [model.id, ...model.scalars];
+            const { nameLength, typeLength } = calculateMaxLengths(initialFields);
+            schemaContent.push(buildPrismaField(model.id, nameLength, typeLength));
+            for (const scalar of model.scalars) {
+                schemaContent.push(buildPrismaField(scalar, nameLength, typeLength));
+            }
+            // Group 2: relations
+            if (model.relations.length > 0) {
+                schemaContent.push(``);
+                schemaContent.push(`  /// Related columns`);
+                const { nameLength, typeLength } = calculateMaxLengths(model.relations);
+                for (const relation of model.relations) {
+                    schemaContent.push(buildPrismaField(relation, nameLength, typeLength));
+                }
+            }
+            // Group 3: files
+            if (model.files.length > 0) {
+                schemaContent.push(``);
+                schemaContent.push(`  /// File columns`);
+                const { nameLength, typeLength } = calculateMaxLengths(model.files);
+                for (const file of model.files) {
+                    schemaContent.push(buildPrismaField(file, nameLength, typeLength));
+                }
+            }
+            // Group 4: extra fields
+            for (const [title, extraFields] of Object.entries(model.extra ?? {})) {
+                if (extraFields.length === 0) {
+                    continue;
+                }
+                schemaContent.push(``);
+                schemaContent.push(`  /// ${title}`);
+                const { nameLength, typeLength } = calculateMaxLengths(extraFields);
+                for (const extraField of extraFields) {
+                    schemaContent.push(buildPrismaField(extraField, nameLength, typeLength));
+                }
+            }
+            // Group 5: audit
+            if (model.audit.length > 0) {
+                schemaContent.push(``);
+                schemaContent.push(`  /// Audit columns`);
+                const { nameLength, typeLength } = calculateMaxLengths(model.audit);
+                for (const audit of model.audit) {
+                    schemaContent.push(buildPrismaField(audit, nameLength, typeLength));
+                }
+            }
+            if (model.index.length) {
+                schemaContent.push(``);
+            }
+            for (const index of model.index) {
+                schemaContent.push(`  ${index}`);
+            }
+            if (model.tableName) {
+                schemaContent.push(``);
+                schemaContent.push(`  @@map("${model.tableName}")`);
+            }
+            schemaContent.push(`}`, ``);
+        }
+        // Add Prisma enums to the schema content
+        for (const [name, enumValues] of Object.entries(prismaEnums)) {
+            schemaContent.push(`enum ${name} {`);
+            for (const value of enumValues) {
+                schemaContent.push(`  ${value}`);
+            }
+            schemaContent.push(`}`, ``);
+        }
+        const outputPath = node_path_1.default.join(cwd, schemaPath);
+        let oldSchema;
+        try {
+            oldSchema = await promises_1.default.readFile(outputPath, 'utf8');
+        }
+        catch (error) {
+            // Schema currently does not exist
+        }
+        await promises_1.default.writeFile(outputPath, schemaContent.join('\n'));
+        const code = await (0, utils_1.runProcess)('prisma', ['generate'], { quiet });
+        if (code !== 0 && oldSchema) {
+            await promises_1.default.writeFile(outputPath, oldSchema);
+            console.error(`Schema generation failed.${quiet ? ' Start with --verbose flag to see error details.' : ''}`);
+            return 1;
+        }
+        else {
+            console.log(`Schema generated to ${node_path_1.default.relative(cwd, schemaPath)}`);
+            return 0;
+        }
+    }
+    catch (error) {
+        console.error('Schema generation failed', error);
+        return 2;
+    }
+}
+function buildPrismaField(field, nameLength = 0, typeLength = 0) {
+    const paddedName = field.name.padEnd(nameLength);
+    const paddedType = field.type.padEnd(typeLength);
+    return `  ${paddedName} ${paddedType} ${field.attributes?.join(' ') ?? ''}`.trimEnd();
+}
+function calculateMaxLengths(fields) {
+    let nameLength = 0;
+    let typeLength = 0;
+    for (const field of fields) {
+        if (field.name.length > nameLength) {
+            nameLength = field.name.length;
+        }
+        if (field.type.length > typeLength) {
+            typeLength = field.type.length;
+        }
+    }
+    return { nameLength, typeLength };
+}
+function createIdSchema(id = {}) {
+    const defaultType = !id.generator || id.generator === 'autoincrement()' ? 'Int' : 'String';
+    const defaultGenerator = id.type !== 'string' ? 'autoincrement()' : 'uuid()';
+    return {
+        name: 'id',
+        type: (0, common_1.capitalize)(id.type ?? defaultType),
+        attributes: ['@id', `@default(${id.generator ?? defaultGenerator})`]
+    };
+}
+function createScalarsSchema(modelName, scalars = {}) {
+    const fields = [];
+    for (const [name, scalar] of Object.entries(scalars)) {
+        fields.push(createScalarSchema(name, modelName, scalar));
+    }
+    return fields;
+}
+function createScalarSchema(name, modelName, scalar) {
+    const attributes = [];
+    const isSqlite = databaseType() === common_1.DatabaseType.Sqlite;
+    const sanitize = (val) => {
+        if ((0, common_1.isNumber)(val) || (0, common_1.isBoolean)(val)) {
+            return val;
+        }
+        else if ((0, common_1.isString)(val)) {
+            return val.replace(/"/g, '\\"');
+        }
+        else {
+            return JSON.stringify(val).replace(/"/g, '\\"');
+        }
+    };
+    let typeSuffix = scalar.required === false ? '?' : '';
+    if (scalar.array) {
+        typeSuffix = '[]';
+    }
+    const type = scalar.type === 'enum' && scalar.values?.length
+        ? `${modelName}${(0, common_1.capitalize)(name)}${typeSuffix}`
+        : `${(0, common_1.capitalize)(scalar.type)}${typeSuffix}`;
+    if (scalar.unique) {
+        attributes.push(`@unique`);
+    }
+    let defaultAttribute;
+    if (scalar.default !== undefined) {
+        if (['string', 'dateTime', 'json'].includes(scalar.type) && !scalar.array) {
+            defaultAttribute = `@default("${sanitize(scalar.default)}")`;
+        }
+        else if (scalar.array) {
+            const defaultValues = (0, common_1.isArray)(scalar.default)
+                ? scalar.default
+                : [scalar.default];
+            const mappedValues = defaultValues
+                .map((v) => ['string', 'dateTime', 'json'].includes(scalar.type)
+                ? `"${sanitize(v)}"`
+                : `${v}`)
+                .join(', ');
+            defaultAttribute = `@default([${mappedValues}])`;
+        }
+        else {
+            defaultAttribute = `@default(${sanitize(scalar.default)})`;
+        }
+    }
+    else if (scalar.defaultGenerator !== undefined) {
+        defaultAttribute = `@default(${scalar.defaultGenerator})`;
+    }
+    else if (scalar.defaultExpression?.length) {
+        defaultAttribute = `@default(dbgenerated("${scalar.defaultExpression}"))`;
+    }
+    if (defaultAttribute) {
+        attributes.push(defaultAttribute);
+    }
+    if (scalar.type === 'string' && scalar.maxLength && !isSqlite) {
+        attributes.push(`@db.VarChar(${scalar.maxLength})`);
+    }
+    return {
+        name,
+        type,
+        attributes
+    };
+}
+function createRelationsSchema(modelName, relations = {}) {
+    const fields = [];
+    for (const [name, relation] of Object.entries(relations)) {
+        fields.push(...createRelationSchema(name, modelName, relation));
+    }
+    return fields;
+}
+function createRelationSchema(name, modelName, relation) {
+    const attributes = [];
+    const relationName = `${modelName}${(0, common_1.capitalize)(name)}${relation.model}`;
+    const relationFieldName = `${name}Id`;
+    const relationSuffix = relation.required === false ? '?' : '';
+    const type = relation.array
+        ? `${relation.model}[]`
+        : `${relation.model}${relationSuffix}`;
+    if (relation.array) {
+        attributes.push(`@relation("${relationName}")`);
+    }
+    else {
+        const referentialActions = [];
+        if (relation.onDelete) {
+            referentialActions.push(`onDelete: ${(0, common_1.capitalize)(relation.onDelete)}`);
+        }
+        if (relation.onUpdate) {
+            referentialActions.push(`onUpdate: ${(0, common_1.capitalize)(relation.onUpdate)}`);
+        }
+        const referentialConfig = referentialActions.length > 0 ? `, ${referentialActions.join(', ')}` : '';
+        attributes.push(`@relation("${relationName}", fields: [${relationFieldName}], references: [id]${referentialConfig})`);
+    }
+    const relationFields = [
+        {
+            name,
+            type,
+            attributes
+        }
+    ];
+    if (!relation.array && relation.owner) {
+        relationFields.push({
+            name: relationFieldName,
+            type: `Int${relationSuffix}`,
+            attributes: relation.unique === true ? ['@unique'] : []
+        });
+    }
+    return relationFields;
+}
+function createFilesSchema(modelName, files = {}) {
+    const fields = [];
+    for (const [name, file] of Object.entries(files)) {
+        fields.push(...createFileSchema(name, modelName, file));
+    }
+    return fields;
+}
+function createFileSchema(name, modelName, file) {
+    const attributes = [];
+    const type = file.array ? 'File[]' : 'File?';
+    const fileRelationName = `${modelName}${(0, common_1.capitalize)(name)}File`;
+    const fileRelationFieldName = `${name}Id`;
+    if (file.array) {
+        attributes.push(`@relation("${fileRelationName}")`);
+    }
+    else {
+        attributes.push(`@relation("${fileRelationName}", fields: [${fileRelationFieldName}], references: [id])`);
+    }
+    const fileFields = [
+        {
+            name,
+            type,
+            attributes
+        }
+    ];
+    if (!file.array) {
+        fileFields.push({
+            name: fileRelationFieldName,
+            type: 'Int?',
+            attributes: ['@unique']
+        });
+    }
+    return fileFields;
+}
+function createAuditSchema(modelName, authModel, audit = {}) {
+    const defaultAudit = {
+        updatedAt: true,
+        createdAt: true,
+        createdById: true
+    };
+    const mergedAudit = { ...defaultAudit, ...audit };
+    const fields = [];
+    const authModelName = authModel?.name;
+    if (mergedAudit.updatedAt) {
+        fields.push({
+            name: 'updatedAt',
+            type: 'DateTime',
+            attributes: ['@updatedAt']
+        });
+    }
+    if (mergedAudit.createdAt) {
+        fields.push({
+            name: 'createdAt',
+            type: 'DateTime',
+            attributes: ['@default(now())']
+        });
+    }
+    if (mergedAudit.createdById && authModelName) {
+        fields.push({
+            name: 'createdBy',
+            type: `${authModelName}?`,
+            attributes: [
+                `@relation("${modelName}CreatedBy${authModelName}", fields: [createdById], references: [id])`
+            ]
+        });
+        fields.push({
+            name: 'createdById',
+            type: 'Int?'
+        });
+    }
+    return fields;
+}
+function createIndexSchema(index) {
+    const indexes = [];
+    if (!index || index.length === 0) {
+        return indexes;
+    }
+    for (const idx of index) {
+        const indexValue = (0, common_1.isArray)(idx) ? `[${idx.join(', ')}]` : idx;
+        const indexExpression = `@@index(${indexValue})`;
+        if (!indexes.includes(indexExpression)) {
+            indexes.push(indexExpression);
+        }
+    }
+    return indexes;
+}
+function databaseType() {
+    return (0, common_1.resolveDatabaseType)(common_1.config.DATABASE_TYPE, common_1.config.DATABASE_URL);
+}

package/generate/generate-types.d.ts

@@ -0,0 +1,10 @@
+import { ResourceModel } from '@appweaver/common';
+/**
+ * Generates TypeScript type definitions for the given resource models and writes them to a specified directory.
+ *
+ * @param {Record<string, ResourceModel>} models - A set of resource models for which TypeScript types will be generated.
+ * @param {string} typesPath - The relative path to the directory where the generated types will be written.
+ * @param {boolean} [quiet=false] - If true, suppresses detailed logging during the operation.
+ * @return {Promise<number>} A promise that resolves to a status code: `0` for success, `2` for failure.
+ */
+export declare function generateTypes(models: Record<string, ResourceModel>, typesPath: string, quiet?: boolean): Promise<number>;