@chargebee/chargebee-apps-shared 0.0.2

package/dist/libs/archive-service.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchiveService = void 0;
+const archiver_1 = __importDefault(require("archiver"));
+const path_1 = __importDefault(require("path"));
+const internal_logger_1 = require("../logger/internal-logger");
+const yauzl = __importStar(require("yauzl"));
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("fs");
+/**
+ * Archive service for managing zip file creation and extraction
+ */
+class ArchiveService {
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+    }
+    /**
+     * Creates the zip package
+     * @param {string[]} files - Array of files to package
+     * @param {string} appDir - The application directory
+     * @param {string} outputPath - The output path for the package
+     */
+    createZipPackage(files, appDir, outputPath) {
+        return new Promise((resolve, reject) => {
+            const output = this.fileSystem.createWriteStream(outputPath);
+            const archive = (0, archiver_1.default)('zip');
+            output.on('close', () => {
+                internal_logger_1.__logger.info(`Archive created: ${archive.pointer()} total bytes`);
+                resolve();
+            });
+            output.on('error', (err) => {
+                internal_logger_1.__logger.error('Error writing to output file:', err);
+                reject(err);
+            });
+            archive.on('error', (err) => {
+                internal_logger_1.__logger.error('Error creating archive:', err);
+                reject(err);
+            });
+            archive.pipe(output);
+            // Add files to the archive
+            files.forEach(file => {
+                const filePath = path_1.default.join(appDir, file);
+                if (this.fileSystem.existsSync(filePath)) {
+                    archive.file(filePath, { name: file });
+                    internal_logger_1.__logger.info(`  - Added: ${file}`);
+                }
+            });
+            archive.finalize();
+        });
+    }
+    /**
+     * Extract zip file to specified directory using yauzl
+     * @param {string} zipFilePath - Path to the zip file
+     * @param {string} extractDir - Directory to extract contents to
+     */
+    extractZipFile(zipFilePath, extractDir) {
+        return new Promise((resolve, reject) => {
+            yauzl.open(zipFilePath, { lazyEntries: true }, (err, zipfile) => {
+                if (err) {
+                    internal_logger_1.__logger.error('Error opening zip file:', err);
+                    reject(err);
+                    return;
+                }
+                zipfile.readEntry();
+                zipfile.on('entry', (entry) => {
+                    if (/\/$/.test(entry.fileName)) {
+                        // Directory entry
+                        const dirPath = path_1.default.join(extractDir, entry.fileName);
+                        fs_1.default.mkdirSync(dirPath, { recursive: true });
+                        zipfile.readEntry();
+                    }
+                    else {
+                        // File entry
+                        zipfile.openReadStream(entry, (err, readStream) => {
+                            if (err) {
+                                internal_logger_1.__logger.error('Error opening read stream:', err);
+                                reject(err);
+                                return;
+                            }
+                            const filePath = path_1.default.join(extractDir, entry.fileName);
+                            const dirPath = path_1.default.dirname(filePath);
+                            // Ensure directory exists
+                            fs_1.default.mkdirSync(dirPath, { recursive: true });
+                            const writeStream = (0, fs_2.createWriteStream)(filePath);
+                            readStream.pipe(writeStream);
+                            writeStream.on('close', () => {
+                                internal_logger_1.__logger.info(`Extracted: ${entry.fileName}`);
+                                zipfile.readEntry();
+                            });
+                            writeStream.on('error', (err) => {
+                                internal_logger_1.__logger.error('Error writing to file:', err);
+                                reject(err);
+                            });
+                        });
+                    }
+                });
+                zipfile.on('end', () => {
+                    internal_logger_1.__logger.info('Extraction completed');
+                    resolve();
+                });
+                zipfile.on('error', (err) => {
+                    internal_logger_1.__logger.error('Error processing zip file:', err);
+                    reject(err);
+                });
+            });
+        });
+    }
+}
+exports.ArchiveService = ArchiveService;

package/dist/libs/file-management-service.d.ts

