@cenk1cenk2/oclif-common 6.3.28 → 6.3.30

package/dist/index.d.ts

@@ -1,413 +1,450 @@
-import { InjectionToken, DynamicModule, INestApplicationContext } from '@nestjs/common';
-export { DynamicModule, Inject } from '@nestjs/common';
-import * as _oclif_core_lib_interfaces from '@oclif/core/lib/interfaces';
-export { Flag, InferredFlags } from '@oclif/core/lib/interfaces';
-import { Manager } from '@listr2/manager';
-import { Config, Command as Command$1, Interfaces, Hook } from '@oclif/core';
-export { Args, Flags, ux } from '@oclif/core';
-import { ChildProcess } from 'child_process';
-import { ListrTaskWrapper, splat, ListrContext } from 'listr2';
-import { Logger, LeveledLogMethod } from 'winston';
-import { ModuleRef } from '@nestjs/core';
-import fs from 'fs-extra';
-export { default as fs } from 'fs-extra';
-import op from 'object-path-immutable';
-import { ClassTransformOptions } from 'class-transformer';
-import { ValidatorOptions } from 'class-validator';
-export { Arg, ArgInput, FlagInput } from '@oclif/core/lib/interfaces/parser';
-
+import { DynamicModule, DynamicModule as DynamicModule$1, INestApplicationContext, Inject, InjectionToken } from "@nestjs/common";
+import { Manager } from "@listr2/manager";
+import { Args, Command as Command$1, Config, Flags, Hook, Interfaces, ux } from "@oclif/core";
+import op from "object-path-immutable";
+import { ListrContext, ListrTaskWrapper, splat } from "listr2";
+import { LeveledLogMethod, Logger } from "winston";
+import fs, { default as fs$1 } from "fs-extra";
+import { ClassTransformOptions } from "class-transformer";
+import { ValidatorOptions } from "class-validator";
+import { ModuleRef } from "@nestjs/core";
+import "reflect-metadata";
+import * as _oclif_core_lib_interfaces0 from "@oclif/core/lib/interfaces";
+import { Flag, InferredFlags } from "@oclif/core/lib/interfaces";
+import { ChildProcess } from "child_process";
+import { Arg, ArgInput, FlagInput } from "@oclif/core/lib/interfaces/parser";
+
+//#region src/interfaces/class.interface.d.ts
 type ClassType<T> = new (...args: any[]) => T;
-
+//#endregion
+//#region src/lib/config/config.interface.d.ts
 interface GlobalConfig {
-    logLevel: LogLevels;
-    isJson: boolean;
+  logLevel: LogLevels;
+  isJson: boolean;
 }
 interface ConfigIterator {
-    key: (string | number)[];
-    env: string;
-    parser?: string;
-    extensions?: ConfigIterator[];
+  key: (string | number)[];
+  env: string;
+  parser?: string;
+  extensions?: ConfigIterator[];
 }
 interface ConfigModuleOptions {
-    oclif?: Config;
-    command?: typeof Command$1;
-    config: GlobalConfig;
+  oclif?: Config;
+  command?: typeof Command$1;
+  config: GlobalConfig;
 }
-
+//#endregion
+//#region src/lib/parser/parser.interface.d.ts
 declare class GenericParser {
-    readonly extensions: string[];
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
+  readonly extensions: string[];
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
 }
-
+//#endregion
+//#region src/lib/logger/pipe/pipe-process-to-listr.d.ts
 declare function pipeProcessThroughListr(task: ListrTaskWrapper<any, any, any>, instance: ChildProcess): ChildProcess;
