@cenk1cenk2/oclif-common 5.0.8 → 6.0.0

package/dist/index.d.ts

@@ -1,20 +1,47 @@
-import { Command as Command$1, ux, Hook } from '@oclif/core';
+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 { ExecaChildProcess } from 'execa';
-import { ListrTaskWrapper, splat, ListrContext, Manager, PromptOptions } from 'listr2';
-import { Logger as Logger$1, LeveledLogMethod } from 'winston';
+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';
-import { InferredFlags } from '@oclif/core/lib/interfaces';
-export { Flag, InferredFlags } from '@oclif/core/lib/interfaces';
-import { FlagInput } from '@oclif/core/lib/interfaces/parser';
 export { Arg, ArgInput, FlagInput } from '@oclif/core/lib/interfaces/parser';
 
 type ClassType<T> = new (...args: any[]) => T;
 
-declare function pipeProcessThroughListr(task: ListrTaskWrapper<any, any>, instance: ExecaChildProcess): ExecaChildProcess;
+interface GlobalConfig {
+    logLevel: LogLevels;
+    isJson: boolean;
+}
+interface ConfigIterator {
+    key: (string | number)[];
+    env: string;
+    parser?: string;
+    extensions?: ConfigIterator[];
+}
+interface ConfigModuleOptions {
+    oclif?: Config;
+    command?: typeof Command$1;
+    config: GlobalConfig;
+}
+
+declare const INSTANCE_LOCKER_SERVICE: InjectionToken;
+
+declare class GenericParser {
+    static extensions: string[];
+    parse<T = unknown>(data: string | Buffer): T | Promise<T>;
+    stringify<T = any>(data: T): string | Promise<string>;
+}
+
+declare function pipeProcessThroughListr(task: ListrTaskWrapper<any, any, any>, instance: ExecaChildProcess): ExecaChildProcess;
 
 declare enum LogLevels {
     SILENT = "SILENT",
@@ -50,66 +77,140 @@ interface PipeProcessToLoggerOptions {
     context?: string;
 }
 
-interface LoggerOptions {
-    useIcons?: boolean;
-    level?: LogLevels;
-}
 interface LoggerFormat {
     level: LogLevels;
     message: string;
     context: string;
     status: string;
 }
-type Winston = Logger$1 & Record<keyof typeof LogLevels, LeveledLogMethod>;
+type Winston = Logger & Record<keyof typeof LogLevels, LeveledLogMethod>;
+
+declare class WinstonService {
+    private readonly options;
+    readonly instance: Winston;
+    constructor(options: ConfigModuleOptions);
+    private initiateLogger;
+    private logColoring;
+}
 
 /**
  * A general logger for the the CLI applications.
  */
-declare class Logger {
-    private context?;
-    private options?;
-    private static instance;
-    private logger;
-    constructor(context?: string, options?: LoggerOptions);
+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;
-    debug(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 initiateLogger;
     private parseMessage;
-    private logColoring;
 }
 
 /**
  * Given the instance it will pipe process output through the logger to append prefixes such as the application name.
  */
-declare function pipeProcessToLogger(logger: Logger, instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
+declare function pipeProcessToLogger(logger: LoggerService, instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
 
-interface GlobalConfig {
-    logLevel: LogLevels;
-    ci: boolean;
-    json: boolean;
+declare class LoggerModule {
 }
-interface ConfigIterator {
-    key: (string | number)[];
-    env: string;
-    parser?: string;
-    extensions?: ConfigIterator[];
+
+declare class EnvironmentVariableParser implements GenericParser {
+    private readonly logger;
+    static extensions: string[];
+    private readonly LINE;
+    constructor(logger: LoggerService);
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+declare class JsonParser implements GenericParser {
+    private readonly logger;
+    static extensions: string[];
+    constructor(logger: LoggerService);
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+declare class YamlParser implements GenericParser {
+    private readonly logger;
+    static extensions: string[];
+    constructor(logger: LoggerService);
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+declare class ParserModule {
+}
+
+declare class FileSystemService {
+    private readonly logger;
+    readonly fs: 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 {
+}
+
+declare class ParserService {
+    private moduleRef;
+    private fs;
+    private readonly logger;
+    parsers: ClassType<GenericParser>[];
+    constructor(moduleRef: ModuleRef, fs: FileSystemService, logger: LoggerService);
+    getParser(file: string): Promise<GenericParser>;
+    setParsers(...parsers: ClassType<GenericParser>[]): void;
+    addParsers(...parsers: ClassType<GenericParser>[]): 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): Promise<T>;
+    stringify<T = any>(file: string, data: T): Promise<string>;
 }
 
+type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
+interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
+    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;
+
 declare function isVerbose(logLevel: LogLevels): boolean;
 declare function isDebug(logLevel: LogLevels): boolean;
 declare function isSilent(logLevel: LogLevels): boolean;
 
+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;
+
 declare enum MergeStrategy {
     OVERWRITE = "OVERWRITE",
     EXTEND = "EXTEND"
@@ -118,15 +219,7 @@ declare enum MergeStrategy {
 /** 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 uniqueFilter(value: any, index: any, self: string | any[]): boolean;
-
-type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
-interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
-    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;
+declare function uniqueArrayFilter(value: any, index: any, self: string | any[]): boolean;
 
 interface CommonLockerData {
     path?: string | string[];
@@ -141,22 +234,22 @@ interface LockData<T extends LockableData = LockableData> extends Partial<Common
 interface UnlockData extends CommonLockerData {
     path: string | string[];
 }
-
-declare class GenericParser {
-    static extensions: string[];
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
+interface LockerServiceOptions {
+    file: string;
+    parser: GenericParser;
+    root?: string[];
+    context?: string;
+    token?: InjectionToken;
 }
 
 declare class LockerService<LockFile extends LockableData = LockableData> {
-    private file;
-    private parser?;
-    private root?;
+    private readonly logger;
+    private readonly fs;
+    private readonly options;
+    readonly op: typeof op;
     private toLock;
     private toUnlock;
-    private logger;
-    private fs;
-    constructor(file: string, parser?: GenericParser, root?: string[], context?: string);
+    constructor(logger: LoggerService, fs: FileSystemService, options: LockerServiceOptions);
     hasLock(): boolean;
     hasUnlock(): boolean;
     addLock<T extends LockableData = LockableData>(...data: LockData<T>[]): void;
@@ -173,119 +266,63 @@ declare class LockerService<LockFile extends LockableData = LockableData> {
     private normalizePath;
 }
 
-declare class ParserService {
-    private static instance;
-    parsers: ClassType<GenericParser>[];
-    private logger;
-    private fs;
-    constructor(parsers?: ClassType<GenericParser>[]);
-    getParser(file: string): GenericParser;
-    setParsers(...parsers: ClassType<GenericParser>[]): void;
-    addParsers(...parsers: ClassType<GenericParser>[]): 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;
-    stringify<T = any>(file: string, data: T): string | Promise<string>;
+declare class LockerModule {
+    static forFeature(options: LockerServiceOptions): DynamicModule;
 }
 
-declare class ConfigService implements GlobalConfig {
-    oclif: Command['config'];
-    command: Command['ctor'];
-    private static instance;
+declare class ConfigService {
+    private readonly parser;
+    private readonly logger;
     defaults: string;
     root: string;
-    parser: ParserService;
-    logLevel: LogLevels;
-    isVerbose: boolean;
-    isDebug: boolean;
-    isSilent: boolean;
-    ci: boolean;
-    json: boolean;
-    private logger;
-    constructor(oclif: Command['config'], command: Command['ctor'], config: GlobalConfig);
+    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>;
-    private recalculate;
-}
-
-declare class FileSystemService {
-    private static instance;
-    private logger;
-    constructor();
-    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 EnvironmentVariableParser implements GenericParser {
-    static extensions: string[];
-    private static instance;
-    private logger;
-    private LINE;
-    constructor();
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
+declare class ConfigModule {
 }
 
-declare class YamlParser implements GenericParser {
-    static extensions: string[];
-    private static instance;
-    private logger;
-    constructor();
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
-}
+declare const TOKEN_LOGO_GENERATOR: InjectionToken;
 
-declare class JsonParser implements GenericParser {
-    static extensions: string[];
-    private static instance;
-    private logger;
-    constructor();
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
+declare class LogoService {
+    readonly cs: ConfigService;
+    private generator;
+    constructor(cs: ConfigService, moduleRef: ModuleRef);
+    generate(): void;
+    shouldBeSilent(): boolean;
+    write(...data: string[]): void;
 }
 
-type DataStore<T extends Record<PropertyKey, any> = Record<PropertyKey, any>> = {
-    logo?: string;
-} & T;
+type LogoGeneratorFn = (this: LogoService) => void;
 
-declare class StoreService<T extends Record<PropertyKey, any> = Record<PropertyKey, any>> {
-    private static instance;
-    private store;
-    constructor();
-    has<K extends keyof DataStore<T>>(key: K): boolean;
-    get<K extends keyof DataStore<T>>(key: K): DataStore<T>[K];
-    set<K extends keyof DataStore<T>>(key: K, data: DataStore<T>[K]): DataStore<T>[K];
+declare class LogoModule {
 }
 
+declare const TOKEN_VALIDATOR_SERVICE_OPTIONS: InjectionToken;
+
 interface ValidatorServiceOptions {
     validator?: ValidatorOptions;
     transformer?: ClassTransformOptions;
 }
 
+declare class ValidatorModule {
+}
+
 declare class ValidatorService {
-    options?: ValidatorServiceOptions;
-    private static instance;
-    private logger;
-    constructor(options?: ValidatorServiceOptions);
+    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;
@@ -293,14 +330,28 @@ declare class ValidatorService {
 
 declare function setup(): void;
 
-type ConfigCommandChoices<T extends string> = Record<T, () => void | Promise<void>>;
-interface ConfigCommandSetup<T extends string = string, LockFile = any> {
-    choices: ConfigCommandChoices<T>;
-    locker?: LockerService<LockFile>;
+interface CliModuleOptions {
+    config: ConfigModuleOptions;
 }
 
-type InferFlags<T extends typeof Command$1> = InferredFlags<T['baseFlags'] & T['flags']>;
-type InferArgs<T extends typeof Command$1> = Record<keyof T['args'], string>;
+declare class CliModule {
+    static forRoot(options: CliModuleOptions): DynamicModule;
+    static forMinimum(): DynamicModule;
+    static create(cls: DynamicModule): Promise<INestApplicationContext>;
+}
+
+declare class ShouldRunBeforeHook {
+    shouldRunBefore(): void | Promise<void>;
+}
+declare class ShouldRunAfterHook<Ctx> {
+    shouldRunAfter(ctx: Ctx): void | Promise<void>;
+}
+declare class RegisterHook {
+    register(cli: DynamicModule, options: CliModuleOptions): DynamicModule;
+}
+
+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']>;
 
 /**
  * Makes the object deep partial.
@@ -309,38 +360,24 @@ type DeepPartial<T> = {
     [P in keyof T]?: DeepPartial<T[P]>;
 };
 
-declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof Command>, Args extends Record<PropertyKey, any> = InferArgs<typeof Command>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command$1 {
-    static get baseFlags(): FlagInput;
-    static set baseFlags(flags: FlagInput);
-    context: string;
-    logger: Logger;
-    tasks: Manager<Ctx, 'default' | 'verbose' | 'silent' | 'simple'>;
-    validator: ValidatorService;
-    cs: ConfigService;
-    parser: ParserService;
-    fs: FileSystemService;
-    store: StoreService<Store>;
-    flags: Flags;
-    args: Args;
-    /**
-     * Construct the class if you dont want to extend init or constructor.
-     */
-    shouldRunBefore(): void | Promise<void>;
-    /**
-     * Deconstruct the class if you dont want to extend finally or catch.
-     */
-    shouldRunAfter(_ctx?: Ctx): void | Promise<void>;
-    run(): Promise<any>;
-    _run<T>(): Promise<T | undefined>;
-    exit(code?: number): void;
+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>;
-    /** Gets prompt from user. */
-    prompt<T = any>(options: PromptOptions): Promise<T>;
     protected setCtxDefaults<T extends Ctx = Ctx>(...defaults: SetCtxDefaultsOptions<T>[]): void;
     protected setCtxAssign<K = Record<PropertyKey, any>>(...assigns: SetCtxAssignOptions<K>[]): void;
     protected pipeProcessToLogger(instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
-    protected pipeProcessThroughListr(task: ListrTaskWrapper<any, any>, instance: ExecaChildProcess): ExecaChildProcess;
+    protected pipeProcessThroughListr(instance: ExecaChildProcess, task: ListrTaskWrapper<any, any, any>): ExecaChildProcess;
     /** Initial functions / constructor */
     protected init(): Promise<void>;
     /** Tasks to run before end of the command. */
@@ -349,24 +386,13 @@ declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Rec
     }>;
     /** Catch any error occurred during command. */
     protected catch(e: Error, exit?: number): Promise<void>;
-    private greet;
-}
-
-declare class ConfigCommand<CommandChoices extends string = string, LockFile = any, Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof ConfigCommand>, Args extends Record<PropertyKey, any> = InferArgs<typeof ConfigCommand>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command<Ctx, Flags, Args, Store> {
-    choices: ConfigCommandChoices<CommandChoices>;
-    locker: LockerService<LockFile>;
-    run(): Promise<any>;
-    setup(): ConfigCommandSetup<CommandChoices, LockFile> | Promise<ConfigCommandSetup<CommandChoices, LockFile>>;
-    protected table(...options: Parameters<typeof ux.table>): void;
-    protected select(): Promise<CommandChoices>;
+    abstract run(): Promise<any>;
 }
 
 declare enum FileConstants {
     CONFIG_SERVICE_DEFAULTS_DIR = "config"
 }
 
-declare const CLI_FLAGS: FlagInput;
-
 declare enum HelpGroups {
     CLI = "CLI"
 }
@@ -375,6 +401,4 @@ declare const notFoundHook: Hook<'command_not_found'>;
 
 declare const updateNotifierHook: Hook<'init'>;
 
-declare const storeHook: <T extends Record<PropertyKey, any> = Record<PropertyKey, any>>(cb: (opts: any, store: StoreService<T>) => void) => Hook<'init'>;
-
-export { CLI_FLAGS, ClassType, Command, CommonLockerData, ConfigCommand, ConfigCommandChoices, ConfigCommandSetup, ConfigIterator, ConfigService, DataStore, DeepPartial, EnvironmentVariableParser, FileConstants, FileSystemService, GenericParser, GlobalConfig, HelpGroups, InferArgs, InferFlags, JsonParser, LockData, LockableData, LockerService, LogFieldStatus, LogLevels, Logger, LoggerFormat, LoggerOptions, MergeStrategy, ParserService, PipeProcessToLoggerOptions, SetCtxAssignOptions, SetCtxDefaultsOptions, StoreService, UnlockData, ValidatorService, ValidatorServiceOptions, Winston, YamlParser, isDebug, isSilent, isVerbose, merge, notFoundHook, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup, storeHook, uniqueFilter, updateNotifierHook };
+export { ClassType, CliModule, CliModuleOptions, Command, CommonLockerData, ConfigIterator, ConfigModule, ConfigModuleOptions, ConfigService, DeepPartial, EnvironmentVariableParser, FileConstants, FileSystemService, FilesystemModule, GenericParser, GlobalConfig, HelpGroups, INSTANCE_LOCKER_SERVICE, InferArgs, InferFlags, 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, isDebug, isHookedWithRegister, isHookedWithShouldRunAfter, isHookedWithShouldRunBefore, isSilent, isVerbose, merge, notFoundHook, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup, uniqueArrayFilter, updateNotifierHook };