@@ -0,0 +1,59 @@
+import { CBFileSystem } from "../node/file-system";
+export interface FileSystemConfig {
+    include: {
+        directories: DirectoryConfig[];
+    };
+}
+export interface DirectoryConfig {
+    name: string;
+    allowedExtensions?: string[];
+    excludeSubdirs?: string[];
+    includeFiles?: string[];
+    excludeFiles?: string[];
+}
+/**
+ * File management service for handling file operations
+ */
+export declare class FileManagementService {
+    private fileSystem;
+    private packageConfig;
+    constructor(fileSystem: CBFileSystem, packageConfig: FileSystemConfig);
+    /**
+     * Collects essential files for the serverless application package
+     * Only includes files and directories specified in packageConfig
+     * @param {string} appDir - The application directory
+     * @returns {string[]} Array of file paths to package
+     */
+    collectFilesToPackage(appDir: string): string[];
+    /**
+     * Cleans all files and folders inside the dist directory
+     * @param {string} appDir - The application directory
+     */
+    cleanExistingPackages(appDir: string): void;
+    /**
+     * Determines the output path for the package
+     * @param {string} appDir - The application directory
+     * @param {string} appName - The application name
+     * @param {PackageOptions} options - Package options
+     * @returns {string} The output path for the package
+     */
+    determineOutputPath(appDir: string, appName: string, packageName?: string): string;
+    /**
+     * Gets the file size in a human-readable format
+     * @param {string} filePath - The file path
+     * @returns {string} Human-readable file size
+     */
+    getFileSize(filePath: string): string;
+    /**
+     * Collects files recursively from a directory based on directory-specific configurations
+     * @param {string} dir - The directory to scan
+     * @param {DirectoryConfig} dirConfig - Directory configuration with file inclusion/exclusion rules
+     * @returns {string[]} Array of file paths relative to the scanned directory
+     */
+    protected getFilesRecursively(dir: string, dirConfig: DirectoryConfig): string[];
+    /**
+     * Recursively deletes a directory and all its contents
+     * @param {string} dirPath - The directory path to delete
+     */
+    protected deleteDirectoryRecursively(dirPath: string): void;
+}