-
+//#endregion
+//#region src/lib/logger/logger.constants.d.ts
 declare enum LogLevels {
-    SILENT = "SILENT",
-    DIRECT = "DIRECT",
-    FATAL = "FATAL",
-    ERROR = "ERROR",
-    WARN = "WARN",
-    INFO = "INFO",
-    VERBOSE = "VERBOSE",
-    DEBUG = "DEBUG",
-    TRACE = "TRACE"
+  SILENT = "SILENT",
+  DIRECT = "DIRECT",
+  FATAL = "FATAL",
+  ERROR = "ERROR",
+  WARN = "WARN",
+  INFO = "INFO",
+  VERBOSE = "VERBOSE",
+  DEBUG = "DEBUG",
+  TRACE = "TRACE",
 }
 declare enum LogFieldStatus {
-    RUN = "run",
-    END = "end",
-    STAGE = "stage",
-    EXIT = "exit",
-    TERMINATE = "terminate"
-}
-
+  RUN = "run",
+  END = "end",
+  STAGE = "stage",
+  EXIT = "exit",
+  TERMINATE = "terminate",
+}
+//#endregion
+//#region src/lib/logger/pipe/pipe-process-to-logger.interface.d.ts
 interface PipeProcessToLoggerOptions {
-    /** Will log the command when the process starts. */
-    start?: LogLevels;
-    /** Will log the command when the process ends. */
-    end?: LogLevels;
-    /** enable/disable stdout */
-    stdout?: LogLevels;
-    /** enable/disable stderrr */
-    stderr?: LogLevels;
-    /** will callback on error in the instance */
-    callback?: (error?: Error) => void;
-    /** context for logger */
-    context?: string;
-}
-
+  /** Will log the command when the process starts. */
+  start?: LogLevels;
+  /** Will log the command when the process ends. */
+  end?: LogLevels;
+  /** enable/disable stdout */
+  stdout?: LogLevels;
+  /** enable/disable stderrr */
+  stderr?: LogLevels;
+  /** will callback on error in the instance */
+  callback?: (error?: Error) => void;
+  /** context for logger */
+  context?: string;
+}
+//#endregion
+//#region src/lib/logger/logger.interface.d.ts
 interface LoggerFormat {
-    level: LogLevels;
-    message: string;
-    context: string;
-    status: string;
+  level: LogLevels;
+  message: string;
+  context: string;
+  status: string;
 }
 type Winston = Logger & Record<keyof typeof LogLevels, LeveledLogMethod>;
-
+//#endregion
+//#region src/lib/logger/winston.service.d.ts
 declare class WinstonService {
-    private readonly options;
-    readonly instance: Winston;
-    constructor(options: ConfigModuleOptions);
-    private initiateLogger;
-    private logColoring;
-}
-
+  private readonly options;
+  readonly instance: Winston;
+  constructor(options: ConfigModuleOptions);
+  private initiateLogger;
+  private logColoring;
+}
+//#endregion
+//#region src/lib/logger/logger.service.d.ts
 /**
  * A general logger for the the CLI applications.
  */
 declare class LoggerService {
-    private readonly winston;
-    context: string;
-    constructor(winston: WinstonService);
-    setup(context: string): LoggerService;
-    log(level: LogLevels, data: string | Buffer, ...args: any): void;
-    direct(data: string | Buffer, ...args: any): void;
-    fatal(data: string | Buffer, ...args: any): void;
-    error(data: string | Buffer, ...args: any): void;
-    warn(data: string | Buffer, ...args: any): void;
-    info(data: string | Buffer, ...args: any): void;
-    verbose(data: string | Buffer, ...args: any): void;
-    debug(data: string | Buffer, ...args: any): void;
-    trace(data: string | Buffer, ...args: any): void;
-    run(data: string | Buffer, ...args: any): void;
-    end(data: string | Buffer, ...args: any): void;
-    stage(data: string | Buffer, ...args: any): void;
-    splat(...args: Parameters<typeof splat>): ReturnType<typeof splat>;
-    private parseMessage;
-}
-
+  private readonly winston;
+  context: string;
+  constructor(winston: WinstonService);
+  setup(context: string): LoggerService;
+  log(level: LogLevels, data: string | Buffer, ...args: any): void;
+  direct(data: string | Buffer, ...args: any): void;
+  fatal(data: string | Buffer, ...args: any): void;
+  error(data: string | Buffer, ...args: any): void;
+  warn(data: string | Buffer, ...args: any): void;
+  info(data: string | Buffer, ...args: any): void;
+  verbose(data: string | Buffer, ...args: any): void;
+  debug(data: string | Buffer, ...args: any): void;
+  trace(data: string | Buffer, ...args: any): void;
+  run(data: string | Buffer, ...args: any): void;
+  end(data: string | Buffer, ...args: any): void;
+  stage(data: string | Buffer, ...args: any): void;
+  splat(...args: Parameters<typeof splat>): ReturnType<typeof splat>;
+  private parseMessage;
+}
+//#endregion
+//#region src/lib/logger/pipe/pipe-process-to-logger.d.ts
 /**
  * Given the instance it will pipe process output through the logger to append prefixes such as the application name.
  */
 declare function pipeProcessToLogger(logger: LoggerService, instance: ChildProcess, options?: PipeProcessToLoggerOptions): ChildProcess;
