@mittwald/cli 1.0.0-alpha.3

package/bin/dev

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const oclif = require('@oclif/core')
+
+const path = require('path')
+const project = path.join(__dirname, '..', 'tsconfig.json')
+
+// In dev mode -> use ts-node and dev plugins
+process.env.NODE_ENV = 'development'
+
+require('ts-node').register({project})
+
+// In dev mode, always show stack traces
+oclif.settings.debug = true;
+
+// Start the CLI
+oclif.run().then(oclif.flush).catch(oclif.Errors.handle)

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\dev" %*

package/bin/mw.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run.js" %*

package/bin/run.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import oclif from "@oclif/core";
+import { handleError } from "../dist/esm/lib/handleError.js";
+
+oclif
+  .run(process.argv.slice(2), import.meta.url)
+  .then(oclif.flush)
+  .catch(handleError);

package/dist/esm/BaseCommand.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    protected authenticationRequired: boolean;
+    protected apiClient: MittwaldAPIV2Client;
+    init(): Promise<void>;
+    protected getTokenFilename(): string;
+    private readApiToken;
+    private readApiTokenFromEnvironment;
+    private readApiTokenFromConfig;
+}

package/dist/esm/BaseCommand.js

@@ -0,0 +1,44 @@
+import { Command } from "@oclif/core";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export class BaseCommand extends Command {
+    authenticationRequired = true;
+    apiClient = MittwaldAPIV2Client.newUnauthenticated();
+    async init() {
+        await super.init();
+        if (this.authenticationRequired) {
+            const token = await this.readApiToken();
+            if (token === undefined) {
+                throw new Error(`Could not get token from either config file (${this.getTokenFilename()}) or environment`);
+            }
+            this.apiClient = MittwaldAPIV2Client.newWithToken(token);
+        }
+    }
+    getTokenFilename() {
+        return path.join(this.config.configDir, "token");
+    }
+    async readApiToken() {
+        return (this.readApiTokenFromEnvironment() ??
+            (await this.readApiTokenFromConfig()));
+    }
+    readApiTokenFromEnvironment() {
+        const token = process.env.MITTWALD_API_TOKEN;
+        if (token === undefined) {
+            return undefined;
+        }
+        return token.trim();
+    }
+    async readApiTokenFromConfig() {
+        try {
+            const tokenFileContents = await fs.readFile(this.getTokenFilename(), "utf-8");
+            return tokenFileContents.trim();
+        }
+        catch (err) {
+            if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+                return undefined;
+            }
+            throw err;
+        }
+    }
+}

package/dist/esm/DeleteBaseCommand.d.ts

@@ -0,0 +1,15 @@
+import { Command, Interfaces } from "@oclif/core";
+import { BaseCommand } from "./BaseCommand.js";
+export type DeleteFlags<T extends typeof Command> = Interfaces.InferredFlags<(typeof DeleteBaseCommand)["baseFlags"] & T["flags"]>;
+export type DeleteArgs<T extends typeof Command> = Interfaces.InferredArgs<T["args"]>;
+export declare abstract class DeleteBaseCommand<T extends typeof Command> extends BaseCommand<T> {
+    static resourceName: string;
+    static baseFlags: {
+        force: Interfaces.BooleanFlag<boolean>;
+    };
+    protected flags: DeleteFlags<T>;
+    protected args: DeleteArgs<T>;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected abstract deleteResource(): Promise<void>;
+}

package/dist/esm/DeleteBaseCommand.js

@@ -0,0 +1,37 @@
+import { Flags, ux } from "@oclif/core";
+import { BaseCommand } from "./BaseCommand.js";
+export class DeleteBaseCommand extends BaseCommand {
+    static resourceName = "object";
+    static baseFlags = {
+        force: Flags.boolean({
+            description: "Do not ask for confirmation",
+        }),
+    };
+    flags;
+    args;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+    async run() {
+        const resourceName = this.ctor.resourceName;
+        if (!this.flags.force) {
+            const confirmed = await ux.confirm(`Do you really want to delete this ${resourceName}?`);
+            if (!confirmed) {
+                this.log("aborting");
+                ux.exit(1);
+                return;
+            }
+        }
+        ux.action.start(`deleting ${resourceName}`);
+        await this.deleteResource();
+        ux.action.stop();
+    }
+}

package/dist/esm/ExtendedBaseCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { CommandArgs, CommandFlags } from "./types.js";
+export declare abstract class ExtendedBaseCommand<T extends typeof BaseCommand> extends BaseCommand<T> {
+    protected flags: CommandFlags<T>;
+    protected args: CommandArgs<T>;
+    init(): Promise<void>;
+}

package/dist/esm/ExtendedBaseCommand.js

@@ -0,0 +1,16 @@
+import { BaseCommand } from "./BaseCommand.js";
+export class ExtendedBaseCommand extends BaseCommand {
+    flags;
+    args;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+}