package/dist/libs/file-management-service.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManagementService = void 0;
+const internal_logger_1 = require("../logger/internal-logger");
+const path_1 = __importDefault(require("path"));
+/**
+ * File management service for handling file operations
+ */
+class FileManagementService {
+    constructor(fileSystem, packageConfig) {
+        this.fileSystem = fileSystem;
+        this.packageConfig = packageConfig;
+    }
+    /**
+     * Collects essential files for the serverless application package
+     * Only includes files and directories specified in packageConfig
+     * @param {string} appDir - The application directory
+     * @returns {string[]} Array of file paths to package
+     */
+    collectFilesToPackage(appDir) {
+        const files = [];
+        // Process directories specified in packageConfig
+        this.packageConfig.include.directories.forEach(dirConfig => {
+            if (dirConfig.name === '.') {
+                // Handle root directory case - collect files directly from appDir
+                const rootFiles = this.getFilesRecursively(appDir, dirConfig);
+                files.push(...rootFiles);
+            }
+            else {
+                // Handle subdirectory case
+                const dirPath = path_1.default.join(appDir, dirConfig.name);
+                if (this.fileSystem.existsSync(dirPath)) {
+                    const dirFiles = this.getFilesRecursively(dirPath, dirConfig);
+                    // Add directory files with directory prefix
+                    dirFiles.forEach((file) => {
+                        files.push(`${dirConfig.name}/${file}`);
+                    });
+                }
+                else {
+                    throw new Error(`Directory ${dirPath} does not exist`);
+                }
+            }
+        });
+        internal_logger_1.__logger.info(`Collected ${files.length} files to package`);
+        internal_logger_1.__logger.info(`  - Directories: ${this.packageConfig.include.directories.map(d => d.name).join(', ')}`);
+        return files;
+    }
+    /**
+     * Cleans all files and folders inside the dist directory
+     * @param {string} appDir - The application directory
+     */
+    cleanExistingPackages(appDir) {
+        const distDir = path_1.default.join(appDir, 'dist');
+        if (!this.fileSystem.existsSync(distDir)) {
+            this.fileSystem.mkdirSync(distDir, { recursive: true });
+            return;
+        }
+        const files = this.fileSystem.readdirSync(distDir);
+        if (files.length > 0) {
+            internal_logger_1.__logger.info(`Cleaning ${files.length} item(s) in dist directory...`);
+            files.forEach(item => {
+                const itemPath = path_1.default.join(distDir, item);
+                const stat = this.fileSystem.statSync(itemPath);
+                if (stat.isDirectory()) {
+                    this.deleteDirectoryRecursively(itemPath);
+                    internal_logger_1.__logger.info(`  - Removed directory: ${item}/`);
+                }
+                else {
+                    this.fileSystem.unlinkSync(itemPath);
+                }
+            });
+        }
+    }
+    /**
+     * Determines the output path for the package
+     * @param {string} appDir - The application directory
+     * @param {string} appName - The application name
+     * @param {PackageOptions} options - Package options
+     * @returns {string} The output path for the package
+     */
+    determineOutputPath(appDir, appName, packageName) {
+        const distDir = path_1.default.join(appDir, 'dist');
+        packageName = packageName || appName;
+        const zipFileName = `${packageName}.zip`;
+        return path_1.default.join(distDir, zipFileName);
+    }
+    /**
+     * Gets the file size in a human-readable format
+     * @param {string} filePath - The file path
+     * @returns {string} Human-readable file size
+     */
+    getFileSize(filePath) {
+        const stats = this.fileSystem.statSync(filePath);
+        const bytes = stats.size;
+        if (bytes === 0) {
+            return '0 Bytes';
+        }
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    /**
+     * Collects files recursively from a directory based on directory-specific configurations
+     * @param {string} dir - The directory to scan
+     * @param {DirectoryConfig} dirConfig - Directory configuration with file inclusion/exclusion rules
+     * @returns {string[]} Array of file paths relative to the scanned directory
+     */
+    getFilesRecursively(dir, dirConfig) {
+        const files = [];
+        // Get configuration values
+        const allowedExtensions = dirConfig.allowedExtensions || [];
+        const excludeSubdirs = dirConfig.excludeSubdirs || [];
+        const includeFiles = dirConfig.includeFiles || [];
+        const excludeFiles = dirConfig.excludeFiles || [];
+        const scanDirectory = (currentDir, baseDir) => {
+            const items = this.fileSystem.readdirSync(currentDir);
+            for (const item of items) {
+                const itemPath = path_1.default.join(currentDir, item);
+                const lstat = this.fileSystem.lstatSync(itemPath);
+                // Skip symlinks — they may be broken (e.g. .bin/ entries in Docker overlay fs)
+                if (lstat.isSymbolicLink()) {
+                    continue;
+                }
+                const stat = this.fileSystem.statSync(itemPath);
+                if (stat.isDirectory()) {
+                    // Skip excluded subdirectories
+                    if (!excludeSubdirs.includes(item)) {
+                        scanDirectory(itemPath, baseDir);
+                    }
+                }
+                else {
+                    // Apply file inclusion/exclusion logic
+                    if (item && typeof item === 'string') {
+                        const relativePath = path_1.default.relative(baseDir, itemPath);
+                        let shouldInclude = false;
+                        // Priority 1: Check specific file inclusion (highest priority)
+                        if (includeFiles.length > 0) {
+                            shouldInclude = includeFiles.includes(item);
+                        }
+                        // Priority 2: Check extension-based inclusion (if no specific files defined)
+                        else if (allowedExtensions.length > 0) {
+                            const ext = path_1.default.extname(item).toLowerCase();
+                            shouldInclude = allowedExtensions.includes(ext);
+                        }
+                        // Priority 3: Include all files if no inclusion rules defined
+                        else {
+                            shouldInclude = true;
+                        }
+                        // Apply exclusion rules (always applied if file was included)
+                        if (shouldInclude && excludeFiles.length > 0) {
+                            shouldInclude = !excludeFiles.includes(item);
+                        }
+                        if (shouldInclude) {
+                            files.push(relativePath);
+                        }
+                    }
+                }
+            }
+        };
+        if (this.fileSystem.existsSync(dir)) {
+            scanDirectory(dir, dir);
+        }
+        return files;
+    }
+    /**
+     * Recursively deletes a directory and all its contents
+     * @param {string} dirPath - The directory path to delete
+     */
+    deleteDirectoryRecursively(dirPath) {
+        const files = this.fileSystem.readdirSync(dirPath);
+        for (const file of files) {
+            const filePath = path_1.default.join(dirPath, file);
+            const stat = this.fileSystem.statSync(filePath);
+            if (stat.isDirectory()) {
+                this.deleteDirectoryRecursively(filePath);
+            }
+            else {
+                this.fileSystem.unlinkSync(filePath);
+            }
+        }
+        // Remove the empty directory
+        this.fileSystem.rmdirSync(dirPath);
+    }
+}
+exports.FileManagementService = FileManagementService;

package/dist/libs/iparams-service.d.ts

@@ -0,0 +1,69 @@
+import { CBFileSystem } from '../node/file-system';
+import { IparamInputs, IparamDefns } from '../types/common';
+/**
+ * Service for managing parameters
+ * Handles loading, validation, and management of iparams and inputs
+ */
+export declare class IparamsService {
+    private fileSystem;
+    private iparamDefnsValidator;
+    private inputsValidator;
+    constructor(fileSystem: CBFileSystem);
+    private getIparamsFilePath;
+    private getInputsFilePath;
+    /**
+     * Checks if iparams.json file exists
+     * @param {string} appDir - The application directory
+     * @returns {boolean} True if the file exists
+     */
+    iparamsFileExists(appDir: string): boolean;
+    /**
+     * Loads and validates the iparamDefns
+     * @param {string} appDir - The application directory
+     * @returns {IparamDefns} The validated iparamDefns
+     * @throws {Error} If the iparamDefns is invalid or cannot be read
+     */
+    loadIparamDefns(appDir: string): IparamDefns;
+    /**
+     * Loads iparam inputs (without validation against defns). Validates file shape only.
+     * @param {string} appDir - The application directory
+     * @returns {IparamInputs} The loaded inputs
+     * @throws {Error} If `iparams.local.json` is missing, invalid JSON, or not a plain object
+     */
+    loadInputs(appDir: string): IparamInputs;
+    /**
+     * Merges inputs with defaults per section.
+     * @param {IparamInputs} inputs - The provided input values
+     * @param {IparamDefns} iparamDefns - The iparam defns
+     * @returns {IparamInputs} The merged inputs with defaults applied
+     * @throws {MissingRequiredParamsError} When required parameters are missing
+     */
+    mergeInputsWithDefaults(inputs: IparamInputs, iparamDefns: IparamDefns): IparamInputs;
+    /**
+     * Loads inputs and defns, validates inputs against defns, merges with defaults, returns resolved iparams.
+     * @param {string} appDir - The application directory
+     * @returns {IparamInputs} The merged inputs with defaults applied
+     * @throws {Error} If validation fails, or required parameters are missing and have no defaults
+     */
+    validateAndGetInputsForExecution(appDir: string): IparamInputs;
+    /**
+     * Saves the iparamDefns to file
+     * @param {string} appDir - The application directory
+     * @param {IparamDefns} iparamDefns - The iparamDefns to save
+     * @throws {Error} If the iparamDefns is invalid or cannot be written
+     */
+    saveIparamDefns(appDir: string, iparamDefns: IparamDefns): void;
+    /**
+     * Loads defns and merges inputs, ensures iparams.local.json exists, then writes.
+     * @param {string} appDir - The application directory
+     * @param {IparamInputs} inputs - The raw input values from the request
+     * @throws {Error} If iparams.json or iparams.local.json is missing, or validation fails
+     */
+    saveInputs(appDir: string, inputs: IparamInputs): void;
+    /**
+     * Validates iparams file without loading it
+     * @param {string} appDir - The application directory
+     * @throws {Error} If the iparamDefns is invalid
+     */
+    validateIparamDefns(appDir: string): void;
+}

package/dist/libs/iparams-service.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IparamsService = void 0;
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const iparams_inputs_validator_1 = require("../validator/iparams-inputs-validator");
+const iparam_defns_validator_1 = require("../validator/iparam-defns-validator");
+const validator_utils_1 = require("../validator/validator-utils");
+/**
+ * Service for managing parameters
+ * Handles loading, validation, and management of iparams and inputs
+ */
+class IparamsService {
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+        this.iparamDefnsValidator = new iparam_defns_validator_1.IparamDefnsValidator(fileSystem);
+        this.inputsValidator = new iparams_inputs_validator_1.IparamInputsValidator(fileSystem);
+    }
+    getIparamsFilePath(appDir) {
+        return path_1.default.join(appDir, 'iparams.json');
+    }
+    getInputsFilePath(appDir) {
+        return path_1.default.join(appDir, 'iparams.local.json');
+    }
+    /**
+     * Checks if iparams.json file exists
+     * @param {string} appDir - The application directory
+     * @returns {boolean} True if the file exists
+     */
+    iparamsFileExists(appDir) {
+        return this.fileSystem.existsSync(this.getIparamsFilePath(appDir));
+    }
+    /**
+     * Loads and validates the iparamDefns
+     * @param {string} appDir - The application directory
+     * @returns {IparamDefns} The validated iparamDefns
+     * @throws {Error} If the iparamDefns is invalid or cannot be read
+     */
+    loadIparamDefns(appDir) {
+        return this.iparamDefnsValidator.validateAndGetIparamDefnsFile(this.getIparamsFilePath(appDir));
+    }
+    /**
+     * Loads iparam inputs (without validation against defns). Validates file shape only.
+     * @param {string} appDir - The application directory
+     * @returns {IparamInputs} The loaded inputs
+     * @throws {Error} If `iparams.local.json` is missing, invalid JSON, or not a plain object
+     */
+    loadInputs(appDir) {
+        return this.inputsValidator.validateAndGetIparamInputsFile(this.getInputsFilePath(appDir));
+    }
+    /**
+     * Merges inputs with defaults per section.
+     * @param {IparamInputs} inputs - The provided input values
+     * @param {IparamDefns} iparamDefns - The iparam defns
+     * @returns {IparamInputs} The merged inputs with defaults applied
+     * @throws {MissingRequiredParamsError} When required parameters are missing
+     */
+    mergeInputsWithDefaults(inputs, iparamDefns) {
+        const mergedInputs = {};
+        const missingRequired = [];
+        for (const section of iparamDefns.installation_parameters?.sections ?? []) {
+            const sectionInputs = inputs[section.name] ?? {};
+            const mergedSection = {};
+            for (const param of section.parameters) {
+                const value = sectionInputs[param.name];
+                const hasValue = iparams_inputs_validator_1.IparamInputsValidator.isProvidedIparamInputValue(value);
+                if (hasValue) {
+                    mergedSection[param.name] = value;
+                    continue;
+                }
+                if (param.default !== undefined && param.default !== null) {
+                    mergedSection[param.name] = param.default;
+                    continue;
+                }
+                if (param.required) {
+                    missingRequired.push(`${section.name}.${param.name}`);
+                }
+            }
+            if (Object.keys(mergedSection).length > 0) {
+                mergedInputs[section.name] = mergedSection;
+            }
+        }
+        if (missingRequired.length > 0) {
+            throw new errors_1.MissingRequiredParamsError(missingRequired);
+        }
+        return mergedInputs;
+    }
+    /**
+     * Loads inputs and defns, validates inputs against defns, merges with defaults, returns resolved iparams.
+     * @param {string} appDir - The application directory
+     * @returns {IparamInputs} The merged inputs with defaults applied
+     * @throws {Error} If validation fails, or required parameters are missing and have no defaults
+     */
+    validateAndGetInputsForExecution(appDir) {
+        const inputs = this.loadInputs(appDir);
+        const iparamDefns = this.loadIparamDefns(appDir);
+        this.inputsValidator.validateInputs(inputs, iparamDefns);
+        return this.mergeInputsWithDefaults(inputs, iparamDefns);
+    }
+    /**
+     * Saves the iparamDefns to file
+     * @param {string} appDir - The application directory
+     * @param {IparamDefns} iparamDefns - The iparamDefns to save
+     * @throws {Error} If the iparamDefns is invalid or cannot be written
+     */
+    saveIparamDefns(appDir, iparamDefns) {
+        (0, validator_utils_1.ensureFileExists)(this.fileSystem, this.getIparamsFilePath(appDir));
+        this.iparamDefnsValidator.validate(iparamDefns);
+        this.fileSystem.writeFileSync(this.getIparamsFilePath(appDir), JSON.stringify(iparamDefns, null, '\t'));
+    }
+    /**
+     * Loads defns and merges inputs, ensures iparams.local.json exists, then writes.
+     * @param {string} appDir - The application directory
+     * @param {IparamInputs} inputs - The raw input values from the request
+     * @throws {Error} If iparams.json or iparams.local.json is missing, or validation fails
+     */
+    saveInputs(appDir, inputs) {
+        const iparamDefns = this.loadIparamDefns(appDir);
+        this.inputsValidator.validateInputs(inputs, iparamDefns);
+        const mergedInputs = this.mergeInputsWithDefaults(inputs, iparamDefns);
+        (0, validator_utils_1.ensureFileExists)(this.fileSystem, this.getInputsFilePath(appDir));
+        this.fileSystem.writeFileSync(this.getInputsFilePath(appDir), JSON.stringify(mergedInputs, null, '\t'));
+    }
+    /**
+     * Validates iparams file without loading it
+     * @param {string} appDir - The application directory
+     * @throws {Error} If the iparamDefns is invalid
+     */
+    validateIparamDefns(appDir) {
+        this.iparamDefnsValidator.validateAndGetIparamDefnsFile(this.getIparamsFilePath(appDir));
+    }
+}
+exports.IparamsService = IparamsService;