-
-declare class LoggerModule {
-}
-
+//#endregion
+//#region src/lib/logger/logger.module.d.ts
+declare class LoggerModule {}
+//#endregion
+//#region src/lib/parser/fts/env-parser.service.d.ts
 declare class EnvironmentVariableParser implements GenericParser {
-    private readonly logger;
-    readonly extensions: string[];
-    private readonly LINE;
-    constructor(logger: LoggerService);
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
-}
-
+  private readonly logger;
+  readonly extensions: string[];
+  private readonly LINE;
+  constructor(logger: LoggerService);
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+//#region src/lib/parser/fts/json-parser.service.d.ts
 declare class JsonParser implements GenericParser {
-    private readonly logger;
-    readonly extensions: string[];
-    constructor(logger: LoggerService);
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
-}
-
+  private readonly logger;
+  readonly extensions: string[];
+  constructor(logger: LoggerService);
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+//#region src/lib/parser/fts/yaml-parser.service.d.ts
 declare class YamlParser implements GenericParser {
-    private readonly logger;
-    readonly extensions: string[];
-    constructor(logger: LoggerService);
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
-}
-
-declare class ParserModule {
-}
-
+  private readonly logger;
+  readonly extensions: string[];
+  constructor(logger: LoggerService);
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+//#region src/lib/parser/parser.module.d.ts
+declare class ParserModule {}
+//#endregion
+//#region src/lib/fs/filesystem.service.d.ts
 declare class FileSystemService {
-    private readonly logger;
-    readonly extra: typeof fs;
-    constructor(logger: LoggerService);
-    exists(path: string): boolean;
-    stats(path: string): fs.Stats;
-    dirname(path: string): string;
-    extname(path: string): string;
-    read(file: string): Promise<string>;
-    readSync(file: string): string;
-    write(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
-    writeSync(file: string, data: string | Buffer, options?: fs.WriteFileOptions): void;
-    append(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
-    appendSync(file: string, data: string | Buffer): void;
-    remove(file: string, options?: fs.RmOptions): Promise<void>;
-    removeSync(file: string, options?: fs.RmOptions): void;
-    emptyDir(directory: string): Promise<void>;
-    emptyDirSync(directory: string): void;
-    removeDir(directory: string): Promise<void>;
-    removeDirSync(directory: string): void;
-    mkdir(directory: string): Promise<void>;
-    mkdirSync(directory: string): void;
-}
-
-declare class FilesystemModule {
-}
-
+  private readonly logger;
+  readonly extra: typeof fs$1;
+  constructor(logger: LoggerService);
+  exists(path: string): boolean;
+  stats(path: string): fs$1.Stats;
+  dirname(path: string): string;
+  extname(path: string): string;
+  read(file: string): Promise<string>;
+  readSync(file: string): string;
+  write(file: string, data: string | Buffer, options?: fs$1.WriteFileOptions): Promise<void>;
+  writeSync(file: string, data: string | Buffer, options?: fs$1.WriteFileOptions): void;
+  append(file: string, data: string | Buffer, options?: fs$1.WriteFileOptions): Promise<void>;
+  appendSync(file: string, data: string | Buffer): void;
+  remove(file: string, options?: fs$1.RmOptions): Promise<void>;
+  removeSync(file: string, options?: fs$1.RmOptions): void;
+  emptyDir(directory: string): Promise<void>;
+  emptyDirSync(directory: string): void;
+  removeDir(directory: string): Promise<void>;
+  removeDirSync(directory: string): void;
+  mkdir(directory: string): Promise<void>;
+  mkdirSync(directory: string): void;
+}
+//#endregion
+//#region src/lib/fs/filesystem.module.d.ts
+declare class FilesystemModule {}
+//#endregion
+//#region src/lib/parser/parser.service.d.ts
 declare class ParserService {
-    private moduleRef;
-    private fs;
-    private readonly logger;
-    private readonly instances;
-    constructor(moduleRef: ModuleRef, fs: FileSystemService, logger: LoggerService);
-    byFt(file: string): GenericParser;
-    fetch<T extends GenericParser>(Parser: ClassType<T>): T;
-    inject<T extends GenericParser>(Parser: ClassType<T>): Promise<T>;
-    register(...parsers: ClassType<GenericParser>[]): Promise<void>;
-    read<T = unknown>(file: string): Promise<T>;
-    write<T = LockableData>(file: string, data: T): Promise<void>;
-    parse<T = unknown>(file: string, data: string | Buffer): T;
-    parseWith<T = unknown>(Parser: ClassType<GenericParser>, data: string | Buffer): T;
-    stringify<T = any>(file: string, data: T): string;
-    stringifyWith<T = any>(Parser: ClassType<GenericParser>, data: T): string;
-}
-
+  private moduleRef;
+  private fs;
+  private readonly logger;
+  private readonly instances;
+  constructor(moduleRef: ModuleRef, fs: FileSystemService, logger: LoggerService);
+  byFt(file: string): GenericParser;
+  fetch<T extends GenericParser>(Parser: ClassType<T>): T;
+  inject<T extends GenericParser>(Parser: ClassType<T>): Promise<T>;
+  register(...parsers: ClassType<GenericParser>[]): Promise<void>;
+  read<T = unknown>(file: string): Promise<T>;
+  write<T = LockableData>(file: string, data: T): Promise<void>;
+  parse<T = unknown>(file: string, data: string | Buffer): T;
+  parseWith<T = unknown>(Parser: ClassType<GenericParser>, data: string | Buffer): T;
+  stringify<T = any>(file: string, data: T): string;
+  stringifyWith<T = any>(Parser: ClassType<GenericParser>, data: T): string;
+}
+//#endregion
+//#region src/utils/defaults.d.ts
 type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
 interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