package/dist/esm/Flags.d.ts

@@ -0,0 +1 @@
+export declare const mwFlags: {};

package/dist/esm/Flags.js

@@ -0,0 +1 @@
+export const mwFlags = {};

package/dist/esm/Formatter.d.ts

@@ -0,0 +1,15 @@
+import { FlagInput } from "@oclif/core/lib/interfaces/parser.js";
+import { ux } from "@oclif/core";
+export interface GetOptions {
+    outputFormat: string;
+}
+export type ListOptions = ux.Table.table.Options;
+export type ListColumns<TItem extends Record<string, unknown>> = ux.Table.table.Columns<TItem>;
+export declare class GetFormatter {
+    static get flags(): FlagInput;
+    log(output: unknown, opts?: GetOptions): void;
+}
+export declare class ListFormatter {
+    static get flags(): FlagInput;
+    log<T extends Record<string, unknown>>(output: T[], columns: ListColumns<T>, opts?: ListOptions): void;
+}

package/dist/esm/Formatter.js

@@ -0,0 +1,28 @@
+import { ux } from "@oclif/core";
+import { PrinterFactory } from "./Printer.js";
+export class GetFormatter {
+    static get flags() {
+        return {
+            output: {
+                ...ux.table.flags().output,
+                options: ["json", "yaml"],
+            },
+        };
+    }
+    log(output, opts) {
+        PrinterFactory.build(opts?.outputFormat).log(output);
+    }
+}
+export class ListFormatter {
+    static get flags() {
+        return {
+            ...ux.table.flags(),
+        };
+    }
+    log(output, columns, opts) {
+        ux.table(output, columns, {
+            printLine: console.log,
+            ...opts,
+        });
+    }
+}

package/dist/esm/GetBaseCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command, Interfaces } from "@oclif/core";
+import { BaseCommand } from "./BaseCommand.js";
+import { GetFormatter } from "./Formatter.js";
+import { Response } from "@mittwald/api-client-commons";
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof GetBaseCommand)["baseFlags"] & T["flags"]>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T["args"]>;
+export declare abstract class GetBaseCommand<T extends typeof BaseCommand, TAPIResponse extends Response> extends BaseCommand<T> {
+    static baseFlags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    protected formatter: GetFormatter;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected abstract getData(): Promise<TAPIResponse>;
+}

package/dist/esm/GetBaseCommand.js

@@ -0,0 +1,27 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { GetFormatter } from "./Formatter.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+export class GetBaseCommand extends BaseCommand {
+    static baseFlags = {
+        ...GetFormatter.flags,
+    };
+    flags;
+    args;
+    formatter = new GetFormatter();
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+    async run() {
+        const response = await this.getData();
+        assertStatus(response, 200);
+        this.formatter.log(response.data, { outputFormat: this.flags.output });
+    }
+}

package/dist/esm/Helpers.d.ts

@@ -0,0 +1,5 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function isUuid(id: string): boolean;
+export declare function isProjectShortId(id: string): boolean;
+export declare function normalizeProjectIdToUuid(apiClient: MittwaldAPIV2Client, uuidOrShortId: string): Promise<string>;
+export declare function normalizeConversationIdToUuid(apiClient: MittwaldAPIV2Client, uuidOrShortId: string): Promise<string>;

package/dist/esm/Helpers.js

@@ -0,0 +1,24 @@
+import { getConversationUuidFromShortId, getProjectUuidFromShortId, } from "./Translator.js";
+const uuidRegex = RegExp("^[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}$");
+const projectShortIdRegex = RegExp("p-[0-9a-zA-Z]{6}");
+export function isUuid(id) {
+    return uuidRegex.test(id);
+}
+export function isProjectShortId(id) {
+    return projectShortIdRegex.test(id);
+}
+export async function normalizeProjectIdToUuid(apiClient, uuidOrShortId) {
+    if (isUuid(uuidOrShortId)) {
+        return uuidOrShortId;
+    }
+    if (isProjectShortId(uuidOrShortId)) {
+        return await getProjectUuidFromShortId(apiClient, uuidOrShortId);
+    }
+    throw new Error(`Given ID ${uuidOrShortId} does not seem to be valid`);
+}
+export async function normalizeConversationIdToUuid(apiClient, uuidOrShortId) {
+    if (isUuid(uuidOrShortId)) {
+        return uuidOrShortId;
+    }
+    return await getConversationUuidFromShortId(apiClient, uuidOrShortId);
+}

package/dist/esm/ListBaseCommand.d.ts