package/dist/libs/template-service.d.ts

@@ -0,0 +1,57 @@
+import { CBFileSystem } from '../node/file-system';
+/**
+ * Template service for managing templates across different CLI packages
+ */
+export declare class TemplateService {
+    private fileSystem;
+    private templatesDir;
+    constructor(fileSystem: CBFileSystem, templatesDir: string);
+    /**
+     * Validates template exists
+     * @param {string} template - Template name to validate
+     * @returns {boolean} True if template is valid
+     */
+    validateTemplate(template: string): boolean;
+    /**
+     * Validates app directory for conflicts
+     * @param {string} targetDir - Target directory path
+     * @param {string} appDir - Original app directory argument
+     * @param {string} template - Template name
+     * @returns {string[]} Array of conflicting files (empty if no conflicts)
+     */
+    validateAppDirectory(targetDir: string, appDir: string, template: string): string[];
+    /**
+     * Gets a list of available templates from the templates directory
+     * @returns {string[]} Array of template names
+     */
+    getAvailableTemplates(): string[];
+    /**
+     * Gets the full path to a specific template
+     * @param {string} template - Template name
+     * @returns {string} Full path to the template directory
+     */
+    getTemplatePath(template: string): string;
+    /**
+     * Gets the templates directory path
+     * @returns {string} Path to the templates directory
+     */
+    getTemplatesDirectory(): string;
+    /**
+     * Recursively collects all files from a template directory
+     * @param {string} templatePath - Path to the template directory
+     * @returns {string[]} Array of file paths relative to template root
+     */
+    getTemplateFiles(templatePath: string): string[];
+    /**
+     * Recursively copies all files from template directory to target directory
+     * @param {string} templatePath - Source template directory path
+     * @param {string} targetPath - Target directory path
+     */
+    copyTemplateFiles(templatePath: string, targetPath: string): void;
+    /**
+     * Prints a tree-like structure of the project directory
+     * @param {string} dir - Directory path to print structure for
+     * @param {string} [indent=''] - Current indentation level
+     */
+    printProjectStructure(dir: string, indent?: string): void;
+}