-    from: K;
-    keys: (keyof K)[];
+  from: K;
+  keys: (keyof K)[];
 }
 declare function setCtxDefaults<T extends ListrContext = ListrContext>(ctx: T, ...defaults: SetCtxDefaultsOptions<T>[]): void;
 declare function setCtxAssign<T extends ListrContext = ListrContext, K = Record<PropertyKey, any>>(ctx: T, ...assigns: SetCtxAssignOptions<K>[]): void;
-
+//#endregion
+//#region src/utils/environment.d.ts
 declare function isVerbose(logLevel: LogLevels): boolean;
 declare function isDebug(logLevel: LogLevels): boolean;
 declare function isSilent(logLevel: LogLevels): boolean;
-
+//#endregion
+//#region src/utils/guards.d.ts
 declare function isHookedWithShouldRunBefore<T extends Command$1 = Command$1>(command: T): command is T & ShouldRunBeforeHook;
 declare function isHookedWithShouldRunAfter<T extends Command$1 = Command$1>(command: T): command is T & ShouldRunAfterHook<any>;
 declare function isHookedWithRegister<T extends Command$1 = Command$1>(command: T): command is T & RegisterHook;
-
+//#endregion
+//#region src/utils/merge.constants.d.ts
 declare enum MergeStrategy {
-    OVERWRITE = "OVERWRITE",
-    EXTEND = "EXTEND"
+  OVERWRITE = "OVERWRITE",
+  EXTEND = "EXTEND",
 }
-
+//#endregion
+//#region src/utils/merge.d.ts
 /** Merge objects deep from overwriting the properties from source to target.
  * Does not mutate the object */
 declare function merge<T extends Record<PropertyKey, any> | any[]>(strategy: MergeStrategy, ...source: Partial<T>[]): T;
 declare function uniqueArrayFilter(value: any, index: any, self: string | any[]): boolean;
