@mittwald/cli 1.0.0-alpha.3

package/dist/esm/generated/customer/listCustomers.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listCustomers"]>>;
+export declare abstract class GeneratedCustomerListCustomers<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedCustomerListCustomers, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/customer/listCustomers.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedCustomerListCustomers extends ListBaseCommand {
+    static description = "Get all customer profiles the authenticated user has access to.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.customer.listCustomers({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/customer/listInvitesForCustomer.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2CustomersCustomerIdInvites.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listInvitesForCustomer"]>>;
+export declare abstract class GeneratedCustomerListInvitesForCustomer<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedCustomerListInvitesForCustomer, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "customer-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/customer/listInvitesForCustomer.js

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedCustomerListInvitesForCustomer extends ListBaseCommand {
+    static description = "List all invites for a Customer.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "customer-id": Flags.string({
+            description: "ID of the Customer to list invites for.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            customerId: this.flags["customer-id"],
+        };
+        return await this.apiClient.customer.listInvitesForCustomer({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/customer/listMembershipsForCustomer.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2CustomersCustomerIdMemberships.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listMembershipsForCustomer"]>>;
+export declare abstract class GeneratedCustomerListMembershipsForCustomer<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedCustomerListMembershipsForCustomer, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "customer-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/customer/listMembershipsForCustomer.js

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedCustomerListMembershipsForCustomer extends ListBaseCommand {
+    static description = "List all memberships belonging to a Customer.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "customer-id": Flags.string({
+            description: "Customer to list memberships for.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            customerId: this.flags["customer-id"],
+        };
+        return await this.apiClient.customer.listMembershipsForCustomer({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/customer/listOfCustomerCategories.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2CustomerCategories.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listOfCustomerCategories"]>>;
+export declare abstract class GeneratedCustomerListOfCustomerCategories<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedCustomerListOfCustomerCategories, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/customer/listOfCustomerCategories.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedCustomerListOfCustomerCategories extends ListBaseCommand {
+    static description = "Get all customer categories.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.customer.listOfCustomerCategories({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/getMysqlDatabase.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlDatabasesId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getMysqlDatabase"]>>;
+export declare abstract class GeneratedDatabaseGetMysqlDatabase extends GetBaseCommand<typeof GeneratedDatabaseGetMysqlDatabase, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/database/getMysqlDatabase.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedDatabaseGetMysqlDatabase extends GetBaseCommand {
+    static description = "Get a MySQLDatabase.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        id: Args.string({
+            description: "ID of the MySQLDatabase to be retrieved.",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.database.getMysqlDatabase({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/getMysqlUser.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlUsersId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getMysqlUser"]>>;
+export declare abstract class GeneratedDatabaseGetMysqlUser extends GetBaseCommand<typeof GeneratedDatabaseGetMysqlUser, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/database/getMysqlUser.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedDatabaseGetMysqlUser extends GetBaseCommand {
+    static description = "Get a MySQLUser.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        id: Args.string({
+            description: "ID of the MySQLUser to be retrieved.",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.database.getMysqlUser({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/getMysqlUserPhpMyAdminUrl.d.ts

@@ -0,0 +1,14 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlUsersIdPhpMyAdminUrl.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getMysqlUserPhpMyAdminUrl"]>>;
+export declare abstract class GeneratedDatabaseGetMysqlUserPhpMyAdminUrl extends GetBaseCommand<typeof GeneratedDatabaseGetMysqlUserPhpMyAdminUrl, APIResponse> {
+    static description: string;
+    static flags: {
+        id: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static args: {};
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/database/getMysqlUserPhpMyAdminUrl.js

@@ -0,0 +1,24 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Flags } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedDatabaseGetMysqlUserPhpMyAdminUrl extends GetBaseCommand {
+    static description = "Get a MySQLUser's PhpMyAdmin-URL.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+        id: Flags.string({
+            description: "ID of the MySQLUser for which to get the URL for.",
+            required: true,
+        }),
+    };
+    static args = {};
+    async getData() {
+        return await this.apiClient.database.getMysqlUserPhpMyAdminUrl({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/getRedisDatabase.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2RedisDatabasesId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getRedisDatabase"]>>;
+export declare abstract class GeneratedDatabaseGetRedisDatabase extends GetBaseCommand<typeof GeneratedDatabaseGetRedisDatabase, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/database/getRedisDatabase.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedDatabaseGetRedisDatabase extends GetBaseCommand {
+    static description = "Get a RedisDatabase.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        id: Args.string({
+            description: "ID of the RedisDatabase to retrieve.",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.database.getRedisDatabase({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/listMysqlCharsets.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlCharsets.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlCharsets"]>>;
+export declare abstract class GeneratedDatabaseListMysqlCharsets<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedDatabaseListMysqlCharsets, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/database/listMysqlCharsets.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedDatabaseListMysqlCharsets extends ListBaseCommand {
+    static description = "List available MySQL character sets and collations, optionally filtered by a MySQLVersion.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.database.listMysqlCharsets({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/listMysqlDatabases.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2ProjectsProjectIdMysqlDatabases.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlDatabases"]>>;
+export declare abstract class GeneratedDatabaseListMysqlDatabases<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedDatabaseListMysqlDatabases, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/database/listMysqlDatabases.js

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedDatabaseListMysqlDatabases extends ListBaseCommand {
+    static description = "List MySQLDatabases belonging to a Project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "project-id": Flags.string({
+            description: "ID of the Project to list MySQLDatabases for.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            projectId: this.flags["project-id"],
+        };
+        return await this.apiClient.database.listMysqlDatabases({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/listMysqlUsers.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlDatabasesDatabaseIdUsers.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlUsers"]>>;
+export declare abstract class GeneratedDatabaseListMysqlUsers<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedDatabaseListMysqlUsers, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/database/listMysqlUsers.js

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedDatabaseListMysqlUsers extends ListBaseCommand {
+    static description = "List MySQLUsers belonging to a database.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "database-id": Flags.string({
+            description: "ID of the MySQLDatabase to list Users for.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            databaseId: this.flags["database-id"],
+        };
+        return await this.apiClient.database.listMysqlUsers({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/listMysqlVersions.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlVersions.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlVersions"]>>;
+export declare abstract class GeneratedDatabaseListMysqlVersions<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedDatabaseListMysqlVersions, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/database/listMysqlVersions.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedDatabaseListMysqlVersions extends ListBaseCommand {
+    static description = "List available MySQLVersions.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.database.listMysqlVersions({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/listRedisDatabases.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2ProjectsProjectIdRedisDatabases.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listRedisDatabases"]>>;
+export declare abstract class GeneratedDatabaseListRedisDatabases<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedDatabaseListRedisDatabases, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/database/listRedisDatabases.js

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedDatabaseListRedisDatabases extends ListBaseCommand {
+    static description = "List RedisDatabases belonging to a project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "project-id": Flags.string({
+            description: "ID of the Project to list RedisDatabases for.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            projectId: this.flags["project-id"],
+        };
+        return await this.apiClient.database.listRedisDatabases({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/database/listRedisVersions.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2RedisVersions.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listRedisVersions"]>>;
+export declare abstract class GeneratedDatabaseListRedisVersions<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedDatabaseListRedisVersions, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/database/listRedisVersions.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedDatabaseListRedisVersions extends ListBaseCommand {
+    static description = "List available Redis versions.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.database.listRedisVersions({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/domain/dnsZoneGetSpecific.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2DnsZonesZoneId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["domain"]["dnsZoneGetSpecific"]>>;
+export declare abstract class GeneratedDnsZoneGetSpecific extends GetBaseCommand<typeof GeneratedDnsZoneGetSpecific, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        zoneId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/domain/dnsZoneGetSpecific.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedDnsZoneGetSpecific extends GetBaseCommand {
+    static description = "gets a specific zone";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        zoneId: Args.string({
+            description: "id of the zone you want to get",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.domain.dnsZoneGetSpecific({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/domain/dnsZonesForProject.d.ts

@@ -0,0 +1,14 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2ProjectsProjectIdDnsZones.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["domain"]["dnsZonesForProject"]>>;
+export declare abstract class GeneratedDnsZonesForProject extends GetBaseCommand<typeof GeneratedDnsZonesForProject, APIResponse> {
+    static description: string;
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static args: {};
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/domain/dnsZonesForProject.js

@@ -0,0 +1,24 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Flags } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedDnsZonesForProject extends GetBaseCommand {
+    static description = "gets all dns zones by project id";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+        "project-id": Flags.string({
+            description: "project you want to get the zones for",
+            required: true,
+        }),
+    };
+    static args = {};
+    async getData() {
+        return await this.apiClient.domain.dnsZonesForProject({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/domain/getDomain.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2DomainsDomainId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["domain"]["getDomain"]>>;
+export declare abstract class GeneratedDomainGetDomain extends GetBaseCommand<typeof GeneratedDomainGetDomain, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        domainId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};