@mittwald/cli 1.0.0-alpha.15 → 1.0.0-alpha.17

package/dist/esm/Translator.d.ts

@@ -1,7 +1,9 @@
-import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+import AppApp = MittwaldAPIV2.Components.Schemas.AppApp;
 export declare function getProjectUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
 export declare function getServerUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
 export declare function getCustomerUuidFromCustomerNumber(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>;
+export declare function getAppFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<AppApp>;
+export declare function getAppVersionFromUuid(apiClient: MittwaldAPIV2Client, appId: string, appVersionId: string): Promise<AppAppVersion>;

package/dist/esm/Translator.js

@@ -47,7 +47,7 @@ export async function getConversationUuidFromShortId(apiClient, shortId) {
     }
     throw new Error("Access Denied.");
 }
-export async function getAppNameFromUuid(apiClient, uuid) {
+export async function getAppFromUuid(apiClient, uuid) {
     if (!isUuid(uuid)) {
         throw new Error("Given UUID not valid.");
     }
@@ -57,7 +57,7 @@ export async function getAppNameFromUuid(apiClient, uuid) {
         return item.id === uuid;
     });
     if (foundApp) {
-        return foundApp.name;
+        return foundApp;
     }
     throw new Error("App not found.");
 }
@@ -68,8 +68,6 @@ export async function getAppVersionFromUuid(apiClient, appId, appVersionId) {
     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.");
+    assertStatus(appVersion, 200);
+    return appVersion.data;
 }

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