-
+//#endregion
+//#region src/lib/locker/locker.interface.d.ts
 interface CommonLockerData {
-    path?: string | string[];
-    enabled?: boolean;
-    root?: boolean;
+  path?: string | string[];
+  enabled?: boolean;
+  root?: boolean;
 }
 type LockableData = any;
 interface LockData<T extends LockableData = LockableData> extends Partial<CommonLockerData> {
-    data: T;
-    merge?: MergeStrategy;
+  data: T;
+  merge?: MergeStrategy;
 }
 interface UnlockData extends CommonLockerData {
-    path: string | string[];
+  path: string | string[];
 }
 interface LockerServiceOptions {
-    file: string;
-    parser: ClassType<GenericParser>;
-    root?: string[];
-    context?: string;
-    token?: InjectionToken;
-}
-
+  file: string;
+  parser: ClassType<GenericParser>;
+  root?: string[];
+  context?: string;
+  token?: InjectionToken;
+}
+//#endregion
+//#region src/lib/locker/locker.service.d.ts
 declare class LockerService<LockFile extends LockableData = LockableData> {
-    private readonly logger;
-    private readonly fs;
-    private readonly parser;
-    private readonly options;
-    readonly op: typeof op;
-    private toLock;
-    private toUnlock;
-    constructor(logger: LoggerService, fs: FileSystemService, parser: ParserService, options: LockerServiceOptions);
-    hasLock(): boolean;
-    hasUnlock(): boolean;
-    addLock<T extends LockableData = LockFile>(...data: LockData<T>[]): void;
-    addUnlock(...data: UnlockData[]): void;
-    applyLockAll(lock: LockFile): Promise<LockFile>;
-    lockAll(): Promise<void>;
-    applyUnlockAll(lock: LockFile): Promise<LockFile>;
-    unlockAll(): Promise<void>;
-    all(): Promise<void>;
-    applyAll(lock: LockFile): Promise<LockFile>;
-    applyLock<T extends LockableData = LockFile>(lock: LockFile, ...data: LockData<T>[]): Promise<LockFile>;
-    lock<T extends LockableData = LockFile>(...data: LockData<T>[]): Promise<LockFile>;
-    applyUnlock(lock: LockFile, ...data: UnlockData[]): Promise<LockFile>;
-    unlock(...data: UnlockData[]): Promise<LockFile | undefined>;
-    read(): Promise<LockFile>;
-    tryRead(): Promise<LockFile | undefined>;
-    tryRemove(): Promise<void>;
-    write(data: LockFile): Promise<void>;
-    private buildPath;
-    private normalizePath;
-}
-
+  private readonly logger;
+  private readonly fs;
+  private readonly parser;
+  private readonly options;
+  readonly op: typeof op;
+  private toLock;
+  private toUnlock;
+  constructor(logger: LoggerService, fs: FileSystemService, parser: ParserService, options: LockerServiceOptions);
+  hasLock(): boolean;
+  hasUnlock(): boolean;
+  addLock<T extends LockableData = LockFile>(...data: LockData<T>[]): void;
+  addUnlock(...data: UnlockData[]): void;
+  applyLockAll(lock: LockFile): Promise<LockFile>;
+  lockAll(): Promise<void>;
+  applyUnlockAll(lock: LockFile): Promise<LockFile>;
+  unlockAll(): Promise<void>;
+  all(): Promise<void>;
+  applyAll(lock: LockFile): Promise<LockFile>;
+  applyLock<T extends LockableData = LockFile>(lock: LockFile, ...data: LockData<T>[]): Promise<LockFile>;
+  lock<T extends LockableData = LockFile>(...data: LockData<T>[]): Promise<LockFile>;
+  applyUnlock(lock: LockFile, ...data: UnlockData[]): Promise<LockFile>;
+  unlock(...data: UnlockData[]): Promise<LockFile | undefined>;
+  read(): Promise<LockFile>;
+  tryRead(): Promise<LockFile | undefined>;
+  tryRemove(): Promise<void>;
+  write(data: LockFile): Promise<void>;
+  private buildPath;
+  private normalizePath;
+}
+//#endregion
+//#region src/lib/locker/locker.module.d.ts
 declare class LockerModule {
-    static forFeature(options: LockerServiceOptions): DynamicModule;
+  static forFeature(options: LockerServiceOptions): DynamicModule$1;
 }
