@suitegeezus/suitecloud-stacker 25.2.127

package/lib/pathHelpers.js

@@ -0,0 +1,428 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/pathHelpers
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFileExtensions = exports.removeIllegalObjectFiles = exports.removeIllegalFileCabinetFiles = exports.getAllFilesRecursively = exports.findMatchingDirectories = exports.getAccountFolders = exports.getAbsolutePath = exports.makeTempDirForSdf = exports.removeFile = exports.removeTempDirForSdf = exports.getAccountDir = exports.getRelativeOf = exports.getDifferenceFromProjectRootToFileCabinet = exports.getFolderHoldingFileCabinetPlus = exports.getRootOfAccount = exports.getSuiteCloudConfigPath = exports.joinPaths = exports.combineOverLappingPaths = exports.getRootOfProject = exports.hasFile = exports.CONSTANTS = void 0;
+const nodePath = require("node:path");
+const fs = require("node:fs/promises");
+const validators_1 = require("./validators");
+const minimatch_1 = require("minimatch");
+const makeManifest = require("./makeManifestXml");
+const packageJsonLocation = nodePath.dirname(require.resolve('#root/package.json'));
+const AccountRoots = [
+    'SuiteScripts',
+    'FileCabinet',
+    'Objects',
+];
+exports.CONSTANTS = {
+    TSCONFIG_SS21: 'tsconfig.ss21.json',
+    SDF_DEFAULT_ROOT: 'src',
+    SDF_TEMP_ROOT: '.src',
+    SDF_FILE_CABINET: 'FileCabinet',
+    SDF_TEMP_ROOT_RGX: new RegExp('(?:^|\W)[.]src\b')
+};
+/**
+ * @description - have it or not
+ * @param filePath
+ * @returns {false|string}
+ */
+const hasFile = async (filePath) => {
+    const path = nodePath.join(...[filePath].flat());
+    return fs.access(path, fs.constants.R_OK)
+        .then(() => path)
+        .catch(() => false);
+};
+exports.hasFile = hasFile;
+/**
+ * ⚠️⚠️⚠️⚠️⚠️ WARNING: this gets the root of this project and not the project using this as a dependency!
+ * @returns {string} e.g. /Users/jdoe/code/nsaccounts
+ */
+const getRootOfProject = () => {
+    return packageJsonLocation;
+};
+exports.getRootOfProject = getRootOfProject;
+/**
+ * @description - for example:
+ * - a relative path and the current directory
+ * - the entire path and a SuiteScripts path that both have SuiteScripts in it
+ * @param path1 -- must be an absolute path
+ * @param path2 - can be a partial path, relative path or special SDK path e.g. /SuiteScripts
+ */
+const combineOverLappingPaths = (path1, path2) => {
+    // remove any separators or dots
+    const normalizedPath1 = nodePath.normalize(path1);
+    const normalizedPath2 = nodePath.normalize(path2);
+    // first resolve any relative paths
+    const projectPath = process.env.SUITECLOUD_PROJECT_PATH || normalizedPath1;
+    const newPath2 = (0, exports.getAbsolutePath)({
+        projectPath,
+        filePath: path2
+    });
+    // address any obvious overlap
+    if (normalizedPath1.includes(normalizedPath2))
+        return normalizedPath1;
+    if (normalizedPath2.includes(normalizedPath1))
+        return normalizedPath2;
+    // Split paths into segments (ignoring any empty segments)
+    const parts1 = normalizedPath1.split(/[\/\\]/).filter(Boolean);
+    const parts2 = normalizedPath2.split(/[\/\\]/).filter(Boolean);
+    // Determine the maximum overlap length between the end of parts1 and start of parts2.
+    let overlapLength = 0;
+    const maxOverlap = Math.min(parts1.length, parts2.length);
+    for (let i = maxOverlap; i > 0; i--) {
+        // Compare the last i segments of parts1 with the first i segments of parts2.
+        if (parts1.slice(-i).join(nodePath.sep) === parts2.slice(0, i).join(nodePath.sep)) {
+            overlapLength = i;
+            break;
+        }
+    }
+    // Create the combined segments: all of parts1 plus the non-overlapping part of parts2.
+    const combinedParts = parts1.concat(parts2.slice(overlapLength));
+    // Reconstruct the path. Preserve absolute paths from the first argument.
+    // If path1 is absolute, ensure the result starts with the path separator.
+    let combinedPath = combinedParts.join(nodePath.sep);
+    if (nodePath.isAbsolute(normalizedPath1)) {
+        combinedPath = nodePath.sep + combinedPath;
+    }
+    return combinedPath;
+};
+exports.combineOverLappingPaths = combineOverLappingPaths;
+const joinPaths = (...paths) => {
+    return nodePath.join(...paths);
+};
+exports.joinPaths = joinPaths;
+/**
+ *
+ * @param {string} [path]
+ * @returns {Promise<string>}
+ */
+const getSuiteCloudConfigPath = async (path) => {
+    const pathToUse = path || process.env['SUITECLOUD_PROJECT_ROOT'] || process.cwd();
+    await fs.access(pathToUse, fs.constants.R_OK);
+    return pathToUse;
+};
+exports.getSuiteCloudConfigPath = getSuiteCloudConfigPath;
+/**
+ *
+ * @param {string} folder - the current place that you are. e.g process.cwd() or __dirname or whatever
+ * @param {boolean} [folderNameOnly] - where to strip off the folders e.g. 12345323
+ * @returns {string} e.g. /path/to/12346357
+ */
+const getRootOfAccount = (folder, folderNameOnly) => {
+    // get the root and subtract that
+    const projectRoot = (0, exports.getRootOfProject)();
+    const projectFolder = folder.replace(projectRoot, '')
+        // slit on dir separators
+        .split(/[\\\/]/)
+        // filter out leading slash artifacts
+        .filter(Boolean)
+        // return the first
+        .shift();
+    console.log({ projectFolder, projectRoot });
+    return folderNameOnly === true ? projectFolder : nodePath.join(projectRoot, projectFolder);
+};
+exports.getRootOfAccount = getRootOfAccount;
+/**
+ * @description - aka. "projectPath" in SDF SDK - the combination of where the config resolves and the projectFolder
+ * @param {string} anyCabinetPathInAccount
+ * @returns {string} e.g. /Users/jdoe/code/nsaccounts/24365476/src
+ */
+const getFolderHoldingFileCabinet = (anyCabinetPathInAccount) => {
+    if (/\bFileCabinet\b/.test(anyCabinetPathInAccount))
+        // get the filecabinet and subtract that
+        return anyCabinetPathInAccount.replace(/^(.*?).\bFileCabinet\b.*$/, '$1');
+    if (process.env['SUITECLOUD_PROJECT_PATH'])
+        return process.env['SUITECLOUD_PROJECT_PATH'];
+    throw new Error('Cannot find FileCabinet. You must provide a `defaultProjectFolder` argument or be in an account');
+};
+/**
+ * @description - If the provided path does not contain the reference then this will scan the descendants for the first one
+ * @param path
+ * @returns {Promise<string>}
+ */
+const getFolderHoldingFileCabinetPlus = async (path) => {
+    if (/\bFileCabinet\b/.test(path))
+        return getFolderHoldingFileCabinet(path);
+    // go hunting for it.
+    const list = await fs.readdir(path, { recursive: true });
+    const candidate = list.find((c) => /\bFileCabinet\b/.test(c) && !exports.CONSTANTS.SDF_TEMP_ROOT_RGX.test(c));
+    return getFolderHoldingFileCabinet(nodePath.join(path, candidate));
+};
+exports.getFolderHoldingFileCabinetPlus = getFolderHoldingFileCabinetPlus;
+/**
+ *
+ * @param {string} anyCabinetPathInAccount
+ * @param {string} [projectRoot]
+ * @returns {string} * @returns {string} e.g. 24365476/src
+ */
+const getDifferenceFromProjectRootToFileCabinet = (anyCabinetPathInAccount, projectRoot) => {
+    const root = projectRoot || (0, exports.getRootOfProject)();
+    let tempFolder = anyCabinetPathInAccount.replace(root, '').replace(/^[\\\/]?/, '');
+    // get the filecabinet and subtract that
+    return tempFolder.replace(/(.*?).\bFileCabinet\b.*$/, '$1');
+};
+exports.getDifferenceFromProjectRootToFileCabinet = getDifferenceFromProjectRootToFileCabinet;
+/**
+ * @description - same as path.relative
+ * @param projectJsonLocation
+ * @param projectRoot
+ */
+const getRelativeOf = (projectJsonLocation, projectRoot) => {
+    return nodePath.relative(projectJsonLocation, projectRoot);
+};
+exports.getRelativeOf = getRelativeOf;
+/**
+ * @description - for common folders
+ * @param {string} type
+ * @param {string[]} extras
+ * @param {string} [target] - defaults to cwd
+ * @returns {string} - The full path
+ *
+ */
+const getAccountDir = async (type, extras, target) => {
+    let dirs = [];
+    switch (type) {
+        case 'FileCabinet':
+            dirs.push('FileCabinet');
+            break;
+        case 'Objects':
+            dirs.push('Objects');
+            break;
+        case 'Translations':
+            dirs.push('Translations');
+            break;
+        case 'AccountConfiguration':
+            dirs.push('AccountConfiguration');
+            break;
+        case 'SuiteScripts':
+            dirs.push('FileCabinet', 'SuiteScripts');
+            break;
+        case 'Templates':
+            dirs.push('FileCabinet', 'Templates');
+            break;
+        case 'Web Site Hosting Files':
+            dirs.push('FileCabinet', 'Web Site Hosting Files');
+        default:
+            break;
+    }
+    console.log({ target, dirs, type });
+    const fcPath = await (0, exports.getFolderHoldingFileCabinetPlus)(target || process.env['SUITECLOUD_PROJECT_PATH'] || process.cwd());
+    if (dirs.length > 0)
+        return nodePath.join(fcPath, ...dirs, ...extras.flatMap((x) => x.split(/\\\//)));
+    throw new Error('Unknown type');
+};
+exports.getAccountDir = getAccountDir;
+const removeTempDirForSdf = async (projectPath) => {
+    const newPath = nodePath.join(projectPath, '..', exports.CONSTANTS.SDF_TEMP_ROOT);
+    await fs.rm(newPath, { recursive: true, force: true }).catch((e) => {
+        console.error(e);
+    });
+    return newPath;
+};
+exports.removeTempDirForSdf = removeTempDirForSdf;
+/**
+ * @description
+ * @param {string[]} pathBits
+ */
+const removeFile = async (pathBits) => {
+    const newPath = nodePath.join(...pathBits);
+    await fs.rm(newPath, { force: true }).catch((e) => {
+        console.error(e);
+    });
+    return newPath;
+};
+exports.removeFile = removeFile;
+/**
+ * @description - makes a `temp` directory in the same account root
+ * - no need to copy anything over
+ * @param {string} projectPath
+ * @returns {Promise<string>}
+ */
+const makeTempDirForSdf = async (projectPath) => {
+    const newPath = nodePath.join(projectPath, '..', exports.CONSTANTS.SDF_TEMP_ROOT);
+    // clean up old files first
+    await (0, exports.removeTempDirForSdf)(projectPath);
+    await fs.mkdir(newPath, { recursive: true });
+    // make manifest file
+    await makeManifest(newPath, 'temp');
+    return newPath;
+};
+exports.makeTempDirForSdf = makeTempDirForSdf;
+/**
+ * @description - Figures out the path
+ * - if you have a relative path then compare it against cwd
+ * - if you have an absolute path then check if it is actually a NetSuite project path
+ * -
+ */
+const getAbsolutePath = (options) => {
+    if (!nodePath.isAbsolute(options.filePath))
+        return nodePath.resolve(nodePath.join(options.executionPath || process.cwd(), options.filePath));
+    if (/^[\\\/]\b(SuiteScripts|SuiteBundles|Suite\w+)\b/.test(options.filePath)) {
+        return nodePath.resolve(nodePath.join(options.projectPath, 'FileCabinet', options.filePath));
+    }
+    if (/^[\\\/]\b(Objects)\b/.test(options.filePath)) {
+        return nodePath.resolve(nodePath.join(options.projectPath, options.filePath));
+    }
+    // e.g. /Users/geraldgillespie/project/src/FileCabinet/SuiteScripts
+    return nodePath.resolve(options.filePath);
+};
+exports.getAbsolutePath = getAbsolutePath;
+/**
+ * @description -
+ */
+const getAccountFolders = async (path) => {
+    const tier1List = await fs.readdir(path, { withFileTypes: true });
+    return tier1List.flatMap((p) => {
+        if (!p.isDirectory())
+            return [];
+        return (0, validators_1.isValidAccountFolderName)(p.name) ? [p.name] : [];
+    });
+};
+exports.getAccountFolders = getAccountFolders;
+/**
+ * Recursively find directories whose names match a series of tests at each depth.
+ * @param {string} dir - The directory to start searching from.
+ * @param {*[]} tests - Current recursion depth (default is 0).
+ * @returns {Promise<string[]>} - An array of matching directory paths.
+ */
+const findMatchingDirectories = async (dir, tests) => {
+    // remove it and make the test list shorter
+    const [rgx, ...rest] = tests;
+    let matchingDirs = [];
+    // Stop recursion if we exceed the maximum depth
+    if (typeof rgx === 'undefined')
+        return matchingDirs;
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        console.error(`Error reading directory ${dir}:`, error);
+        return matchingDirs;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const fullPath = nodePath.join(dir, entry.name);
+            // If the directory name passes the test, add its full path to the results
+            if (rgx.test(entry.name)) {
+                matchingDirs.push(fullPath);
+                // Recursively search within the directory
+                const subDirs = await (0, exports.findMatchingDirectories)(fullPath, rest);
+                matchingDirs = matchingDirs.concat(subDirs);
+            }
+        }
+    }
+    return matchingDirs;
+};
+exports.findMatchingDirectories = findMatchingDirectories;
+/**
+ * @description - Get the remaining path
+ * @param {string[]} paths
+ * @param {'SuiteScripts'} type -
+ * @param {Array<function|string|RegExp>} [tests] - functions or globs or regex to apply. Only `some` has to pass.
+ * @returns {Promise<string[]>}
+ */
+const getAllFilesRecursively = async (paths, type, tests) => {
+    // console.log({paths, tests});
+    const unique = new Set();
+    const replacer = [new RegExp(`^.*(\\b${type}\\b.*)$`), '/$1'];
+    const testers = tests.flatMap((test) => {
+        if (typeof test === 'function')
+            return [test];
+        if (typeof test === 'string')
+            return [(x) => (0, minimatch_1.minimatch)(x, test)];
+        if (typeof test === 'object' && test instanceof RegExp)
+            return [(x) => test.test(x)];
+        return [];
+    });
+    await Promise.allSettled(paths.map(async (path) => {
+        const branch = await fs.readdir(path, { recursive: true, withFileTypes: true });
+        branch.forEach((p) => {
+            if (!p.isFile())
+                return;
+            if (!p.parentPath.includes(type))
+                return;
+            let modifiedP = nodePath.join(p.parentPath, p.name);
+            if (Array.isArray(replacer))
+                modifiedP = modifiedP.replace(...replacer);
+            if (testers.some((test) => test(modifiedP)))
+                unique.add(modifiedP);
+        });
+    }));
+    return [...unique];
+};
+exports.getAllFilesRecursively = getAllFilesRecursively;
+/**
+ * @description -- you should convert first
+ * @param paths
+ */
+const removeIllegalFileCabinetFiles = (paths) => {
+    return paths.filter((p) => {
+        if (/\.tsx?$/.test(p))
+            return false;
+        if (/\.csv$/.test(p))
+            return false;
+        if (/\.test\.js$/.test(p))
+            return false;
+        if (/\.map$/.test(p))
+            return false;
+        // anything in these subfolders
+        if (/__(tests?|mocks?)__/.test(p))
+            return false;
+        if (/\.attributes\b/.test(p))
+            return false;
+        if (/\.attr\.xml\b/.test(p))
+            return false;
+        if (/\.[mc]js$/.test(p))
+            return false;
+        // suitecloud
+        if (/\bsuitecloud\.config\b/.test(p))
+            return false;
+        if (/\bproject\b.*\bjson\b/.test(p))
+            return false;
+        // any deploy files
+        if (/\bdeploy\b.*\bxml\b/.test(p))
+            return false;
+        // jest config
+        if (/\bjest\b/.test(p))
+            return false;
+        // tscnofig
+        if (/\btsconfig\b/.test(p))
+            return false;
+        // hidden files e.g. .gitKeep
+        if (/[\\\/]\./.test(p))
+            return false;
+        if (/\beslint\b/.test(p))
+            return false;
+        return true;
+    });
+};
+exports.removeIllegalFileCabinetFiles = removeIllegalFileCabinetFiles;
+/**
+ * @description - A legal object file has only one extension '.xml'
+ * And the scriptid inside matches its file name. We cannot open files here
+ * @param paths
+ */
+const removeIllegalObjectFiles = (paths) => {
+    return paths.filter((p) => {
+        if (!/^(.*\/)?[a-z_\d\*]+\.xml$/.test(p))
+            return false;
+    });
+    // open the file
+};
+exports.removeIllegalObjectFiles = removeIllegalObjectFiles;
+/**
+ * @description - e.g. ts to js
+ * @param paths
+ */
+const convertFileExtensions = (paths) => {
+    return paths.map((p) => {
+        if (/\.ts$/.test(p))
+            return p.replace(/(\.d)?\.ts$/, '.js');
+        return p;
+    });
+};
+exports.convertFileExtensions = convertFileExtensions;
+//# sourceMappingURL=pathHelpers.js.map

package/lib/pause.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file sdf/lib/pause.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+declare const pause: () => never;
+export = pause;

package/lib/pause.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @file sdf/lib/pause.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const pause = () => {
+    throw new Error('this should be a pause detection');
+};
+module.exports = pause;
+//# sourceMappingURL=pause.js.map

package/lib/projectJsonHelpers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/projectJsonHelpers
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { ProjectJsonContents } from '../index';
+/**
+ *
+ * @param location
+ * @param altName
+ */
+export declare const readProjectJson: (location: string[], altName?: string) => Promise<any>;
+/**
+ * @description - re-usable ProjectJson updated
+ * @param {ProjectJsonContents} options
+ * @param {string[]} location
+ * @param {string} [altName] e.g. project.x.json
+ * @returns {ProjectJsonContents}
+ */
+export declare const updateProjectJson: <T extends ProjectJsonContents>(options: T, location: string[], altName?: "project.json" | string) => Promise<T>;
+export declare const readProjectJsonSync: (location: string[], altName?: string) => any;
+/**
+ * @description - re-usable ProjectJson updated
+ * @param {ProjectJsonContents} options
+ * @param {string[]} location
+ * @param {string} [altName] e.g. project.x.json
+ * @param {boolean} [keepExisting]
+ * @returns {ProjectJsonContents}
+ */
+export declare const updateProjectJsonSync: <T extends ProjectJsonContents>(options: T, location: string[], altName?: "project.json" | string, keepExisting?: boolean) => T;

package/lib/projectJsonHelpers.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/projectJsonHelpers
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProjectJsonSync = exports.readProjectJsonSync = exports.updateProjectJson = exports.readProjectJson = void 0;
+const fs = require("node:fs/promises");
+const fsSync = require("node:fs");
+const nodePath = require("node:path");
+const promptHelpers_1 = require("./promptHelpers");
+/**
+ *
+ * @param location
+ * @param altName
+ */
+const readProjectJson = async (location, altName) => {
+    if (location.length === 0)
+        location.push(process.cwd());
+    const filePath = nodePath.join(...location, altName || 'project.json');
+    const serializedContents = await fs.readFile(filePath, { encoding: 'utf8' }).catch(() => ('{}'));
+    return JSON.parse(serializedContents);
+};
+exports.readProjectJson = readProjectJson;
+/**
+ * @description - re-usable ProjectJson updated
+ * @param {ProjectJsonContents} options
+ * @param {string[]} location
+ * @param {string} [altName] e.g. project.x.json
+ * @returns {ProjectJsonContents}
+ */
+const updateProjectJson = async (options, location, altName) => {
+    if (location.length === 0)
+        location.push(process.cwd());
+    const filePath = nodePath.join(...location, altName || 'project.json');
+    const data = await (0, exports.readProjectJson)(location, altName || 'project.json');
+    if (Object.keys(options).length > 0) {
+        process.stdout.write((0, promptHelpers_1.goColor)('SUBTLE', '\nUpdating project json', JSON.stringify(data, null, 2)));
+        Object.entries(options).forEach(([key, value]) => {
+            data[key] = value;
+        });
+        await fs.writeFile(filePath, JSON.stringify(data, null, 2), { encoding: 'utf8' });
+    }
+    // if( !data.defaultAuthId )
+    return data;
+};
+exports.updateProjectJson = updateProjectJson;
+const readProjectJsonSync = (location, altName) => {
+    if (location.length === 0)
+        location.push(process.cwd());
+    const filePath = nodePath.join(...location, altName || 'project.json');
+    try {
+        const serializedContents = fsSync.readFileSync(filePath, { encoding: 'utf8' });
+        return JSON.parse(serializedContents);
+    }
+    catch (err) {
+        return {};
+    }
+};
+exports.readProjectJsonSync = readProjectJsonSync;
+/**
+ * @description - re-usable ProjectJson updated
+ * @param {ProjectJsonContents} options
+ * @param {string[]} location
+ * @param {string} [altName] e.g. project.x.json
+ * @param {boolean} [keepExisting]
+ * @returns {ProjectJsonContents}
+ */
+const updateProjectJsonSync = (options, location, altName, keepExisting) => {
+    if (location.length === 0)
+        location.push(process.cwd());
+    const filePath = nodePath.join(...location, altName || 'project.json');
+    let serializedContents = '{}';
+    try {
+        serializedContents = fsSync.readFileSync(filePath, { encoding: 'utf8' });
+    }
+    catch (e) {
+        serializedContents = '{}';
+    }
+    const data = JSON.parse(serializedContents);
+    if (Object.keys(options).length > 0) {
+        Object.entries(options).forEach(([key, value]) => {
+            if (keepExisting && Reflect.has(data, key))
+                return;
+            data[key] = value;
+        });
+        fsSync.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: 'utf8' });
+    }
+    return data;
+};
+exports.updateProjectJsonSync = updateProjectJsonSync;
+//# sourceMappingURL=projectJsonHelpers.js.map