@@ -0,0 +1,20 @@
+import { Command, Interfaces } from "@oclif/core";
+import { BaseCommand } from "./BaseCommand.js";
+import { ListColumns, ListFormatter } from "./Formatter.js";
+import { Response } from "@mittwald/api-client-commons";
+import { SuccessfulResponse } from "./types.js";
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof ListBaseCommand)["baseFlags"] & T["flags"]>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T["args"]>;
+export declare abstract class ListBaseCommand<T extends typeof BaseCommand, TItem extends Record<string, unknown>, TAPIResponse extends Response> extends BaseCommand<T> {
+    static baseFlags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    protected formatter: ListFormatter;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected abstract getData(): Promise<TAPIResponse>;
+    protected abstract mapData(data: SuccessfulResponse<TAPIResponse, 200>["data"]): TItem[] | Promise<TItem[]>;
+    protected getColumns(data: TItem[]): ListColumns<TItem>;
+}

package/dist/esm/ListBaseCommand.js

@@ -0,0 +1,60 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { ListFormatter } from "./Formatter.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { formatDate } from "./lib/viewhelpers/date.js";
+export class ListBaseCommand extends BaseCommand {
+    static baseFlags = {
+        ...ListFormatter.flags,
+    };
+    flags;
+    args;
+    formatter = new ListFormatter();
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+    async run() {
+        const response = await this.getData();
+        assertStatus(response, 200);
+        const data = await this.mapData(response.data);
+        this.formatter.log(data, this.getColumns(data), { ...this.flags });
+    }
+    getColumns(data) {
+        if (data.length === 0) {
+            return {};
+        }
+        // define some default columns, can be overwritten by child class
+        let columns = {
+            id: {
+                header: "ID",
+                minWidth: 36,
+            },
+        };
+        if ("shortId" in data[0]) {
+            columns = {
+                ...columns,
+                shortId: {
+                    header: "Short ID",
+                    minWidth: 8,
+                },
+            };
+        }
+        if ("createdAt" in data[0]) {
+            columns = {
+                ...columns,
+                createdAt: {
+                    header: "Created at",
+                    get: (row) => formatDate(new Date(`${row.createdAt}`)),
+                },
+            };
+        }
+        return columns;
+    }
+}

package/dist/esm/Printer.d.ts

@@ -0,0 +1,16 @@
+interface Printer {
+    log(content: unknown): void;
+}
+export declare class PrinterFactory {
+    static build(outputFormat: string | undefined): Printer;
+}
+export declare class YamlPrinter implements Printer {
+    log(content: unknown): void;
+}
+export declare class JsonPrinter implements Printer {
+    log(content: unknown): void;
+}
+export declare class DefaultPrinter implements Printer {
+    log(content: unknown): void;
+}
+export {};

package/dist/esm/Printer.js

@@ -0,0 +1,30 @@
+import * as yaml from "js-yaml";
+import { ux, stdout } from "@oclif/core";
+export class PrinterFactory {
+    static build(outputFormat) {
+        switch (outputFormat) {
+            case "yaml":
+                return new YamlPrinter();
+            case "json":
+                return new JsonPrinter();
+            default:
+                return new DefaultPrinter();
+        }
+    }
+}
+export class YamlPrinter {
+    log(content) {
+        stdout.write(yaml.dump(content));
+    }
+}
+export class JsonPrinter {
+    log(content) {
+        ux.styledJSON(content);
+    }
+}
+// csvn't
+export class DefaultPrinter {
+    log(content) {
+        ux.styledObject(content);
+    }
+}

package/dist/esm/Translator.d.ts

@@ -0,0 +1,5 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getProjectUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
+export declare function getConversationUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
+export declare function getAppNameFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<string>;
+export declare function getAppVersionFromUuid(apiClient: MittwaldAPIV2Client, appId: string, appVersionId: string): Promise<string>;

package/dist/esm/Translator.js

@@ -0,0 +1,53 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { isUuid, isProjectShortId } from "./Helpers.js";
+export async function getProjectUuidFromShortId(apiClient, shortId) {
+    if (!isProjectShortId(shortId)) {
+        throw new Error("Given ShortID not valid.");
+    }
+    const projects = await apiClient.project.listProjects();
+    assertStatus(projects, 200);
+    const foundProject = projects.data.find((item) => {
+        return item.shortId === shortId;
+    });
+    if (foundProject) {
+        return foundProject.id;
+    }
+    throw new Error("Access Denied.");
+}
+export async function getConversationUuidFromShortId(apiClient, shortId) {
+    const conversations = await apiClient.conversation.listConversations();
+    assertStatus(conversations, 200);
+    const foundConversation = conversations.data.find((item) => {
+        return item.shortId === shortId;
+    });
+    if (foundConversation) {
+        return foundConversation.conversationId;
+    }
+    throw new Error("Access Denied.");
+}
+export async function getAppNameFromUuid(apiClient, uuid) {
+    if (!isUuid(uuid)) {
+        throw new Error("Given UUID not valid.");
+    }
+    const apps = await apiClient.app.listApps();
+    assertStatus(apps, 200);
+    const foundApp = apps.data.find((item) => {
+        return item.id === uuid;
+    });
+    if (foundApp) {
+        return foundApp.name;
+    }
+    throw new Error("App not found.");
+}
+export async function getAppVersionFromUuid(apiClient, appId, appVersionId) {
+    if (!isUuid(appId) && !isUuid(appVersionId)) {
+        throw new Error("Given UUID not valid.");
+    }
+    const appVersion = await apiClient.app.getAppversion({
+        pathParameters: { appId: appId, appVersionId: appVersionId },
+    });
+    if (appVersion.data.externalVersion) {
+        return appVersion.data.externalVersion;
+    }
+    throw new Error("AppVersion not found.");
+}