-
+//#endregion
+//#region src/lib/config/config.service.d.ts
 declare class ConfigService {
-    private readonly parser;
-    private readonly logger;
-    defaults: string;
-    root: string;
-    config: GlobalConfig;
-    oclif: Config;
-    command: typeof Command$1;
-    constructor(parser: ParserService, logger: LoggerService, options: ConfigModuleOptions);
-    get isVerbose(): boolean;
-    get isDebug(): boolean;
-    get isSilent(): boolean;
-    get isJson(): boolean;
-    read<T extends LockableData = LockableData>(path: string): Promise<T>;
-    extend<T extends LockableData = LockableData>(paths: (string | Partial<T>)[], strategy?: MergeStrategy): Promise<T>;
-    merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): T;
-    env<T extends LockableData = LockableData>(definition: string | Record<PropertyKey, any>, config: T): Promise<T>;
-    write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
-}
-
-declare class ConfigModule {
-}
-
+  private readonly parser;
+  private readonly logger;
+  defaults: string;
+  root: string;
+  config: GlobalConfig;
+  oclif: Config;
+  command: typeof Command$1;
+  constructor(parser: ParserService, logger: LoggerService, options: ConfigModuleOptions);
+  get isVerbose(): boolean;
+  get isDebug(): boolean;
+  get isSilent(): boolean;
+  get isJson(): boolean;
+  read<T extends LockableData = LockableData>(path: string): Promise<T>;
+  extend<T extends LockableData = LockableData>(paths: (string | Partial<T>)[], strategy?: MergeStrategy): Promise<T>;
+  merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): T;
+  env<T extends LockableData = LockableData>(definition: string | Record<PropertyKey, any>, config: T): Promise<T>;
+  write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
+}
+//#endregion
+//#region src/lib/config/config.module.d.ts
+declare class ConfigModule {}
+//#endregion
+//#region src/lib/logo/logo.constants.d.ts
 declare const TOKEN_LOGO_GENERATOR: InjectionToken;
-
+//#endregion
+//#region src/lib/logo/logo.service.d.ts
 declare class LogoService {
-    readonly cs: ConfigService;
-    private generator;
-    constructor(cs: ConfigService, moduleRef: ModuleRef);
-    generate(): void;
-    shouldBeSilent(): boolean;
-    write(...data: string[]): void;
-}
-
+  readonly cs: ConfigService;
+  private generator;
+  constructor(cs: ConfigService, moduleRef: ModuleRef);
+  generate(): void;
+  shouldBeSilent(): boolean;
+  write(...data: string[]): void;
+}
+//#endregion
+//#region src/lib/logo/logo.interface.d.ts
 type LogoGeneratorFn = (this: LogoService) => void;
-
-declare class LogoModule {
-}
-
+//#endregion
+//#region src/lib/logo/logo.module.d.ts
+declare class LogoModule {}
+//#endregion
+//#region src/lib/validator/validator.constants.d.ts
 declare const TOKEN_VALIDATOR_SERVICE_OPTIONS: InjectionToken;
-
+//#endregion
+//#region src/lib/validator/validator.interface.d.ts
 interface ValidatorServiceOptions {
-    validator?: ValidatorOptions;
-    transformer?: ClassTransformOptions;
-}
-
-declare class ValidatorModule {
-}
-
+  validator?: ValidatorOptions;
+  transformer?: ClassTransformOptions;
+}
+//#endregion
+//#region src/lib/validator/validator.module.d.ts
+declare class ValidatorModule {}
+//#endregion
+//#region src/lib/validator/validator.service.d.ts
 declare class ValidatorService {
-    private readonly logger;
-    private options;
-    constructor(logger: LoggerService, moduleRef: ModuleRef);
-    validate<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): Promise<T>;
-    validateSync<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): T;
-    private logValidationError;
-}
-
+  private readonly logger;
+  private options;
+  constructor(logger: LoggerService, moduleRef: ModuleRef);
+  validate<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): Promise<T>;
+  validateSync<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): T;
+  private logValidationError;
+}
+//#endregion
+//#region src/lib/setup.d.ts
 declare function setup(): Promise<void>;
-
+//#endregion
+//#region src/lib/cli.interface.d.ts
 interface CliModuleOptions {
-    config: ConfigModuleOptions;
+  config: ConfigModuleOptions;
 }
-
+//#endregion
+//#region src/lib/cli.module.d.ts
 declare class CliModule {
-    static forRoot(options: CliModuleOptions): DynamicModule;
-    static forMinimum(): DynamicModule;
-    static create(cls: DynamicModule): Promise<INestApplicationContext>;
+  static forRoot(options: CliModuleOptions): DynamicModule$1;
+  static forMinimum(): DynamicModule$1;
+  static create(cls: DynamicModule$1): Promise<INestApplicationContext>;
 }
