@types/listr

constructor(
    tasks?: readonly Listr.ListrTask<Ctx>[],
    options?: Listr.ListrOptions<Ctx>
);

constructor(options?: Listr.ListrOptions<Ctx>);

tasks: readonly Listr.ListrTaskWrapper<Ctx>[];

add: (tasks: Listr.ListrTask<Ctx> | ReadonlyArray<Listr.ListrTask<Ctx>>) => void;

render: () => void;

run: (ctx?: Ctx) => Promise<Ctx>;

setRenderer: (value: Listr.ListrRendererValue<Ctx>) => void;

context: Ctx;

data?: string | boolean | undefined;

type: string;

concurrent?: boolean | number | undefined;

exitOnError?: boolean | undefined;

nonTTYRenderer?: ListrRendererValue<Ctx> | undefined;

renderer?: ListrRendererValue<Ctx> | undefined;

end: (err: Error) => void;

render: () => void;

nonTTY: boolean;

new (
    tasks: ReadonlyArray<ListrTaskObject<Ctx>>,
    options: ListrOptions<Ctx>
): ListrRenderer;

enabled?:
    | ((ctx: Ctx) => boolean | Promise<boolean> | Observable<boolean>)
    | undefined;

skip?:
    | ((
          ctx: Ctx
      ) => void | boolean | string | Promise<undefined | boolean | string>)
    | undefined;

task: (ctx: Ctx, task: ListrTaskWrapper<Ctx>) => void | ListrTaskResult<Ctx>;

title: string;

check: (ctx: Ctx) => void;

output?: string | undefined;

run: (ctx: Ctx, wrapper: ListrTaskWrapper<Ctx>) => Promise<void>;

skip: (
    ctx: Ctx
) => void | boolean | string | Promise<undefined | boolean | string>;

state: string;

subtasks: ReadonlyArray<ListrTaskWrapper<Ctx>>;

task: (ctx: Ctx, task: ListrTaskWrapper<Ctx>) => void | ListrTaskResult<Ctx>;

title: string;

hasFailed: () => boolean;

hasSubtasks: () => boolean;

isCompleted: () => boolean;

isEnabled: () => boolean;

isPending: () => boolean;

isSkipped: () => boolean;

output: string;

title: string;

report: (error: Error) => void;

run: (ctx?: Ctx) => Promise<void>;

skip: (message: string) => void;