@@ -0,0 +1,17 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    appInstallationId: string;
+};
+export declare class Copy extends ExecRenderBaseCommand<typeof Copy, Result> {
+    static args: {
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<Result>;
+    protected render(executionResult: Result): ReactNode;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { appInstallationFlags } from "../../lib/app/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../rendering/react/components/Success.js";
+export class Copy extends ExecRenderBaseCommand {
+    static args = { ...appInstallationFlags };
+    static flags = {
+        ...processFlags,
+        description: Flags.string({
+            summary: "set a description for the new app installation",
+            required: true,
+        }),
+    };
+    async exec() {
+        const { "installation-id": id } = this.args;
+        const { description } = this.flags;
+        const p = makeProcessRenderer(this.flags, "Copying app installation");
+        const result = await p.runStep("requesting app copy", async () => {
+            const r = await this.apiClient.app.requestAppinstallationCopy({
+                pathParameters: { id },
+                data: {
+                    description,
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        p.complete(_jsx(Success, { children: "App successfully copied; have fun! \uD83D\uDE80" }));
+        return { appInstallationId: result.id };
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.appInstallationId;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../../types.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { ListColumns } from "../../../Formatter.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2Systemsoftwares.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["app"]["listSystemsoftwares"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.AppSystemSoftware[];
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/esm/commands/app/dependency/list.js

@@ -0,0 +1,27 @@
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+export class List extends ListBaseCommand {
+    static description = "get all available dependencies";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        return await this.apiClient.app.listSystemsoftwares({
+            pathParameters: {},
+        });
+    }
+    mapData(data) {
+        data.sort((a, b) => a.tags[0].localeCompare(b.tags[0]) || a.name.localeCompare(b.name));
+        return data;
+    }
+    getColumns(data) {
+        const baseColumns = super.getColumns(data);
+        return {
+            id: baseColumns.id,
+            name: {},
+            tags: {
+                get: (item) => item.tags.join(", "),
+            },
+        };
+    }
+}

package/dist/esm/commands/app/dependency/update.d.ts

@@ -0,0 +1,20 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export default class Update extends ExecRenderBaseCommand<typeof Update, void> {
+    static summary: string;
+    static args: {
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        set: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "update-policy": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    private getVersions;
+    protected render(): ReactNode;
+}

package/dist/esm/commands/app/dependency/update.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { appInstallationFlags } from "../../../lib/app/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Range, SemVer } from "semver";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { Text } from "ink";
+export default class Update extends ExecRenderBaseCommand {
+    static summary = "Update the dependencies of an app";
+    static args = { ...appInstallationFlags };
+    static examples = [
+        {
+            description: "Update Node.js version to newest available from the 18.x branch",
+            command: "<%= config.bin %> <%= command.id %> $APP_ID --set node=~18",
+        },
+    ];
+    static flags = {
+        ...processFlags,
+        set: Flags.string({
+            summary: "set a dependency to a specific version",
+            description: `\
+        The format is <dependency>=<version>, where <dependency> is the name of the dependency (use the "<%= config.bin %> app dependency list" command to get a list of available dependencies) and <version> is a semver constraint.
+
+        This flag may be specified multiple times to update multiple dependencies.`,
+            multiple: true,
+            required: true,
+        }),
+        "update-policy": Flags.string({
+            summary: "set the update policy for the configured dependencies",
+            default: "patchLevel",
+            options: ["none", "inheritedFromApp", "patchLevel", "all"],
+        }),
+    };
+    async exec() {
+        const appInstallationId = this.args["installation-id"];
+        const updatePolicy = this.flags["update-policy"];
+        const process = makeProcessRenderer(this.flags, "Updating app dependencies");
+        const systemSoftwares = await process.runStep("fetching system softwares", async () => {
+            const r = await this.apiClient.app.listSystemsoftwares();
+            assertStatus(r, 200);
+            return r.data;
+        });
+        const versionsToUpdate = {};
+        for (const s of this.flags.set) {
+            const [software, versionSpec] = s.split("=");
+            const parsedVersionSpec = new Range(versionSpec);
+            if (!parsedVersionSpec) {
+                throw new Error(`version spec ${versionSpec} is not a valid semver constraint`);
+            }
+            const systemSoftware = systemSoftwares.find((s) => s.name.toLowerCase() === software.toLowerCase());
+            if (!systemSoftware) {
+                throw new Error(`unknown system software ${software}`);
+            }
+            const versions = await this.getVersions(process, systemSoftware);
+            const version = await process.runStep(`determining version for ${software}`, async () => {
+                const exactMatch = versions.find((v) => v.externalVersion === versionSpec);
+                if (exactMatch) {
+                    return exactMatch;
+                }
+                const version = versions.find((v) => parsedVersionSpec.test(v.externalVersion));
+                if (!version) {
+                    const available = versions.map((v) => v.externalVersion).join(", ");
+                    throw new Error(`unknown version ${versionSpec} for ${software}; available versions are: ${available}`);
+                }
+                return version;
+            });
+            process.addInfo(_jsxs(Text, { children: ["selected ", _jsx(Value, { children: systemSoftware.name }), " version:", " ", _jsx(Value, { children: version.externalVersion })] }));
+            versionsToUpdate[systemSoftware.id] = {
+                systemSoftwareVersion: version.id,
+                updatePolicy,
+            };
+        }
+        await process.runStep("updating app dependencies", async () => {
+            const r = await this.apiClient.app.patchAppinstallation({
+                pathParameters: { appInstallationId },
+                data: {
+                    systemSoftware: versionsToUpdate,
+                },
+            });
+            assertStatus(r, 204);
+        });
+        process.complete(_jsx(Success, { children: "The dependencies of this app were successfully updated!" }));
+    }
+    async getVersions(p, systemSoftware) {
+        const versions = await p.runStep(`fetching versions for ${systemSoftware.name}`, async () => {
+            const r = await this.apiClient.app.listSystemsoftwareversions({
+                pathParameters: { systemSoftwareId: systemSoftware.id },
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        versions.sort((a, b) => {
+            return (new SemVer(a.externalVersion).compare(new SemVer(b.externalVersion)) *
+                -1);
+        });
+        return versions;
+    }
+    render() {
+        return undefined;
+    }
+}

package/dist/esm/commands/app/dependency/versions.d.ts

@@ -0,0 +1,20 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { SuccessfulResponse } from "../../../types.js";
+import { ListColumns } from "../../../Formatter.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2SystemsoftwareSystemSoftwareIdVersions.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["app"]["listSystemsoftwareversions"]>>;
+export declare class Versions extends ListBaseCommand<typeof Versions, ResponseItem, Response> {
+    static description: string;
+    static args: {
+        systemsoftware: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.AppSystemSoftwareVersion[];
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/esm/commands/app/dependency/versions.js

@@ -0,0 +1,39 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { SemVer } from "semver";
+import { Args } from "@oclif/core";
+export class Versions extends ListBaseCommand {
+    static description = "get all available versions of a particular dependency";
+    static args = {
+        systemsoftware: Args.string({
+            description: "name of the systemsoftware for which to list versions",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const systemSoftwareName = this.args["systemsoftware"];
+        const systemSoftwares = await this.apiClient.app.listSystemsoftwares({});
+        assertStatus(systemSoftwares, 200);
+        const systemSoftware = systemSoftwares.data.find((s) => s.name.toLowerCase() === systemSoftwareName.toLowerCase());
+        if (!systemSoftware) {
+            throw new Error(`system software ${systemSoftwareName} not found`);
+        }
+        return await this.apiClient.app.listSystemsoftwareversions({
+            pathParameters: { systemSoftwareId: systemSoftware.id },
+        });
+    }
+    mapData(data) {
+        data.sort((a, b) => new SemVer(a.externalVersion).compare(b.externalVersion));
+        return data;
+    }
+    getColumns(data) {
+        const baseColumns = super.getColumns(data);
+        return {
+            id: baseColumns.id,
+            externalVersion: { header: "Version" },
+        };
+    }
+}

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

@@ -1,3 +1,12 @@
-import { GeneratedAppGetAppinstallation } from "../../generated/app/getAppinstallation.js";
-export default class Get extends GeneratedAppGetAppinstallation {
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export default class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected render(): ReactNode;
 }

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

@@ -1,6 +1,20 @@
-/* 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 {
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+import { AppInstallationDetails } from "../../rendering/react/components/AppInstallation/AppInstallationDetails.js";
+import { useApp, useAppInstallation } from "../../lib/app/hooks.js";
+import { appInstallationFlags } from "../../lib/app/flags.js";
+export default class Get extends RenderBaseCommand {
+    static description = "Get details about an app installation";
+    static flags = { ...GetBaseCommand.baseFlags };
+    static args = { ...appInstallationFlags };
+    render() {
+        const appInstallation = useAppInstallation(this.args["installation-id"]);
+        const app = useApp(appInstallation.appId);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "appInstallation", data: appInstallation });
+        }
+        return (_jsx(AppInstallationDetails, { appInstallation: appInstallation, app: app }));
+    }
 }

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

@@ -1,15 +1,24 @@
-import { BaseCommand } from "../../BaseCommand.js";
-export default class List extends BaseCommand {
+import { Simplify } from "@mittwald/api-client-commons";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../types.js";
+import { ListColumns } from "../../Formatter.js";
+import AppApp = MittwaldAPIV2.Components.Schemas.AppApp;
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdAppinstallations.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["app"]["listAppinstallations"]>>;
+type ExtendedResponseItem = ResponseItem & {
+    app: AppApp;
+    appVersionCurrent: AppAppVersion | undefined;
+    appVersionDesired: AppAppVersion;
+};
+export default class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
     static description: string;
     static flags: {
-        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>;
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any> | import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
     };
-    run(): Promise<void>;
+    protected getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): Promise<ExtendedResponseItem[]>;
+    protected getColumns(): ListColumns<ExtendedResponseItem>;
 }
+export {};

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

@@ -1,58 +1,72 @@
-import { ux } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
-import { BaseCommand } from "../../BaseCommand.js";
-import { getAppNameFromUuid, getAppVersionFromUuid } from "../../Translator.js";
+import { getAppFromUuid, getAppVersionFromUuid } from "../../Translator.js";
 import { projectFlags, withProjectId } from "../../lib/project/flags.js";
-export default class List extends BaseCommand {
-    static description = "List projects";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export default class List extends ListBaseCommand {
+    static description = "List installed apps in a project.";
     static flags = {
-        ...ux.table.flags(),
+        ...ListBaseCommand.baseFlags,
         ...projectFlags,
     };
-    async run() {
-        const { flags } = await this.parse(List);
-        const projectId = await withProjectId(this.apiClient, flags, {}, this.config);
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, this.flags, this.args, this.config);
         const apps = await this.apiClient.app.listAppinstallations({
             pathParameters: { projectId },
         });
         assertStatus(apps, 200);
-        if (flags.json) {
-            this.logJson(apps.data);
-            return;
-        }
-        const relevantAppInfo = await Promise.all(apps.data.map(async (app) => {
+        return apps;
+    }
+    mapData(data) {
+        return Promise.all(data.map(async (item) => {
             return {
-                id: app.id,
-                description: app.description,
-                app: await getAppNameFromUuid(this.apiClient, app.appId),
-                appVersion: await getAppVersionFromUuid(this.apiClient, app.appId, app.appVersion.current),
-                installPath: app.installationPath,
+                ...item,
+                app: await getAppFromUuid(this.apiClient, item.appId),
+                appVersionCurrent: item.appVersion.current
+                    ? await getAppVersionFromUuid(this.apiClient, item.appId, item.appVersion.current)
+                    : undefined,
+                appVersionDesired: await getAppVersionFromUuid(this.apiClient, item.appId, item.appVersion.desired),
             };
         }));
-        ux.table(relevantAppInfo, {
+    }
+    getColumns() {
+        return {
             id: {
                 header: "ID",
                 minWidth: 36,
             },
-            description: {
-                header: "Description",
-                minWidth: 36,
-            },
+            description: {},
             app: {
                 header: "Application",
                 minWidth: 8,
+                get: (i) => i.app.name,
             },
             appVersion: {
                 header: "Version",
-                minWidth: 8,
+                get: (i) => {
+                    if (i.appVersionCurrent?.id === i.appVersionDesired.id) {
+                        return i.appVersionDesired.externalVersion;
+                    }
+                    if (!i.appVersionCurrent) {
+                        return i.appVersionDesired.externalVersion;
+                    }
+                    return `${i.appVersionCurrent.externalVersion} => ${i.appVersionDesired.externalVersion}`;
+                },
             },
-            installPath: {
-                header: "InstallDir",
-                minWidth: 12,
+            status: {
+                header: "Status",
+                get: (i) => {
+                    if (i.appVersionCurrent?.id === i.appVersionDesired.id) {
+                        return "up-to-date";
+                    }
+                    if (!i.appVersionCurrent) {
+                        return "installing";
+                    }
+                    return "updating";
+                },
             },
-        }, {
-            printLine: this.log.bind(this),
-            ...flags,
-        });
+            installationPath: {
+                header: "Installed in",
+            },
+        };
     }
 }

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

@@ -0,0 +1,9 @@
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+export default class Uninstall extends DeleteBaseCommand<typeof Uninstall> {
+    static description: string;
+    static resourceName: string;
+    static args: {
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected deleteResource(): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+import { Args } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+export default class Uninstall extends DeleteBaseCommand {
+    static description = "Uninstall an app";
+    static resourceName = "app installation";
+    static args = {
+        "installation-id": Args.string({
+            description: "ID of the app installation to delete",
+            required: true,
+        }),
+    };
+    async deleteResource() {
+        const appInstallationId = this.args["installation-id"];
+        const response = await this.apiClient.app.uninstallAppinstallation({
+            pathParameters: { appInstallationId },
+        });
+        assertStatus(response, 204);
+    }
+}

package/dist/esm/commands/database/redis/create.d.ts

@@ -0,0 +1,19 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    databaseId: string;
+};
+export declare class Create extends ExecRenderBaseCommand<typeof Create, Result> {
+    static summary: string;
+    static flags: {
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        persistent: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "max-memory": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "max-memory-policy": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ databaseId }: Result): ReactNode;
+}
+export {};