-
+//#endregion
+//#region src/interfaces/hooks.interface.d.ts
 declare class ShouldRunBeforeHook {
-    shouldRunBefore(): void | Promise<void>;
+  shouldRunBefore(): void | Promise<void>;
 }
 declare class ShouldRunAfterHook<Ctx extends ListrContext = ListrContext> {
-    shouldRunAfter(ctx: Ctx): void | Promise<void>;
+  shouldRunAfter(ctx: Ctx): void | Promise<void>;
 }
 declare class RegisterHook {
-    register(cli: DynamicModule, options: CliModuleOptions): DynamicModule | Promise<DynamicModule>;
+  register(cli: DynamicModule$1, options: CliModuleOptions): DynamicModule$1 | Promise<DynamicModule$1>;
 }
-
+//#endregion
+//#region src/interfaces/oclif.interface.d.ts
 type InferFlags<T extends typeof Command$1> = Interfaces.InferredFlags<(typeof Command$1)['baseFlags'] & T['flags']>;
 type InferArgs<T extends typeof Command$1> = Interfaces.InferredArgs<T['args']>;
-
+//#endregion
+//#region src/interfaces/type-helper.interface.d.ts
 /**
  * Makes the object deep partial.
  */
-type DeepPartial<T> = {
-    [P in keyof T]?: DeepPartial<T[P]>;
-};
-
+type DeepPartial<T> = { [P in keyof T]?: DeepPartial<T[P]> };
+//#endregion
+//#region src/commands/base.command.d.ts
 declare abstract class Command<T extends typeof Command$1 = typeof Command$1, Ctx extends ListrContext = ListrContext> extends Command$1 {
-    static baseFlags: {
-        "log-level": _oclif_core_lib_interfaces.OptionFlag<string, _oclif_core_lib_interfaces.CustomOptions>;
-        ci: _oclif_core_lib_interfaces.BooleanFlag<boolean>;
-        json: _oclif_core_lib_interfaces.BooleanFlag<boolean>;
-    };
-    logger: LoggerService;
-    tasks: Manager<Ctx>;
-    app: INestApplicationContext;
-    flags: InferFlags<T>;
-    args: InferArgs<T>;
-    exit(code?: number): never;
-    /** Run all tasks from task manager. */
-    runTasks<C extends Ctx = Ctx>(): Promise<C>;
-    protected setCtxDefaults<T extends Ctx = Ctx>(...defaults: SetCtxDefaultsOptions<T>[]): void;
-    protected setCtxAssign<K = Record<PropertyKey, any>>(...assigns: SetCtxAssignOptions<K>[]): void;
-    protected pipeProcessToLogger(instance: ChildProcess, options?: PipeProcessToLoggerOptions): ChildProcess;
-    protected pipeProcessThroughListr(instance: ChildProcess, task: ListrTaskWrapper<any, any, any>): ChildProcess;
-    /** Initial functions / constructor */
-    protected init(): Promise<void>;
-    /** Tasks to run before end of the command. */
-    protected finally<C extends Ctx = Ctx>(err: Error | undefined): Promise<{
-        ctx: C;
-    }>;
-    /** Catch any error occurred during command. */
-    protected catch(err: Error): Promise<never>;
-    abstract run(): Promise<any>;
-}
-
+  static baseFlags: {
+    "log-level": _oclif_core_lib_interfaces0.OptionFlag<string, _oclif_core_lib_interfaces0.CustomOptions>;
+    ci: _oclif_core_lib_interfaces0.BooleanFlag<boolean>;
+    json: _oclif_core_lib_interfaces0.BooleanFlag<boolean>;
+  };
+  logger: LoggerService;
+  tasks: Manager<Ctx>;
+  app: INestApplicationContext;
+  flags: InferFlags<T>;
+  args: InferArgs<T>;
+  exit(code?: number): never;
+  /** Run all tasks from task manager. */
+  runTasks<C extends Ctx = Ctx>(): Promise<C>;
+  protected setCtxDefaults<T extends Ctx = Ctx>(...defaults: SetCtxDefaultsOptions<T>[]): void;
+  protected setCtxAssign<K = Record<PropertyKey, any>>(...assigns: SetCtxAssignOptions<K>[]): void;
+  protected pipeProcessToLogger(instance: ChildProcess, options?: PipeProcessToLoggerOptions): ChildProcess;
+  protected pipeProcessThroughListr(instance: ChildProcess, task: ListrTaskWrapper<any, any, any>): ChildProcess;
+  /** Initial functions / constructor */
+  protected init(): Promise<void>;
+  /** Tasks to run before end of the command. */
+  protected finally<C extends Ctx = Ctx>(err: Error | undefined): Promise<{
+    ctx: C;
+  }>;
+  /** Catch any error occurred during command. */
+  protected catch(err: Error): Promise<never>;
+  abstract run(): Promise<any>;
+}
+//#endregion
+//#region src/constants/file.constants.d.ts
 declare enum FileConstants {
-    CONFIG_SERVICE_DEFAULTS_DIR = "config"
+  CONFIG_SERVICE_DEFAULTS_DIR = "config",
 }