package/lib/promptHelpers.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file sdf/lib/promptHelpers.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { COLORS } from '../types/colors';
+declare const Colors: {
+    readonly WARN: COLORS.ORANGE;
+    readonly BAD: COLORS.RED;
+    readonly INFO: COLORS.CYAN;
+    readonly HIGHLIGHT: COLORS.YELLOW;
+    readonly GOOD: COLORS.GREEN;
+    readonly NONE: COLORS.RESET_ALL;
+    readonly BOLD: COLORS.BOLD;
+    readonly SUBTLE: COLORS.BRIGHT_BLACK;
+};
+interface GoColor {
+    /**
+     * @des
+     * @param {colors: string|(keyof typeof Colors)| Array<string|keyof typeof Colors>} colors
+     * @param {string[]} messages
+     * @param {boolean} [skipReset=false]
+     * @returns {string}
+     */
+    (colors: string | (keyof typeof Colors) | Array<string | keyof typeof Colors>, messages: any[], skipReset?: boolean): string;
+    (colors: string | (keyof typeof Colors) | Array<string | keyof typeof Colors>, ...messages: Array<any | boolean>): string;
+}
+/**
+ * @description
+ * @param {Array<string|keyof typeof Colors>} colors
+ * @param {string[]} messages
+ * @param {boolean} skipReset
+ * @returns {string}
+ */
+export declare const goColor: GoColor;
+/**
+ * @description
+ * @param {string} previousMessage
+ * @param {string} toAppend
+ * @returns {string}
+ */
+export declare const appendToPrevious: (previousMessage: string, toAppend: string) => void;
+/**
+ * @description -
+ * @param line
+ * @returns {boolean}
+ */
+export declare const detectPrompt: (line: string) => boolean;
+/**
+ * @param {{message: string; timeout?: number;}} options
+ * @param {(string)=>any} [callback]
+ * @returns {Promise<string|null>}
+ */
+export declare const promptUser: ({ message, timeout }: {
+    message: string;
+    timeout?: number | null;
+}, callback?: (answer: any) => any) => Promise<any>;
+export declare const promptUserSync: ({ message, timeout }: {
+    message: string;
+    timeout?: number | null;
+}, callback?: (answer: any) => any) => void;
+/**
+ * @description - pass in a array of strings to be presented with a numbered choice list
+ * 0 is always "QUIT" (even if not presented) and the program will exit with code 0 (coincidence on the number)
+ * "-1" is always the default -- this helps with automation
+ *
+ * @param {{choices: string[]}} options
+ * @returns {Promise<string>}
+ */
+export declare const promptChoices: <C>(options: {
+    choices: Record<string, C> | C[];
+    displayChoices: string[] | Record<string, string>;
+    default: C | null;
+    premessage?: string;
+    question: string;
+    childDefault?: C;
+}) => Promise<C & string>;
+export {};