@mittwald/cli 1.0.0-alpha.9 → 1.0.0-beta.2

package/dist/commands/backup/create.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { Flags } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../rendering/react/components/Success.js";
+import { waitFlags, waitUntil } from "../../lib/wait.js";
+import { Text } from "ink";
+import { expireFlags } from "../../lib/flags/expireFlags.js";
+export class Create extends ExecRenderBaseCommand {
+    static summary = "Create a new backup of a project";
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        description: Flags.string({
+            description: "a description for the backup.",
+        }),
+        ...expireFlags("backup", true),
+        ...waitFlags,
+    };
+    static aliases = ["project:backup:create"];
+    static deprecateAliases = true;
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Creating backup");
+        const projectId = await this.withProjectId(Create);
+        const { description, expires } = this.flags;
+        const backup = await p.runStep("creating backup", async () => {
+            const r = await this.apiClient.backup.createProjectBackup({
+                projectId,
+                data: {
+                    description,
+                    expirationTime: expires.toJSON(),
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        if (this.flags.wait) {
+            const stepWaiting = p.addStep(_jsx(Text, { children: "waiting for backup to be complete" }));
+            await waitUntil(async () => {
+                const backupResponse = await this.apiClient.backup.getProjectBackup({
+                    projectBackupId: backup.id,
+                });
+                if (backupResponse.status === 200 &&
+                    backupResponse.data.status === "Completed") {
+                    return true;
+                }
+            }, this.flags["wait-timeout"]);
+            stepWaiting.complete();
+        }
+        p.complete(_jsx(Success, { children: "Backup successfully created." }));
+        return { backupId: backup.id };
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.backupId;
+        }
+    }
+}

package/dist/commands/backup/delete.d.ts

@@ -0,0 +1,15 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+export declare class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "backup-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected deleteResource(): Promise<void>;
+}

package/dist/commands/backup/delete.js

@@ -0,0 +1,18 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { backupArgs, withBackupId } from "../../lib/resources/backup/flags.js";
+export class Delete extends DeleteBaseCommand {
+    static description = "Delete a backup";
+    static resourceName = "backup";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = { ...backupArgs };
+    static aliases = ["project:backup:delete"];
+    static deprecateAliases = true;
+    async deleteResource() {
+        const projectBackupId = await withBackupId(this.apiClient, Delete, this.flags, this.args, this.config);
+        const response = await this.apiClient.backup.deleteProjectBackup({
+            projectBackupId,
+        });
+        assertStatus(response, 204);
+    }
+}

package/dist/commands/backup/download.d.ts

@@ -0,0 +1,29 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import { AxiosResponseHeaders, RawAxiosResponseHeaders } from "@mittwald/api-client-commons";
+type Result = {
+    outputFilename: string;
+};
+export declare class Download extends ExecRenderBaseCommand<typeof Download, Result> {
+    static description: string;
+    static args: {
+        "backup-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<"tar" | "zip", import("@oclif/core/interfaces").CustomOptions>;
+        password: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "generate-password": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "prompt-password": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        resume: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected getPassword(p: ProcessRenderer): Promise<string | undefined>;
+    protected exec(): Promise<Result>;
+    protected getFilename(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): string;
+    protected render(executionResult: Result): ReactNode;
+}
+export {};

package/dist/commands/backup/download.js

@@ -0,0 +1,174 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import crypto from "crypto";
+import { Text } from "ink";
+import { Value } from "../../rendering/react/components/Value.js";
+import { assertStatus, } from "@mittwald/api-client-commons";
+import { waitUntil } from "../../lib/wait.js";
+import axios from "axios";
+import * as fs from "fs";
+import { Success } from "../../rendering/react/components/Success.js";
+import ByteQuantity from "../../lib/units/ByteQuantity.js";
+import Duration from "../../lib/units/Duration.js";
+import { backupArgs, withBackupId } from "../../lib/resources/backup/flags.js";
+export class Download extends ExecRenderBaseCommand {
+    static description = "Download a backup to your local disk";
+    static args = { ...backupArgs };
+    static flags = {
+        ...processFlags,
+        output: Flags.string({
+            description: "the file to write the backup to; if omitted, the filename will be determined by the server.",
+        }),
+        format: Flags.custom({
+            description: "the file format to download the backup in.",
+            options: ["tar", "zip"],
+            default: "tar",
+        })(),
+        password: Flags.string({
+            summary: "the password to encrypt the backup with.",
+            description: `\
+        CAUTION #1: this is not stored anywhere.
+        CAUTION #2: it is dangerous to use this option, as the password might be stored in your shell history.`,
+            exclusive: ["generate-password", "prompt-password"],
+        }),
+        "generate-password": Flags.boolean({
+            summary: "generate a random password to encrypt the backup with.",
+            description: "CAUTION: this is not stored anywhere.",
+            exclusive: ["password", "prompt-password"],
+        }),
+        "prompt-password": Flags.boolean({
+            summary: "prompt for a password to encrypt the backup with.",
+            description: "CAUTION: this is not stored anywhere.",
+            exclusive: ["password", "generate-password"],
+        }),
+        resume: Flags.boolean({
+            summary: "resume a previously interrupted download.",
+            dependsOn: ["output"],
+        }),
+    };
+    static aliases = ["project:backup:download"];
+    static deprecateAliases = true;
+    async getPassword(p) {
+        if (this.flags.password) {
+            return this.flags.password;
+        }
+        if (this.flags["generate-password"]) {
+            const password = await p.runStep("generating password", async () => {
+                return crypto.randomBytes(32).toString("ascii").substring(0, 32);
+            });
+            p.addInfo(_jsxs(Text, { children: ["generated password: ", _jsx(Value, { children: password })] }));
+            return password;
+        }
+        if (this.flags["prompt-password"]) {
+            return await p.addInput(_jsx(Text, { children: "enter backup password" }), true);
+        }
+        return undefined;
+    }
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Downloading backup");
+        const projectBackupId = await withBackupId(this.apiClient, Download, this.flags, this.args, this.config);
+        const { format } = this.flags;
+        const password = await this.getPassword(p);
+        const backup = await p.runStep("fetching backup", async () => {
+            const r = await this.apiClient.backup.getProjectBackup({
+                projectBackupId,
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        if (backup.export && backup.export.phase !== "Expired") {
+            p.addInfo(_jsx(Text, { children: "backup download is already prepared" }));
+        }
+        else {
+            await p.runStep("preparing backup download", async () => {
+                const r = await this.apiClient.backup.createProjectBackupExport({
+                    projectBackupId,
+                    data: {
+                        format,
+                        password,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        const backupExport = await p.runStep("waiting for backup download to be ready", () => {
+            return waitUntil(async () => {
+                const r = await this.apiClient.backup.getProjectBackup({
+                    projectBackupId,
+                });
+                assertStatus(r, 200);
+                if (r.data.export?.phase === "Completed") {
+                    return r.data.export;
+                }
+                return null;
+            }, Duration.fromString("1h"));
+        });
+        if (!backupExport.downloadURL) {
+            throw new Error("backup download is not ready");
+        }
+        const reqConfig = { responseType: "stream" };
+        if (this.flags.resume &&
+            this.flags.output &&
+            fs.existsSync(this.flags.output)) {
+            const stat = fs.statSync(this.flags.output);
+            const range = `bytes=${stat.size}-`;
+            reqConfig.headers = { Range: range };
+            p.addInfo(_jsxs(Text, { children: ["resuming download starting at ", _jsx(Value, { children: stat.size }), " bytes"] }));
+        }
+        const downloadStep = p.addStep("downloading backup");
+        const resp = await axios(backupExport.downloadURL, reqConfig);
+        const size = ByteQuantity.fromBytes(parseInt(resp.headers["content-length"] || "0", 10));
+        let downloaded = ByteQuantity.fromBytes(0);
+        const outputFilename = this.getFilename(resp.headers);
+        const outputStream = fs.createWriteStream(outputFilename, {
+            flags: this.flags.resume ? "a" : undefined,
+        });
+        const byteFormattingOpts = {
+            maximumFractionDigits: 2,
+            minimumFractionDigits: 2,
+        };
+        resp.data.on("data", (chunk) => {
+            downloaded = downloaded.add(ByteQuantity.fromBytes(chunk.length));
+            downloadStep.progress(downloaded.format(byteFormattingOpts) +
+                " of " +
+                size.format(byteFormattingOpts));
+            outputStream.write(chunk);
+        });
+        await new Promise((res) => {
+            resp.data.on("end", () => {
+                downloadStep.complete();
+                res();
+            });
+            resp.data.on("error", (err) => {
+                downloadStep.error(err);
+                res();
+            });
+        });
+        p.complete(_jsxs(Success, { children: ["The backup was successfully downloaded to", " ", _jsx(Value, { children: outputFilename })] }));
+        return { outputFilename };
+    }
+    getFilename(headers) {
+        if (this.flags.output) {
+            return this.flags.output;
+        }
+        const disposition = headers["content-disposition"];
+        if (disposition) {
+            const match = disposition.match(/filename=("?)(.*)\1/);
+            if (match) {
+                return match[2];
+            }
+        }
+        if (this.flags.format === "tar") {
+            return "backup.tar.gz";
+        }
+        return "backup.zip";
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.outputFilename;
+        }
+        return undefined;
+    }
+}

package/dist/commands/backup/get.d.ts

@@ -0,0 +1,14 @@
+import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export default class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static args: {
+        "backup-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        [x: string]: import("@oclif/core/interfaces").Flag<any>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected render(): ReactNode;
+}

package/dist/commands/backup/get.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
+import { useProjectBackup } from "../../lib/resources/projectbackup/hooks.js";
+import { ProjectBackupDetails } from "../../rendering/react/components/ProjectBackup/ProjectBackupDetails.js";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { GetBaseCommand } from "../../lib/basecommands/GetBaseCommand.js";
+import { Box } from "ink";
+import { backupArgs, withBackupId } from "../../lib/resources/backup/flags.js";
+import { usePromise } from "@mittwald/react-use-promise";
+export default class Get extends RenderBaseCommand {
+    static description = "Show details of a backup.";
+    static args = { ...backupArgs };
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static aliases = ["project:backup:get"];
+    static deprecateAliases = true;
+    render() {
+        const backupId = usePromise(() => withBackupId(this.apiClient, Get, this.flags, this.args, this.config), []);
+        const projectBackup = useProjectBackup(backupId);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "projectBackup", data: projectBackup });
+        }
+        return (_jsx(Box, { marginBottom: 1, children: _jsx(ProjectBackupDetails, { projectBackup: projectBackup }) }));
+    }
+}

package/dist/commands/backup/list.d.ts

@@ -0,0 +1,25 @@
+import { Response, Simplify } from "@mittwald/api-client-commons";
+import { type MittwaldAPIV2 } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { ListColumns } from "../../rendering/formatter/ListFormatter.js";
+type BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+type ListResponse = Response<BackupProjectBackup[]>;
+type ListItem = Simplify<BackupProjectBackup>;
+export declare class List extends ListBaseCommand<typeof List, ListItem, ListResponse> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    getData(): Promise<ListResponse>;
+    protected getColumns(data: ListItem[]): ListColumns<ListItem>;
+}
+export {};

package/dist/commands/backup/list.js

@@ -0,0 +1,36 @@
+import { assertStatus } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import ListDateColumnFormatter from "../../rendering/formatter/ListDateColumnFormatter.js";
+export class List extends ListBaseCommand {
+    static description = "List Backups for a given Project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    static aliases = ["project:backup:list"];
+    static deprecateAliases = true;
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        const response = await this.apiClient.backup.listProjectBackups({
+            projectId,
+        });
+        assertStatus(response, 200);
+        return response;
+    }
+    getColumns(data) {
+        const { id, createdAt } = super.getColumns(data);
+        const dateColumnBuilder = new ListDateColumnFormatter(this.flags);
+        return {
+            id,
+            status: {},
+            createdAt,
+            expiresIn: dateColumnBuilder.buildColumn({
+                header: "Expires in",
+                column: "expiresAt",
+                fallback: "never",
+            }),
+        };
+    }
+}

package/dist/commands/backup/schedule/create.d.ts

@@ -0,0 +1,18 @@
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    projectBackupScheduleId: string;
+};
+export declare class Create extends ExecRenderBaseCommand<typeof Create, Result> {
+    static summary: string;
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        schedule: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        ttl: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ projectBackupScheduleId }: Result): ReactNode;
+}
+export {};

package/dist/commands/backup/schedule/create.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { projectFlags } from "../../../lib/resources/project/flags.js";
+import { backupScheduleFlagDefinitions } from "../../../lib/resources/backup/schedule/flags.js";
+export class Create extends ExecRenderBaseCommand {
+    static summary = "Create a new backup schedule";
+    static flags = {
+        ...projectFlags,
+        ...processFlags,
+        description: backupScheduleFlagDefinitions.description(),
+        schedule: backupScheduleFlagDefinitions.schedule({ required: true }),
+        ttl: backupScheduleFlagDefinitions.ttl({ required: true }),
+    };
+    async exec() {
+        const process = makeProcessRenderer(this.flags, "Creating a new backup schedule");
+        const projectId = await this.withProjectId(Create);
+        const { description, schedule, ttl } = this.flags;
+        const backupScheduleCreationPayload = {
+            schedule,
+            ttl,
+        };
+        if (description) {
+            backupScheduleCreationPayload.description = description;
+        }
+        const { id: projectBackupScheduleId } = await process.runStep("creating backup schedule", async () => {
+            const r = await this.apiClient.backup.createProjectBackupSchedule({
+                projectId,
+                data: backupScheduleCreationPayload,
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        const projectBackupSchedule = await process.runStep("checking newly created backup schedule", async () => {
+            const r = await this.apiClient.backup.getProjectBackupSchedule({
+                projectBackupScheduleId,
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        if (description) {
+            await process.complete(_jsxs(Success, { children: ["The backup schedule \"", _jsx(Value, { children: projectBackupSchedule.description }), "\" was successfully created."] }));
+        }
+        else {
+            await process.complete(_jsx(Success, { children: "The backup schedule was successfully created." }));
+        }
+        return { projectBackupScheduleId };
+    }
+    render({ projectBackupScheduleId }) {
+        if (this.flags.quiet) {
+            return projectBackupScheduleId;
+        }
+    }
+}

package/dist/commands/backup/schedule/delete.d.ts

@@ -0,0 +1,12 @@
+import { DeleteBaseCommand } from "../../../lib/basecommands/DeleteBaseCommand.js";
+export declare class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static args: {
+        "backup-schedule-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected deleteResource(): Promise<void>;
+}

package/dist/commands/backup/schedule/delete.js

@@ -0,0 +1,32 @@
+import { DeleteBaseCommand } from "../../../lib/basecommands/DeleteBaseCommand.js";
+import assertSuccess from "../../../lib/apiutil/assert_success.js";
+import { Args } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+export class Delete extends DeleteBaseCommand {
+    static description = "Delete a backup schedule";
+    static resourceName = "backupSchedule";
+    static args = {
+        "backup-schedule-id": Args.string({
+            description: "ID of schedule to delete",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...processFlags,
+    };
+    async deleteResource() {
+        const process = makeProcessRenderer(this.flags, "Deleting backup schedule");
+        const projectBackupScheduleId = this.args["backup-schedule-id"];
+        const currentBackupSchedule = await this.apiClient.backup.getProjectBackupSchedule({
+            projectBackupScheduleId,
+        });
+        if (currentBackupSchedule.data.isSystemBackup) {
+            await process.error("The system backup created through this schedule is reserved to restore your project in an emergency. " +
+                "It can not be deleted.");
+        }
+        const response = await this.apiClient.backup.deleteProjectBackupSchedule({
+            projectBackupScheduleId,
+        });
+        assertSuccess(response);
+    }
+}

package/dist/commands/backup/schedule/list.d.ts

@@ -0,0 +1,25 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListColumns } from "../../../rendering/formatter/ListFormatter.js";
+import { ListBaseCommand } from "../../../lib/basecommands/ListBaseCommand.js";
+type BackupProjectBackupSchedule = MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule;
+type ResponseItem = Simplify<BackupProjectBackupSchedule>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["backup"]["listProjectBackupSchedules"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    getData(): Promise<Response>;
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/backup/schedule/list.js

@@ -0,0 +1,28 @@
+import { ListBaseCommand } from "../../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags, withProjectId, } from "../../../lib/resources/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List backup schedules belonging to a given project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    static aliases = ["project:backupschedule:list"];
+    static deprecateAliases = true;
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, List, this.flags, this.args, this.config);
+        return await this.apiClient.backup.listProjectBackupSchedules({
+            projectId,
+        });
+    }
+    getColumns(data) {
+        const { id, createdAt } = super.getColumns(data);
+        return {
+            id,
+            isSystemBackup: { header: "System backup" },
+            schedule: {},
+            ttl: { header: "TTL" },
+            createdAt,
+        };
+    }
+}

package/dist/commands/backup/schedule/update.d.ts

@@ -0,0 +1,18 @@
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type UpdateResult = void;
+export default class Update extends ExecRenderBaseCommand<typeof Update, UpdateResult> {
+    static description: string;
+    static args: {
+        "backup-schedule-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        schedule: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ttl: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+}
+export {};