-
+//#endregion
+//#region src/constants/help-groups.constants.d.ts
 declare enum HelpGroups {
-    CLI = "CLI"
+  CLI = "CLI",
 }
-
+//#endregion
+//#region src/hooks/not-found.hook.d.ts
 declare const notFoundHook: Hook<'command_not_found'>;
-
+//#endregion
+//#region src/hooks/update-notifier.hook.d.ts
 declare const updateNotifierHook: Hook<'init'>;
-
-export { type ClassType, CliModule, type CliModuleOptions, Command, type CommonLockerData, type ConfigIterator, ConfigModule, type ConfigModuleOptions, ConfigService, type DeepPartial, EnvironmentVariableParser, FileConstants, FileSystemService, FilesystemModule, GenericParser, type GlobalConfig, HelpGroups, type InferArgs, type InferFlags, JsonParser, type LockData, type LockableData, LockerModule, LockerService, type LockerServiceOptions, LogFieldStatus, LogLevels, type LoggerFormat, LoggerModule, LoggerService, type LogoGeneratorFn, LogoModule, LogoService, MergeStrategy, ParserModule, ParserService, type PipeProcessToLoggerOptions, RegisterHook, type SetCtxAssignOptions, type SetCtxDefaultsOptions, ShouldRunAfterHook, ShouldRunBeforeHook, TOKEN_LOGO_GENERATOR, TOKEN_VALIDATOR_SERVICE_OPTIONS, type UnlockData, ValidatorModule, ValidatorService, type ValidatorServiceOptions, type Winston, WinstonService, YamlParser, isDebug, isHookedWithRegister, isHookedWithShouldRunAfter, isHookedWithShouldRunBefore, isSilent, isVerbose, merge, notFoundHook, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup, uniqueArrayFilter, updateNotifierHook };
+//#endregion
+export { type Arg, type ArgInput, Args, ClassType, CliModule, CliModuleOptions, Command, CommonLockerData, ConfigIterator, ConfigModule, ConfigModuleOptions, ConfigService, DeepPartial, type DynamicModule, EnvironmentVariableParser, FileConstants, FileSystemService, FilesystemModule, type Flag, type FlagInput, Flags, GenericParser, GlobalConfig, HelpGroups, InferArgs, InferFlags, type InferredFlags, Inject, JsonParser, LockData, LockableData, LockerModule, LockerService, LockerServiceOptions, LogFieldStatus, LogLevels, LoggerFormat, LoggerModule, LoggerService, LogoGeneratorFn, LogoModule, LogoService, MergeStrategy, ParserModule, ParserService, PipeProcessToLoggerOptions, RegisterHook, SetCtxAssignOptions, SetCtxDefaultsOptions, ShouldRunAfterHook, ShouldRunBeforeHook, TOKEN_LOGO_GENERATOR, TOKEN_VALIDATOR_SERVICE_OPTIONS, UnlockData, ValidatorModule, ValidatorService, ValidatorServiceOptions, Winston, WinstonService, YamlParser, type fs, isDebug, isHookedWithRegister, isHookedWithShouldRunAfter, isHookedWithShouldRunBefore, isSilent, isVerbose, merge, notFoundHook, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup, uniqueArrayFilter, updateNotifierHook, ux };