package/dist/esm/commands/app/delete.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../BaseCommand.js";
+export default class Delete extends BaseCommand<typeof Delete> {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private confirmDeletion;
+}

package/dist/esm/commands/app/delete.js

@@ -0,0 +1,45 @@
+import { Flags, Args, ux } from "@oclif/core";
+import { BaseCommand } from "../../BaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { isUuid } from "../../Helpers.js";
+export default class Delete extends BaseCommand {
+    static description = "Delete an app";
+    static args = {
+        id: Args.string({
+            required: true,
+            description: "ID of the app to be deleted.",
+        }),
+    };
+    static flags = {
+        force: Flags.boolean({
+            char: "f",
+            description: "delete without prompting for confirmation",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Delete);
+        const { id } = args;
+        if (!isUuid(id)) {
+            throw new Error("AppID does not seem to be valid");
+        }
+        if (!(await this.confirmDeletion(flags.force))) {
+            this.log("aborting.");
+            return;
+        }
+        ux.action.start("deleting app");
+        const project = await this.apiClient.app.uninstallAppinstallation({
+            pathParameters: { appInstallationId: id },
+        });
+        assertStatus(project, 204);
+        ux.action.stop(`deleted app ${id}`);
+    }
+    async confirmDeletion(force) {
+        if (force) {
+            return true;
+        }
+        const promptResult = await ux.prompt("Are you sure you want to delete this app? y/n", {
+            type: "single",
+        });
+        return promptResult === "y";
+    }
+}

package/dist/esm/commands/app/getApp.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedAppGetApp } from "../../generated/app/getApp.js";
+export default class Get extends GeneratedAppGetApp {
+}

package/dist/esm/commands/app/getApp.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { GeneratedAppGetApp } from "../../generated/app/getApp.js";
+export default class Get extends GeneratedAppGetApp {
+}

package/dist/esm/commands/app/getAppinstallation.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedAppGetAppinstallation } from "../../generated/app/getAppinstallation.js";
+export default class Get extends GeneratedAppGetAppinstallation {
+}

package/dist/esm/commands/app/getAppinstallation.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { GeneratedAppGetAppinstallation } from "../../generated/app/getAppinstallation.js";
+export default class Get extends GeneratedAppGetAppinstallation {
+}

package/dist/esm/commands/app/getAppversion.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedAppGetAppversion } from "../../generated/app/getAppversion.js";
+export default class Get extends GeneratedAppGetAppversion {
+}

package/dist/esm/commands/app/getAppversion.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { GeneratedAppGetAppversion } from "../../generated/app/getAppversion.js";
+export default class Get extends GeneratedAppGetAppversion {
+}

package/dist/esm/commands/app/getSystemsoftware.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedAppGetSystemsoftware } from "../../generated/app/getSystemsoftware.js";
+export default class Get extends GeneratedAppGetSystemsoftware {
+}

package/dist/esm/commands/app/getSystemsoftware.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { GeneratedAppGetSystemsoftware } from "../../generated/app/getSystemsoftware.js";
+export default class Get extends GeneratedAppGetSystemsoftware {
+}

package/dist/esm/commands/app/getSystemsoftwareversion.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedAppGetSystemsoftwareversion } from "../../generated/app/getSystemsoftwareversion.js";
+export default class Get extends GeneratedAppGetSystemsoftwareversion {
+}

package/dist/esm/commands/app/getSystemsoftwareversion.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { GeneratedAppGetSystemsoftwareversion } from "../../generated/app/getSystemsoftwareversion.js";
+export default class Get extends GeneratedAppGetSystemsoftwareversion {
+}

package/dist/esm/commands/app/list.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from "../../BaseCommand.js";
+export default class List extends BaseCommand<typeof List> {
+    static description: string;
+    static flags: {
+        project: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        columns: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
+        sort: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
+        filter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
+        csv: import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
+        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
+        extended: import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
+        'no-truncate': import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
+        'no-header': import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
+    };
+    run(): Promise<void>;
+}