yeoman-generator

type ArgumentSpec = {
    name: string;

    /** Description for the argument. */
    description?: string;

    /** A value indicating whether the argument is required. */
    required?: boolean;

    /** A value indicating whether the argument is optional. */
    optional?: boolean;

    /** The type of the argument. */
    type: typeof String | typeof Number | typeof Array | typeof Object;

    /** The default value of the argument. */
    default?: any;
};

type BaseFeatures = FeaturesApi & {
    /** The Generator instance unique identifier. The Environment will ignore duplicated identifiers. */
    uniqueBy?: string;

    /** UniqueBy calculation method */
    unique?: true | 'argument' | 'namespace';

    /** Only queue methods that matches a priority. */
    tasksMatchingPriority?: boolean;

    /** Tasks methods starts with prefix. Allows api methods (non tasks) without prefix. */
    taskPrefix?: string;

    /** Provides a custom install task. Environment built-in task will not be executed */
    customInstallTask?: boolean | ((...args: any[]) => void | Promise<void>);

    /** Provides a custom commit task. */
    customCommitTask?: boolean | ((...args: any[]) => void | Promise<void>);

    /** Disable args/options parsing. Whenever options/arguments are provided parsed like using commander based parsing. */
    skipParseOptions?: boolean;

    /** Disable args/options support. Whenever options/arguments are provided parsed like using commander based parsing. */
    disableInGeneratorOptionsSupport?: boolean;

    /** Custom priorities for more fine tuned workflows. */
    customPriorities?: Priority[];

    /** Inherit tasks from parent prototypes, implies tasksMatchingPriority */
    inheritTasks?: boolean;

    /** Transform the configuration before reading. */
    configTransform?: StorageTransform<Record<string, any>>;
};

type BaseOptions = OptionsApi & {
    destinationRoot?: string;

    skipInstall?: boolean;

    skipCheckEnv?: boolean;

    ignoreVersionCheck?: boolean;

    askAnswered?: boolean;

    localConfigOnly?: boolean;

    skipCache?: boolean;

    skipLocalCache?: boolean;

    description?: string;
};

type CliOptionSpec = {
    name: string;

    /** The type of the option. */
    type: typeof Boolean | typeof String | typeof Number | ((opt: string) => any);

    required?: boolean;

    /** The option name alias (example `-h` and --help`). */
    alias?: string;

    /** The default value. */
    default?: any;

    /** The description for the option. */
    description?: string;

    /** A value indicating whether the option should be hidden from the help output. */
    hide?: boolean;

    /** The storage to persist the option */
    storage?: string | Storage<any>;
};

type ComposeOptions<G extends BaseGenerator = BaseGenerator> =
    EnvironmentComposeOptions<G> & {
        skipEnvRegister?: boolean;
        forceResolve?: boolean;
        forwardOptions?: boolean;
    };

type GeneratorPipelineOptions = PipelineOptions<MemFsEditorFile> &
    ProgressOptions & { pendingFiles?: boolean };

type Priority = QueueOptions & {
    /** Name of the priority. */
    priorityName: string;
    /** The queue which this priority should be added before. */
    before?: string;
};

type PromptQuestion<T extends PromptAnswers = PromptAnswers> =
    PromptQuestionApi<T> & {
        name: string;

        /**
         * The storage to store the answer.
         */
        storage?: Storage<any>;

        /**
         * A value indicating whether to store the user's previous answer for others projects.
         */
        store?: boolean;
    };

type PromptQuestions<A extends PromptAnswers = PromptAnswers> =
    | PromptQuestion<A>
    | Array<PromptQuestion<A>>;

type QuestionRegistrationOptions<T extends PromptAnswers = PromptAnswers> =
    PromptQuestion<T> & {
        /**
         * A value indicating whether an option should be exported for this question.
         */
        exportOption?: boolean | Record<string, unknown>;
    };

type QueueOptions = {
    /** Name of the queue. */
    queueName?: string;

    /** Execute only once by namespace and taskName. */
    once?: boolean;

    /** Run the queue if not running yet. */
    run?: boolean;

    /** Edit a priority */
    edit?: boolean;

    /** Queued manually only */
    skip?: boolean;

    /** Arguments to pass to tasks */
    args?: any[] | ((generator: Generator) => any[]);
};

type StorageOptions = {
    name?: string;
    /**
     * Set true to treat name as a lodash path.
     */
    lodashPath?: boolean;
    /**
     * Set true to disable json object cache.
     */
    disableCache?: boolean;
    /**
     * Set true to cleanup cache for every fs change.
     */
    disableCacheByFile?: boolean;
    /**
     * Set true to write sorted json.
     */
    sorted?: boolean;
    /**
     * Transform the content of the storage when reading it. This can be used to sanitize or modify the data before it is returned.
     */
    transform?: StorageTransform<Record<string, any>>;
};

type StorageTransform<A extends Record<string, any>> = (
    content: A,
    name?: string
) => A;

type StorageValue = JsonValue;

type Task<TaskContext = any> = TaskOptions & {
    /** Function to be queued. */

    method: (this: TaskContext, ...args: any[]) => unknown | Promise<unknown>;

    /** Name of the task. */
    taskName: string;
};

type TaskOptions = QueueOptions & {
    /** Reject callback. */
    reject?: (error: unknown) => void;

    taskPrefix?: string;

    auto?: boolean;

    taskOrigin?: any;

    cancellable?: boolean;
};