creatium 0.1.17 → 0.2.2

package/dist/index.d.ts

@@ -0,0 +1,881 @@
+import { Prettify, color, prompt, line, ObjectValues, Response, ContentInput, ObjectToArray, copyDir, replacePlaceholders, getPaths } from './utils.js';
+import { ClippiumData } from 'clippium';
+import '@visulima/boxen';
+import 'cli-table3';
+import 'columnify';
+import '@clack/prompts';
+import 'fs';
+import 'node:fs/promises';
+import 'tiny-glob';
+import 'node:os';
+import 'node:process';
+import 'deepmerge-ts';
+import 'node:url';
+
+type Option = NonNullable<ClippiumData['flags']>[number];
+type OptionsUtils = {
+    color: typeof color;
+    prompt: typeof prompt;
+    line: typeof line;
+};
+type OptionSuper = {
+    /** Key of the option */
+    /** Description of the option */
+    desc: string;
+};
+type OptionCommon = OptionSuper & {
+    /**
+     * If is not set. Desc value will be used
+     */
+    promptMsg?: string;
+    /** Alias of the option */
+    alias?: string[];
+};
+type OptionCommonWithPlaceholder<V> = Prettify<OptionCommon & {
+    /**
+     * Value that will be used as placeholder in prompt.
+     */
+    placeholderValue?: V;
+}>;
+type CliOption = Option;
+/**
+ * Core interface
+ *
+ * @template V
+ */
+type CoreInterface<V = string> = {
+    /**
+     * Validate value.
+     *
+     * Used to validate initial value in prompt method
+     */
+    validateInitialValue: (data: {
+        /** Show success message */
+        showSuccess?: boolean;
+        /** Show error message */
+        showError?: boolean;
+    }) => Promise<V | undefined>;
+    /**
+     * Method to set the cli option
+     *
+     * @returns {Promise<CliOption | undefined>}
+     */
+    cmd: () => Promise<CliOption | undefined>;
+    /**
+     * Method to set the prompt for the option
+     *
+     * @returns {Promise<V>}
+     */
+    prompt: () => Promise<V>;
+};
+declare class Core<Config extends OptionSuper = OptionCommon, V = string> {
+    config: Prettify<Config>;
+    _utils: OptionsUtils;
+    /** On cancel callback */
+    _onCancel: () => Promise<void>;
+    /** After the prompt is set */
+    afterPrompt: (<V>(value: V) => Promise<V>) | undefined;
+    /** Enable debug MODE */
+    debugMode: boolean;
+    /**
+     * Set initial value.
+     * For example if you want to prioritize a cli flag.
+     *
+     * @default undefined
+     */
+    initialValue: V | undefined;
+    protected _type: {
+        readonly string: "string";
+        readonly number: "number";
+        readonly boolean: "boolean";
+        readonly array: "array";
+        readonly choices: "choices";
+    };
+    constructor(config: Prettify<Config>, _utils: OptionsUtils);
+    protected _text: {
+        initialValueSuccess: (t: string, v: string) => string;
+        initialValueError: (v?: string) => string;
+    };
+    getPromptHooked(): Promise<any>;
+}
+
+type Value$5 = string | number;
+type OptionSelect<V extends Value$5 = Value$5> = OptionCommonWithPlaceholder<V> & {
+    /** Set the options of select */
+    options: {
+        [key in V]: {
+            /** Visible name of the option */
+            name: string;
+            /** Description of the option. Used in cli prompt */
+            desc?: string;
+        };
+    };
+};
+declare class Select<V extends Value$5 = Value$5> extends Core<OptionSelect<V>, V> implements CoreInterface<Value$5> {
+    cmd(): Promise<CliOption>;
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<V | undefined>;
+    prompt(): Promise<string>;
+}
+
+declare const SELECT_BASE_OPTS: {
+    readonly NONE: "none";
+};
+type OptionNone = typeof SELECT_BASE_OPTS['NONE'];
+type OptionsValue = {
+    /** Visible name of the option */
+    name?: string;
+    /** Description of the option. Used in cli prompt */
+    desc?: string;
+};
+type SelectBaseOptions<Value extends string = string> = Partial<Omit<OptionSelect<Value>, 'options'>> & {
+    /**
+     * Select only specific options by key.
+     *
+     * Minimum 2 option.
+     *
+     * @example ['yarn', 'pnpm']
+     */
+    onlyOptions?: [Exclude<Value, OptionNone>, Exclude<Value, OptionNone>, ...Exclude<Value, OptionNone>[]];
+    /** Change the options values by key */
+    options?: {
+        [key in Value]?: OptionsValue;
+    };
+};
+
+/** Text editor values used in `openEditor` option. */
+declare const TEXT_EDITOR: {
+    readonly VSCODE: "code";
+    readonly SUBLIME: "subl";
+    readonly WEBSTORM: "webstorm";
+    readonly NONE: "none";
+};
+type TextEditor = ObjectValues<typeof TEXT_EDITOR>;
+type OptionEditor = SelectBaseOptions<TextEditor>;
+declare class Editor extends Select<TextEditor> {
+    _utils: OptionsUtils;
+    constructor(config: OptionEditor, _utils: OptionsUtils);
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<TextEditor | undefined>;
+    prompt(): Promise<TextEditor>;
+}
+
+/** installer values used in `install` option. */
+declare const INSTALLER: {
+    readonly NONE: "none";
+    readonly DENO: "deno";
+    readonly BUN: "bun";
+    readonly NPM: "npm";
+    readonly PNPM: "pnpm";
+    readonly YARN: "yarn";
+};
+type Installer = ObjectValues<typeof INSTALLER>;
+type OptionInstall = SelectBaseOptions<Installer>;
+declare class Install extends Select<Installer> {
+    _utils: OptionsUtils;
+    constructor(config: OptionInstall, _utils: OptionsUtils);
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<Installer | undefined>;
+    prompt(): Promise<Installer>;
+}
+
+/** Object of the CREATIUM types */
+declare const OPTION: {
+    readonly array: "array";
+    readonly select: "select";
+    readonly multiselect: "multiselect";
+    readonly boolean: "boolean";
+    readonly number: "number";
+    readonly text: "text";
+    readonly void: "void";
+    readonly output: "output";
+    readonly name: "name";
+    readonly template: "template";
+    readonly install: "install";
+    readonly openEditor: "openEditor";
+    readonly path: "path";
+};
+
+type Value$4 = string[];
+type OptionArray = OptionCommonWithPlaceholder<Value$4> & {
+    /**
+     * Separator for value strings.
+     *
+     * @default ','
+     */
+    separator?: string;
+};
+declare class Array extends Core<OptionArray, Value$4> implements CoreInterface<Value$4> {
+    #private;
+    cmd(): Promise<CliOption>;
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<string[] | undefined>;
+    prompt(): Promise<string[]>;
+}
+
+type Value$3 = boolean;
+type OptionBoolean = OptionCommonWithPlaceholder<Value$3>;
+declare class Boolean extends Core<OptionBoolean, Value$3> implements CoreInterface<Value$3> {
+    cmd(): Promise<CliOption>;
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<boolean | undefined>;
+    prompt(): Promise<boolean>;
+}
+
+type Value$2 = string;
+type OptionMultiselect<V extends Value$2 = Value$2> = OptionCommonWithPlaceholder<V[]> & {
+    /** Set the options of multiselect */
+    options: {
+        [key in V]: {
+            /** Visible name of the option */
+            name: string;
+            /** Description of the option. Used in cli prompt */
+            desc?: string;
+        };
+    };
+};
+declare class Multiselect<V extends Value$2 = Value$2> extends Core<OptionMultiselect<V>, V[]> implements CoreInterface<V[]> {
+    cmd(): Promise<CliOption>;
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<V[] | undefined>;
+    prompt(): Promise<string[]>;
+}
+
+type Value$1 = number;
+type OptionNumber = OptionCommonWithPlaceholder<Value$1>;
+declare class Number extends Core<OptionNumber, Value$1> implements CoreInterface<Value$1> {
+    cmd(): Promise<CliOption>;
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<number | undefined>;
+    prompt(): Promise<number>;
+}
+
+type Value = string;
+type OptionText = OptionCommonWithPlaceholder<Value>;
+declare class Text extends Core<OptionText, Value> implements CoreInterface<Value> {
+    cmd(): Promise<CliOption>;
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<string | undefined>;
+    prompt(): Promise<string>;
+}
+
+type OptionVoid = OptionSuper & {
+    fn: () => Response<void>;
+};
+declare class Void extends Core<OptionVoid, void> implements CoreInterface<void> {
+    cmd(): Promise<undefined>;
+    validateInitialValue(): Promise<undefined>;
+    prompt(): Promise<void>;
+}
+
+type OptionName = Partial<Name['config']>;
+declare class Name extends Text {
+    _utils: OptionsUtils;
+    constructor(config: OptionName, _utils: OptionsUtils);
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<string | undefined>;
+    prompt(): Promise<string>;
+}
+
+declare const PATH_TYPE: {
+    folder: string;
+    file: string;
+};
+type PathType = typeof PATH_TYPE[keyof typeof PATH_TYPE];
+type OptionPath = Partial<Path['config']> & {
+    /**
+     * Set path type
+     *
+     * @default 'file'
+     */
+    pathType?: PathType;
+    /**
+     * Set if you want to check if path exists or not.
+     *
+     * @default false
+     */
+    exists?: boolean;
+};
+declare class Path extends Text {
+    #private;
+    _utils: OptionsUtils;
+    constructor(config: OptionPath, _utils: OptionsUtils);
+    validateInitialValue(data?: {
+        showSuccess?: boolean;
+        showError?: boolean;
+    }): Promise<string | undefined>;
+    prompt(): Promise<string>;
+}
+
+type OptionOutput = Partial<Omit<Path['config'], 'pathType' | 'exists'>>;
+declare class Output extends Path {
+    _utils: OptionsUtils;
+    constructor(config: OptionOutput, _utils: OptionsUtils);
+}
+
+type OptionTemplate = Partial<Omit<Select['config'], 'options'>> & {
+    options: {
+        [key: string]: {
+            /**
+             * Input for download
+             * Could be an directory or an array of files
+             */
+            input: string | ContentInput[];
+            /**
+             * Name of the template.
+             * If not set, the name of the template will be the key of the template
+             */
+            name?: string;
+            /**
+             * Description of the template.
+             */
+            desc?: string;
+        };
+    };
+};
+declare class Template extends Select<keyof OptionTemplate['options']> {
+    _utils: OptionsUtils;
+    constructor(config: OptionTemplate, _utils: OptionsUtils);
+}
+
+type Options = {
+    /**Array of values*/
+    [OPTION.array]: OptionArray;
+    /**Single selection option*/
+    [OPTION.select]: OptionSelect;
+    /**Multiple selection option*/
+    [OPTION.multiselect]: OptionMultiselect;
+    /**Boolean option (true/false)*/
+    [OPTION.boolean]: OptionBoolean;
+    /**Numeric input*/
+    [OPTION.number]: OptionNumber;
+    /**Text input*/
+    [OPTION.text]: OptionText;
+    /**Void option (no value)*/
+    [OPTION.void]: OptionVoid;
+    /** Options for path*/
+    [OPTION.path]: OptionPath;
+    /**Input for download*/
+    [OPTION.output]: OptionOutput;
+    /**Name of the project
+     * @default filename(output)*/
+    [OPTION.name]: OptionName;
+    /**Templates*/
+    [OPTION.template]: OptionTemplate;
+    /**Package manager to install dependencies*/
+    [OPTION.install]: OptionInstall;
+    /** Open project in a text editor if exist */
+    [OPTION.openEditor]: OptionEditor;
+};
+type OptionsClasses = {
+    /** Class for handling array options */
+    [OPTION.array]: typeof Array;
+    /** Class for handling select options */
+    [OPTION.select]: typeof Select;
+    /** Class for handling multiselect options */
+    [OPTION.multiselect]: typeof Multiselect;
+    /** Class for handling boolean options */
+    [OPTION.boolean]: typeof Boolean;
+    /** Class for handling number options */
+    [OPTION.number]: typeof Number;
+    /** Class for handling text options */
+    [OPTION.text]: typeof Text;
+    /** Class for handling void options */
+    [OPTION.void]: typeof Void;
+    /** Options for path*/
+    [OPTION.path]: typeof Path;
+    /** Class for handling output options */
+    [OPTION.output]: typeof Output;
+    /** Class for handling name options */
+    [OPTION.name]: typeof Name;
+    /** Class for handling template options */
+    [OPTION.template]: typeof Template;
+    /** Class for handling install options */
+    [OPTION.install]: typeof Install;
+    /** Class for handling openEditor options */
+    [OPTION.openEditor]: typeof Editor;
+};
+type OptionsParams = Prettify<Record<string, ObjectToArray<Options>[number]>>;
+type GetPromptValue<K extends keyof OptionsClasses> = Prettify<'prompt' extends keyof OptionsClasses[K]['prototype'] ? Awaited<ReturnType<OptionsClasses[K]['prototype']['prompt']>> : never>;
+
+type HookParams = {
+    /** Values passed to the prompt */
+    values?: {
+        [x: string]: unknown;
+    };
+};
+type CreateTemplateOpts = {
+    /** Set the input path or the template key */
+    input?: string;
+    /** Set the output path */
+    output?: string;
+    /** Set the name of the template */
+    name?: string;
+    /** Set the installer */
+    install?: Installer;
+    /**
+     * Open editor
+     */
+    openEditor?: TextEditor;
+    /**
+     * Add consts to use in your templates.
+     *
+     */
+    consts?: Record<string, string>;
+};
+type ValuesSimple = Prettify<Omit<CreateTemplateOpts, 'consts' | 'input' | 'output'> & Required<Pick<CreateTemplateOpts, 'output' | 'input'>>>;
+type Config = {
+    /**
+     * Set name of you project
+     */
+    name: string;
+    /**
+     * Set version of you current project
+     * Used in for the updater notifications.
+     */
+    version: string;
+    /**
+     * Use cache
+     *
+     * @default true
+     */
+    cache?: boolean;
+    /**
+     * Use updater
+     *
+     * @default false
+     */
+    updater?: boolean;
+    /** Set custom function foor when user cancels the process */
+    onCancel?: ((data: HookParams) => Response<void>) | false;
+    /** Set custom intro */
+    intro?: ((data: HookParams) => Response<void>) | false;
+    /** Set custom outro */
+    outro?: ((data: HookParams) => Response<void>) | false;
+    /**
+     * Set you prompts config
+     */
+    prompt: OptionsParams;
+    /**
+     * hooks for
+     */
+    hooks?: {
+        beforePrompt?: <D extends HookParams>(data: D) => Response<D | undefined>;
+        afterPrompt?: <D extends HookParams>(data: D) => Response<D | undefined>;
+    };
+};
+type ConfigSimple = Prettify<Omit<Config, 'prompt' | 'hooks'> & {
+    /** Set your prompt options */
+    opts?: {
+        /** Active/deactivate the name prompt */
+        [OPTION.name]?: boolean;
+        /**
+         * Active/deactivate the install prompt
+         * Also, You can set the installators that you want to use.
+         */
+        [OPTION.install]?: false | Options['install']['onlyOptions'];
+        /**
+         * Active/deactivate the openEditor prompt.
+         * Also, You can set the editors that you want to use.
+         */
+        [OPTION.openEditor]?: false | Options['openEditor']['onlyOptions'];
+    };
+    /** Set your template ooptions */
+    templates: Options['template']['options'];
+    /**
+     * Add consts to use in your templates.
+     */
+    consts?: CreateTemplateOpts['consts'];
+}>;
+type CliOpts = {
+    /**
+     * Arguments to pass to the command
+     *
+     * @default process.argv.slice(2)
+     */
+    args?: string[];
+    /**
+     * Hide the first two arguments
+     *
+     * @default false
+     */
+    hideBin?: boolean;
+};
+type CreateOpts = CliOpts & {
+    /**
+     * Options for activate cli.
+     *
+     * @default true
+     */
+    activeCli?: boolean;
+};
+
+type GetPromptValues<C extends Config> = Prettify<{
+    [K in keyof C['prompt']]?: Prettify<(C['prompt'][K] extends {
+        type: infer T;
+    } ? T extends keyof OptionsClasses ? GetPromptValue<T> : never : never)>;
+}>;
+
+/**
+ * Customizable class of `Creatium` for create project templates (CLI and Library).
+ *
+ * @template C
+ * @example
+ * //////////////// core.js ///////////////////
+ *
+ * export const core = new CreatiumCore({
+ *   name: 'My Project',
+ *   version: '1.0.0',
+ *   prompts: {
+ *     ...
+ *   },
+ *   ...
+ * })
+ *
+ * //////////////// bin.js ///////////////////
+ *
+ * import { core } from './core.js'
+ * const res = await core.cli()
+ * // do something with res...
+ * await core.createTemplate( res )
+ *
+ * //////////////// lib.js ///////////////////
+ *
+ * import { core } from './core.js'
+ * export const create = async (args) => {
+ *   const res = await core.build( args )
+ *   // do something with res...
+ *   await core.createTemplate( res )
+ * }
+ */
+declare class CreatiumCore<C extends Config = Config> {
+    #private;
+    utils: OptionsUtils;
+    config: C;
+    constructor(config: C);
+    /** Force debug mode */
+    set debugMode(value: boolean);
+    /**
+     * Shows a notification if the current package is outdated.
+     *
+     * **information**: If this 'custom' function is provided, the default
+     * notification will not be shown.
+     *
+     * @returns {Promise<boolean>} - A promise that resolves when the notification has finished.
+     */
+    updateNotify(): Promise<boolean>;
+    /**
+     * Cancels the current process and exits with code 0.
+     *
+     * If a `message` is provided, it will be displayed in the console.
+     * If `onCancel` is set in the config, it will be called with the current data.
+     * If `onCancel` is not set, a default message will be displayed.
+     *
+     * @param {string} [message] - The message to display before exiting.
+     */
+    cancel(message?: string): Promise<void>;
+    /**
+     * Intro prompt line.
+     *
+     * If the parameter `message` is provided, it will be used as the intro message.
+     * If the `intro` option is a function, it will be called with the `this.#data` as the argument.
+     * If the `intro` option is undefined, the default intro message will be used.
+     *
+     * @param {string} [message] - The intro message.
+     */
+    intro(message?: string): Promise<void>;
+    /**
+     * Outro prompt line.
+     *
+     * If the parameter `message` is provided, it will be used as the outro message.
+     * If the `outro` option is a function, it will be called with the `this.#data` as the argument.
+     * If the `outro` option is undefined, the default outro message will be used.
+     *
+     * @param {string} [message] - The outro message.
+     */
+    outro(message?: string): Promise<void>;
+    /**
+     * Copy a directory from input path to output path.
+     *
+     * @param   {object}        data - Options object with input and output paths.
+     * @returns {Promise<void>}      - Resolves when the directory has been copied.
+     * @example
+     *
+     * const copyResult = await core.copyDir({
+     *   input : '/path/to/sourceDir',
+     *   output: '/path/to/destinationDir',
+     * })
+     * const copyResult = await copyDir({
+     * input : [
+     *   {
+     *     name: 'file1.txt',
+     *     content: 'Hello, world!',
+     *   },
+     *   {
+     *     name: 'file2.txt',
+     *     content: 'Goodbye, world!',
+     *   },
+     * ],
+     * output: '/path/to/destinationDir',
+     * })
+     */
+    copyDir(data: Parameters<typeof copyDir>[0]): Promise<void>;
+    /**
+     * Installs the project with the given package manager.
+     *
+     * @param   {object}        [options]           - The options to install.
+     * @param   {Installer}     [options.installer] - The package manager to use for the installation.
+     * @param   {string}        [options.input]     - The path to the folder. If not provided, the current directory is used.
+     * @returns {Promise<void>}
+     * @example
+     * await core.install( {
+     *   installer : 'pnpm',
+     *   input     : 'my/project/path',
+     * } )
+     */
+    install({ installer, input, }?: {
+        installer?: Installer;
+        input?: string;
+    }): Promise<void>;
+    /**
+     * Open the project in the given editor.
+     *
+     * @param   {object}        params        - The parameters for opening the editor.
+     * @param   {TextEditor}    params.editor - The editor to open the project in.
+     * @param   {string}        params.input  - The input path. If not provided, the current directory is used.
+     * @returns {Promise<void>}
+     * @example
+     * await core.openEditor( {
+     *   editor : 'vscode',
+     *   input  : 'my/project/path',
+     *  })
+     */
+    openEditor({ editor, input, }?: {
+        editor?: TextEditor;
+        input?: string;
+    }): Promise<void>;
+    /**
+     * Replaces placeholders in files within the specified directory.
+     *
+     * This function searches for files in the provided input directory and replaces
+     * placeholders within those files using the specified parameters. The placeholders
+     * in the content are replaced with values from the `params` object.
+     *
+     * @param   {object}        args          - The arguments object.
+     * @param   {string}        [args.input]  - The directory path containing files with placeholders.
+     * @param   {object}        [args.params] - An object containing key-value pairs for replacing placeholders.
+     * @returns {Promise<void>}               A Promise that resolves once all placeholders have been replaced.
+     * @example
+     * await core.replacePlaceholders( {
+     *   input  : 'my/project/path',
+     *   params : { consts: { version: '1.0.0' }, prompt: { name: 'My Project' } },
+     * })
+     */
+    replacePlaceholders({ input, params, inputOpts, }?: {
+        input?: string;
+        params?: Parameters<typeof replacePlaceholders>[0]['params'];
+        inputOpts?: Parameters<typeof getPaths>[1];
+    }): Promise<void>;
+    /**
+     * Return the input path of a template by name or path.
+     *
+     * @param   {string}                      [input] - The name of the template or the path to the template.
+     * @returns {Promise<string | undefined>}         The input path of the template or undefined if not found.
+     * @example
+     * // with template path
+     * const input = await core.getTemplateInput( { input : 'my/template/path' } )
+     * @example
+     * // With template key
+     * // template key must be specified in the config prompt secction.
+     * const input = await core.getTemplateInput( { input : 'templateKey' )
+     */
+    getTemplateInput({ input }?: {
+        input?: string;
+    }): Promise<string | undefined>;
+    /**
+     * Create a new project template.
+     *
+     * @param   {CreateTemplateOpts} values - The values to create the template.
+     * @returns {Promise<void>}             - A promise that resolves when the template is created.
+     * @example
+     * // basic usage
+     * await core.createTemplate( { input : 'my/template/path', output : 'my/project/path' } )
+     * @example
+     * // custom usage
+     * await core.createTemplate( {
+     *   input : 'my/template/path',
+     *   output : 'my/project/path',
+     *   install : 'pnpm',
+     *   open : 'vscode',
+     *   consts : {
+     *     version : '1.0.0',
+     *     header : '// Template generated by Creatium. a project from PigeonPosse',
+     *   },
+     * } )
+     */
+    createTemplate(values: CreateTemplateOpts): Promise<void>;
+    /**
+     * Initialize the CLI and executes the callback function passed in the config.
+     *
+     * @param   {GetPromptValues<C>} [values] - The values to override the CLI prompts. If not set, the CLI prompts will be executed.
+     * @param   {CreateOpts}         [opts]   - The options to pass to the CLI.
+     * @returns                               The result of the callback function.
+     */
+    build(values?: Prettify<GetPromptValues<C>>, opts?: CreateOpts): Promise<{ [K_1 in keyof C["prompt"]]?: ((C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_7 ? { [K_3 in keyof T_7]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never) extends infer T_5 ? { [K_2 in keyof T_5]: (C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_6 ? { [K_3 in keyof T_6]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never)[K_2]; } : never) | undefined; } extends infer T ? { [K in keyof T]: { [K_1 in keyof C["prompt"]]?: ((C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_4 ? { [K_3 in keyof T_4]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never) extends infer T_1 ? { [K_2 in keyof T_1]: (C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_3 ? { [K_3 in keyof T_3]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never)[K_2]; } : never) | undefined; }[K]; } : never>;
+    /**
+     * Initializes and executes the command-line interface (CLI) process.
+     *
+     * @param   {CliOpts} [props] - Optional CLI options to configure the initialization process.
+     * @returns                   A promise resolving to the prompt values obtained after executing the CLI.
+     * @example
+     * // simple usage
+     * await core.cli()
+     * @example
+     * // custom usage
+     * await core.cli( { args : process.argv.slice( 4), hideBin : false } )
+     */
+    cli(props?: CliOpts): Promise<{ [K_1 in keyof C["prompt"]]?: ((C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_7 ? { [K_3 in keyof T_7]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never) extends infer T_5 ? { [K_2 in keyof T_5]: (C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_6 ? { [K_3 in keyof T_6]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never)[K_2]; } : never) | undefined; } extends infer T ? { [K in keyof T]: { [K_1 in keyof C["prompt"]]?: ((C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_4 ? { [K_3 in keyof T_4]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never) extends infer T_1 ? { [K_2 in keyof T_1]: (C["prompt"][K_1] extends {
+        type: infer T_2;
+    } ? T_2 extends keyof OptionsClasses ? ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never) extends infer T_3 ? { [K_3 in keyof T_3]: ("prompt" extends keyof OptionsClasses[T_2]["prototype"] ? Awaited<ReturnType<OptionsClasses[T_2]["prototype"]["prompt"]>> : never)[K_3]; } : never : never : never)[K_2]; } : never) | undefined; }[K]; } : never>;
+}
+
+/**
+ * Class of `Creatium` for create project templates (CLI and Library).
+ *
+ * @example
+ * //////////////// core.js ///////////////////
+ *
+ * import { Creatium } from 'creatium'
+ * export const core = new Creatium({
+ *   name: 'My Project',
+ *   version: '1.0.0',
+ *   templates: {
+ *     ...
+ *   },
+ * })
+ *
+ * //////////////// bin.js ///////////////////
+ *
+ * import { core } from './core.js'
+ * core.cli()
+ *
+ * //////////////// lib.js ///////////////////
+ *
+ * import { core } from './core.js'
+ * export const create = core.build
+ */
+declare class Creatium {
+    #private;
+    protected options: ConfigSimple;
+    protected config: {
+        prompt: {
+            openEditor?: {
+                type: "openEditor";
+                onlyOptions: ["code" | "subl" | "webstorm", "code" | "subl" | "webstorm", ...("code" | "subl" | "webstorm")[]] | undefined;
+            } | undefined;
+            install?: {
+                type: "install";
+                onlyOptions: ["deno" | "bun" | "npm" | "pnpm" | "yarn", "deno" | "bun" | "npm" | "pnpm" | "yarn", ...("deno" | "bun" | "npm" | "pnpm" | "yarn")[]] | undefined;
+            } | undefined;
+            input: {
+                type: "template";
+                options: {
+                    [key: string]: {
+                        input: string | ContentInput[];
+                        name?: string;
+                        desc?: string;
+                    };
+                };
+            };
+            name?: {
+                type: "name";
+            } | undefined;
+            output: {
+                type: "output";
+            };
+        };
+        name: string;
+        version: string;
+        cache?: boolean | undefined;
+        updater?: boolean | undefined;
+        onCancel?: ((data: HookParams) => Response<void>) | false | undefined;
+        intro?: ((data: HookParams) => Response<void>) | false | undefined;
+        outro?: ((data: HookParams) => Response<void>) | false | undefined;
+    };
+    constructor(options: ConfigSimple);
+    /**
+     * A simplified version of the `build` method from the main class.
+     *
+     * @param   {ValuesSimple}          [values] - The values to override the CLI prompts. If not set, the CLI prompts will be executed.
+     * @param   {CreateOpts}            [opts]   - The options to pass to the CLI.
+     * @returns {Promise<ValuesSimple>}          A promise resolving to the prompt values obtained after executing the CLI.
+     * @example
+     * // simple usage
+     * await core.build()
+     * @example
+     * // custom usage
+     * await core.build( { args : process.argv.slice(4), hideBin : false } )
+     */
+    build(values?: ValuesSimple, opts?: CreateOpts): Promise<{
+        openEditor?: undefined;
+        install?: undefined;
+        input?: string | undefined;
+        name?: undefined;
+        output?: string | undefined;
+    }>;
+    /**
+     * A simplified version of the `cli` method from the main class.
+     * Initializes and executes the command-line interface (CLI) process.
+     *
+     * @param   {CliOpts}               [props] - Optional CLI options to configure the initialization process.
+     * @returns {Promise<ValuesSimple>}         A promise resolving to the prompt values obtained after executing the CLI.
+     * @example
+     * // simple usage
+     * await core.cli()
+     * @example
+     * // custom usage
+     * await core.cli( { args : process.argv.slice(4), hideBin : false } )
+     */
+    cli(props?: CliOpts): Promise<{
+        openEditor?: undefined;
+        install?: undefined;
+        input?: string | undefined;
+        name?: undefined;
+        output?: string | undefined;
+    }>;
+}
+
+export { Creatium, CreatiumCore, INSTALLER, OPTION, TEXT_EDITOR };
+export type { CliOpts, Config, CreateOpts, CreateTemplateOpts };