@mittwald/cli 1.0.0-alpha.36 → 1.0.0-alpha.37

package/dist/lib/ddev/config_builder.js

@@ -0,0 +1,124 @@
+import { assertStatus } from "@mittwald/api-client";
+import { typo3Installer } from "../../commands/app/install/typo3.js";
+import { wordpressInstaller } from "../../commands/app/install/wordpress.js";
+import { shopware6Installer } from "../../commands/app/install/shopware6.js";
+import { drupalInstaller } from "../../commands/app/install/drupal.js";
+export class DDEVConfigBuilder {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async build(appInstallationId, type) {
+        const appInstallation = await this.getAppInstallation(appInstallationId);
+        const systemSoftwares = await this.buildSystemSoftwareVersionMap(appInstallation);
+        return {
+            override_config: true,
+            type: await this.determineProjectType(appInstallation, type),
+            webserver_type: "apache-fpm",
+            php_version: this.determinePHPVersion(systemSoftwares),
+            database: await this.determineDatabaseVersion(appInstallation),
+            docroot: await this.determineDocumentRoot(appInstallation),
+            web_environment: [
+                `MITTWALD_APP_INSTALLATION_ID=${appInstallation.shortId}`,
+            ],
+        };
+    }
+    async determineDocumentRoot(inst) {
+        const appVersion = await this.getAppVersion(inst.appId, inst.appVersion.desired);
+        if (appVersion.docRootUserEditable && hasCustomDocumentRoot(inst)) {
+            return stripLeadingSlash(inst.customDocumentRoot);
+        }
+        return stripLeadingSlash(appVersion.docRoot);
+    }
+    async determineProjectType(inst, type) {
+        if (type !== "auto") {
+            return type;
+        }
+        switch (inst.appId) {
+            case typo3Installer.appId:
+                return "typo3";
+            case wordpressInstaller.appId:
+                return "wordpress";
+            case shopware6Installer.appId:
+                return "shopware6";
+            case drupalInstaller.appId: {
+                const version = await this.getAppVersion(inst.appId, inst.appVersion.desired);
+                const [major] = version.externalVersion.split(".");
+                return `drupal${major}`;
+            }
+            default:
+                throw new Error("Automatic project type detection failed. Please specify the project type manually by setting the `--override-type` flag.");
+        }
+    }
+    async determineDatabaseVersion(inst) {
+        const isPrimary = (db) => db.purpose === "primary";
+        const primary = (inst.linkedDatabases || []).find(isPrimary);
+        if (primary?.kind === "mysql") {
+            const r = await this.apiClient.database.getMysqlDatabase({
+                mysqlDatabaseId: primary.databaseId,
+            });
+            assertStatus(r, 200);
+            return {
+                type: "mysql",
+                version: r.data.version,
+            };
+        }
+        return undefined;
+    }
+    determinePHPVersion(systemSoftwareVersions) {
+        if (!("php" in systemSoftwareVersions)) {
+            return undefined;
+        }
+        const version = systemSoftwareVersions["php"];
+        return stripPatchLevelVersion(version);
+    }
+    async buildSystemSoftwareVersionMap(inst) {
+        const versionMap = {};
+        for (const { systemSoftwareId, systemSoftwareVersion, } of inst.systemSoftware || []) {
+            const { name } = await this.getSystemSoftware(systemSoftwareId);
+            const { externalVersion } = await this.getSystemSoftwareVersion(systemSoftwareId, systemSoftwareVersion.desired);
+            versionMap[name] = externalVersion;
+        }
+        return versionMap;
+    }
+    async getSystemSoftware(systemSoftwareId) {
+        const systemSoftwareResponse = await this.apiClient.app.getSystemsoftware({
+            systemSoftwareId,
+        });
+        assertStatus(systemSoftwareResponse, 200);
+        return systemSoftwareResponse.data;
+    }
+    async getSystemSoftwareVersion(systemSoftwareId, systemSoftwareVersionId) {
+        const r = await this.apiClient.app.getSystemsoftwareversion({
+            systemSoftwareId,
+            systemSoftwareVersionId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    }
+    async getAppVersion(appId, appVersionId) {
+        const r = await this.apiClient.app.getAppversion({
+            appId,
+            appVersionId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    }
+    async getAppInstallation(appInstallationId) {
+        const r = await this.apiClient.app.getAppinstallation({
+            appInstallationId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    }
+}
+function hasCustomDocumentRoot(inst) {
+    return inst.customDocumentRoot !== undefined;
+}
+function stripLeadingSlash(input) {
+    return input.replace(/^\//, "");
+}
+function stripPatchLevelVersion(version) {
+    const [major, minor] = version.split(".");
+    return `${major}.${minor}`;
+}

package/dist/lib/ddev/config_loader.d.ts

@@ -0,0 +1,2 @@
+import { DDEVConfig } from "./config.js";
+export declare function loadDDEVConfig(baseDir?: string): Promise<Partial<DDEVConfig> | undefined>;

package/dist/lib/ddev/config_loader.js

@@ -0,0 +1,13 @@
+import { readFile } from "fs/promises";
+import { pathExists } from "../fsutil.js";
+import { load } from "js-yaml";
+import { cwd } from "process";
+import path from "path";
+export async function loadDDEVConfig(baseDir = cwd()) {
+    const configPath = path.join(baseDir, ".ddev", "config.yaml");
+    if (!(await pathExists(configPath))) {
+        return undefined;
+    }
+    const existing = await readFile(".ddev/config.yaml", "utf-8");
+    return load(existing);
+}

package/dist/lib/ddev/config_render.d.ts

@@ -0,0 +1,2 @@
+import { DDEVConfig } from "./config.js";
+export declare function renderDDEVConfig(appInstallationId: string, cfg: Partial<DDEVConfig>): string;

package/dist/lib/ddev/config_render.js

@@ -0,0 +1,6 @@
+import yaml from "js-yaml";
+export function renderDDEVConfig(appInstallationId, cfg) {
+    return `# DDEV configuration for mittwald app installation '${appInstallationId}'
+# generated by 'mw ddev init-config'
+${yaml.dump(cfg)}`;
+}

package/dist/lib/ddev/flags.d.ts

@@ -0,0 +1,3 @@
+export declare const ddevFlags: {
+    "override-type": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};

package/dist/lib/ddev/flags.js

@@ -0,0 +1,10 @@
+import { Flags } from "@oclif/core";
+export const ddevFlags = {
+    "override-type": Flags.string({
+        summary: "Override the type of the generated DDEV configuration",
+        default: "auto",
+        description: "The type of the generated DDEV configuration; this can be any of the documented DDEV project types, or 'auto' (which is also the default) for automatic discovery." +
+            "\n\n" +
+            "See https://ddev.readthedocs.io/en/latest/users/configuration/config/#type for more information",
+    }),
+};

package/dist/lib/domain/dnszone/records.d.ts

@@ -0,0 +1,18 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsRecordCombinedA = MittwaldAPIV2.Components.Schemas.DnsRecordCombinedA;
+type DnsCombinedAManaged = MittwaldAPIV2.Components.Schemas.DnsCombinedAManaged;
+type DnsRecordMX = MittwaldAPIV2.Components.Schemas.DnsRecordMX;
+type DnsRecordMXManaged = MittwaldAPIV2.Components.Schemas.DnsRecordMXManaged;
+type DnsCombinedACustom = MittwaldAPIV2.Components.Schemas.DnsCombinedACustom;
+type DnsRecordMXCustom = MittwaldAPIV2.Components.Schemas.DnsRecordMXCustom;
+type DnsRecordTXT = MittwaldAPIV2.Components.Schemas.DnsRecordTXT;
+type DnsRecordTXTComponent = MittwaldAPIV2.Components.Schemas.DnsRecordTXTComponent;
+type DnsRecordSRVComponent = MittwaldAPIV2.Components.Schemas.DnsRecordSRVComponent;
+type DnsRecordSRV = MittwaldAPIV2.Components.Schemas.DnsRecordSRV;
+export declare function isManagedARecord(r: DnsRecordCombinedA): r is DnsCombinedAManaged;
+export declare function isCustomARecord(r: DnsRecordCombinedA): r is DnsCombinedACustom;
+export declare function isManagedMXRecord(r: DnsRecordMX): r is DnsRecordMXManaged;
+export declare function isCustomMXRecord(r: DnsRecordMX): r is DnsRecordMXCustom;
+export declare function isTXTRecord(r: DnsRecordTXT): r is DnsRecordTXTComponent;
+export declare function isSRVRecord(r: DnsRecordSRV): r is DnsRecordSRVComponent;
+export {};

package/dist/lib/fsutil.d.ts

@@ -0,0 +1,2 @@
+export declare function isNotFound(e: unknown): boolean;
+export declare function pathExists(path: string): Promise<boolean>;

package/dist/lib/fsutil.js

@@ -0,0 +1,16 @@
+import fs from "fs/promises";
+export function isNotFound(e) {
+    return e instanceof Error && "code" in e && e.code === "ENOENT";
+}
+export async function pathExists(path) {
+    try {
+        await fs.stat(path);
+        return true;
+    }
+    catch (e) {
+        if (isNotFound(e)) {
+            return false;
+        }
+        throw e;
+    }
+}

package/dist/{esm/lib → lib}/handleError.d.ts

@@ -1,7 +1,7 @@
 import { OclifError, PrettyPrintableError } from "@oclif/core/lib/interfaces/index.js";
 import { ApiClientError, AxiosResponse } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
-import CommonsValidationErrors = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type CommonsValidationErrors = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
 export declare const handleError: (error: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
     skipOclifErrorHandling?: boolean;
 }) => void;
@@ -9,3 +9,4 @@ export declare function isUnexpectedError(err: unknown): boolean;
 export declare function isValidationError(err: unknown): err is ApiClientError<CommonsValidationErrors> & {
     response: AxiosResponse<CommonsValidationErrors>;
 };
+export {};

package/dist/{esm/lib → lib}/project/flags.js

@@ -24,9 +24,12 @@ export function makeProjectFlagSet(name, char, opts = {}) {
         }),
     };
     if (supportsContext) {
-        flags[flagName].summary += `; this flag is optional if a default ${displayName} is set in the context`;
-        flags[flagName].description += `; you can also use the "<%= config.bin %> context set --${flagName}=<VALUE>" command to persistently set a default ${displayName} for all commands that accept this flag.`;
-        args[flagName].description += `; this argument is optional if a default ${displayName} is set in the context`;
+        flags[flagName].summary +=
+            `; this flag is optional if a default ${displayName} is set in the context`;
+        flags[flagName].description +=
+            `; you can also use the "<%= config.bin %> context set --${flagName}=<VALUE>" command to persistently set a default ${displayName} for all commands that accept this flag.`;
+        args[flagName].description +=
+            `; this argument is optional if a default ${displayName} is set in the context`;
     }
     const idFromArgsOrFlag = (flags, args) => {
         if (args[flagName]) {
@@ -46,7 +49,7 @@ export function makeProjectFlagSet(name, char, opts = {}) {
             const projectId = await withProjectId(apiClient, commandType, flags, args, cfg);
             return normalize(apiClient, projectId, idInput);
         }
-        const idFromContext = await new Context(cfg).getContextValue(flagName);
+        const idFromContext = await new Context(apiClient, cfg).getContextValue(flagName);
         if (idFromContext) {
             return idFromContext.value;
         }

package/dist/lib/project/hooks.d.ts

@@ -0,0 +1,4 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type ProjectProject = MittwaldAPIV2.Components.Schemas.ProjectProject;
+export declare function useProject(projectId: string): ProjectProject;
+export {};

package/dist/lib/projectbackup/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+type BackupProjectBackupSchedule = MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule;
+export declare function useProjectBackup(projectBackupId: string): BackupProjectBackup;
+export declare function useProjectBackupSchedule(projectBackupScheduleId: string): BackupProjectBackupSchedule;
+export {};

package/dist/{esm/lib → lib}/ssh/exec.d.ts

@@ -11,4 +11,4 @@ export type RunCommand = {
 } | {
     shell: string;
 };
-export declare function executeViaSSH(client: MittwaldAPIV2Client, sshUser: string | undefined, target: RunTarget, command: RunCommand, output: NodeJS.WritableStream): Promise<void>;
+export declare function executeViaSSH(client: MittwaldAPIV2Client, sshUser: string | undefined, target: RunTarget, command: RunCommand, output: NodeJS.WritableStream | null, input?: NodeJS.ReadableStream | null): Promise<void>;

package/dist/{esm/lib → lib}/ssh/exec.js

@@ -1,17 +1,22 @@
 import cp from "child_process";
 import { getSSHConnectionForAppInstallation } from "./appinstall.js";
 import { getSSHConnectionForProject } from "./project.js";
-export async function executeViaSSH(client, sshUser, target, command, output) {
+export async function executeViaSSH(client, sshUser, target, command, output, input = null) {
     const { user, host } = await connectionDataForTarget(client, target, sshUser);
     const sshCommandArgs = "shell" in command
         ? ["bash", "-c", command.shell]
         : [command.command, ...command.args];
     const sshArgs = ["-l", user, "-T", host, ...sshCommandArgs];
     const ssh = cp.spawn("ssh", sshArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: [input ? "pipe" : "ignore", output ? "pipe" : "ignore", "pipe"],
     });
     let err = "";
-    ssh.stdout.pipe(output);
+    if (input && ssh.stdin) {
+        input.pipe(ssh.stdin);
+    }
+    if (output && ssh.stdout) {
+        ssh.stdout.pipe(output);
+    }
     ssh.stderr.on("data", (data) => {
         err += data.toString();
     });
@@ -25,7 +30,7 @@ export async function executeViaSSH(client, sshUser, target, command, output) {
                     rej(new Error(`ssh+${command} exited with code ${code}\n${err}`));
                 }
             };
-            if (output === process.stdout) {
+            if (output === process.stdout || output === null) {
                 resolve();
             }
             else {

package/dist/lib/viewhelpers/date.d.ts

@@ -0,0 +1,7 @@
+export type DateRenderer = (d: Date | string) => string;
+export declare function optionalDateRenderer(r: DateRenderer): (n: Date | string | undefined) => string | undefined;
+export declare const formatDateISO: DateRenderer;
+export declare const formatDateLocale: DateRenderer;
+export declare const formatRelativeDate: DateRenderer;
+export declare const parseDate: (text: string) => Date | undefined;
+export declare function makeDateRendererForFormat(format: string, relative: boolean): DateRenderer;

package/dist/lib/viewhelpers/date.js

@@ -0,0 +1,47 @@
+import { formatDistanceToNow } from "date-fns";
+const forceDateType = (d) => {
+    if (typeof d === "string") {
+        return new Date(d);
+    }
+    return d;
+};
+export function optionalDateRenderer(r) {
+    return (d) => {
+        if (d === undefined) {
+            return undefined;
+        }
+        return r(d);
+    };
+}
+export const formatDateISO = (d) => forceDateType(d).toISOString();
+export const formatDateLocale = (d) => forceDateType(d).toLocaleString();
+export const formatRelativeDate = (date) => {
+    if (!date) {
+        return "unknown";
+    }
+    if (typeof date === "string") {
+        date = new Date(date);
+    }
+    if (date.getTime() < new Date().getTime()) {
+        return formatDistanceToNow(date) + " ago";
+    }
+    return formatDistanceToNow(date) + " from now";
+};
+export const parseDate = (text) => {
+    const time = Date.parse(text);
+    if (isNaN(time)) {
+        return undefined;
+    }
+    return new Date(time);
+};
+export function makeDateRendererForFormat(format, relative) {
+    switch (format) {
+        case "csv":
+            return formatDateISO;
+        case "json":
+        case "yaml":
+            return (d) => forceDateType(d).toJSON();
+        default:
+            return relative ? formatRelativeDate : formatDateLocale;
+    }
+}

package/dist/lib/viewhelpers/list_column_date.d.ts

@@ -0,0 +1,14 @@
+import { FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
+import { DateRenderer } from "./date.js";
+import { table } from "@oclif/core/lib/cli-ux/styled/table.js";
+import Column = table.Column;
+type ResourceWithCreatedAt = {
+    createdAt: string;
+};
+export declare function isResourceWithCreatedAt(resource: Record<string, unknown>): resource is ResourceWithCreatedAt;
+export declare function makeDateRendererForFlags(flags: FlagOutput): DateRenderer;
+export declare function buildCreatedAtColumn(flags: FlagOutput): Partial<Column<Record<string, unknown>>>;
+export declare function formatCreatedAt(row: {
+    createdAt: string;
+}): string;
+export {};

package/dist/lib/viewhelpers/list_column_date.js

@@ -0,0 +1,21 @@
+import { formatDateISO, formatRelativeDate, makeDateRendererForFormat, } from "./date.js";
+import { isListFormatterFlags } from "../../Formatter.js";
+export function isResourceWithCreatedAt(resource) {
+    return "createdAt" in resource;
+}
+export function makeDateRendererForFlags(flags) {
+    if (isListFormatterFlags(flags)) {
+        return makeDateRendererForFormat(flags.output, !flags["no-relative-dates"]);
+    }
+    return formatDateISO;
+}
+export function buildCreatedAtColumn(flags) {
+    const dateFormatter = makeDateRendererForFlags(flags);
+    return {
+        header: "Created at",
+        get: (row) => dateFormatter(new Date(`${row.createdAt}`)),
+    };
+}
+export function formatCreatedAt(row) {
+    return formatRelativeDate(new Date(`${row.createdAt}`));
+}

package/dist/lib/viewhelpers/tui.d.ts

@@ -0,0 +1,2 @@
+export declare function printHeader(heading: string): void;
+export declare function printKeyValues(tableContents: Record<string, string>): void;

package/dist/lib/viewhelpers/tui.js

@@ -0,0 +1,13 @@
+import chalk from "chalk";
+export function printHeader(heading) {
+    console.log(chalk.bold.white(heading));
+    console.log(chalk.bold.white("─".repeat(heading.length)));
+    console.log();
+}
+export function printKeyValues(tableContents) {
+    const keys = Object.keys(tableContents);
+    const l = Math.max(...keys.map((k) => k.length));
+    for (const key of keys) {
+        console.log(chalk.blueBright(key.padEnd(l, " ")), " ", tableContents[key]);
+    }
+}

package/dist/{esm/rendering → rendering}/process/components/ProcessInput.js

@@ -9,7 +9,7 @@ export const ProcessInput = ({ step, onSubmit }) => {
     const [value, setValue] = useState("");
     if (!step.value) {
         const { isRawModeSupported } = useStdin();
-        return (_jsx(_Fragment, { children: _jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsxs(Text, { children: [step.title, ": "] }), isRawModeSupported ? (_jsx(TextInput, { mask: step.mask ? "*" : undefined, value: value, onChange: setValue, onSubmit: onSubmit })) : (_jsx(InteractiveInputDisabled, {}))] }) }));
+        return (_jsx(_Fragment, { children: _jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsxs(Text, { children: [step.title, ": "] }), isRawModeSupported ? (_jsx(Text, { color: "blue", children: _jsx(TextInput, { mask: step.mask ? "*" : undefined, value: value, onChange: setValue, onSubmit: onSubmit }) })) : (_jsx(InteractiveInputDisabled, {}))] }) }));
     }
     return _jsx(ProcessState, { step: step });
 };

package/dist/rendering/process/components/ProcessValidationErrors.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type CommonsValidationErrors = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
+export declare const ProcessValidationErrors: React.FC<{
+    err: CommonsValidationErrors;
+    color?: string;
+}>;
+export {};

package/dist/{esm/rendering → rendering}/process/process.js

@@ -34,6 +34,9 @@ export class RunnableHandler {
         this.listener();
     }
     appendOutput(o) {
+        if (this.processStep.output === undefined) {
+            this.processStep.output = "";
+        }
         this.processStep.output += o;
         this.listener();
     }

package/dist/rendering/process/process_exec.d.ts

@@ -0,0 +1,3 @@
+import { ProcessRenderer } from "./process.js";
+import { ReactNode } from "react";
+export declare function spawnInProcess(r: ProcessRenderer, title: ReactNode, cmd: string, args: string[]): Promise<void>;

package/dist/rendering/process/process_exec.js

@@ -0,0 +1,27 @@
+import { spawn } from "child_process";
+export async function spawnInProcess(r, title, cmd, args) {
+    const step = r.addStep(title);
+    const child = spawn(cmd, args, {
+        shell: false,
+        stdio: ["inherit", "pipe", "pipe"],
+    });
+    const appendOutput = (chunk) => {
+        if (typeof chunk === "string") {
+            step.appendOutput(chunk);
+        }
+        if (Buffer.isBuffer(chunk)) {
+            step.appendOutput(chunk.toString());
+        }
+    };
+    child.stdout.on("data", appendOutput);
+    child.stderr.on("data", appendOutput);
+    child.on("exit", (code) => {
+        if (code === 0) {
+            step.complete();
+        }
+        else {
+            step.error(new Error(`${cmd} exited with code ${code}`));
+        }
+    });
+    await step.wait();
+}

package/dist/rendering/react/components/AppInstallation/AppInstallationDetails.d.ts

@@ -0,0 +1,9 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppAppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+type AppApp = MittwaldAPIV2.Components.Schemas.AppApp;
+export declare const AppInstallationDetails: FC<{
+    appInstallation: AppAppInstallation;
+    app: AppApp;
+}>;
+export {};

package/dist/rendering/react/components/AppInstallation/AppInstallationStatus.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppAppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+type AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+export declare const AppInstallationStatus: FC<{
+    appInstallation: AppAppInstallation;
+    desired: AppAppVersion;
+    current: AppAppVersion | undefined;
+}>;
+export {};

package/dist/rendering/react/components/AppInstallation/AppSystemSoftware.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppAppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+export declare const AppSystemSoftware: FC<{
+    appInstallation: AppAppInstallation;
+}>;
+export {};

package/dist/{esm/rendering → rendering}/react/components/Conversation/ConversationMessage.d.ts

@@ -1,5 +1,5 @@
 import { FC } from "react";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
 type Message = MittwaldAPIV2.Components.Schemas.ConversationMessage | MittwaldAPIV2.Components.Schemas.ConversationStatusUpdate;
 interface Props {
     message: Message;

package/dist/{esm/rendering → rendering}/react/components/Conversation/ConversationMessages.d.ts

@@ -1,5 +1,5 @@
 import { FC } from "react";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
 type Message = MittwaldAPIV2.Components.Schemas.ConversationMessage | MittwaldAPIV2.Components.Schemas.ConversationStatusUpdate;
 interface Props {
     messages: Message[];

package/dist/{esm/rendering → rendering}/react/components/Conversation/ConversationStatusUpdate.d.ts

@@ -1,5 +1,5 @@
 import { FC } from "react";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
 type Message = MittwaldAPIV2.Components.Schemas.ConversationStatusUpdate;
 interface Props {
     message: Message;

package/dist/{esm/rendering → rendering}/react/components/CronJob/CronJobDetails.d.ts

@@ -1,6 +1,6 @@
 import { FC } from "react";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
-import CronjobCronjob = MittwaldAPIV2.Components.Schemas.CronjobCronjob;
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type CronjobCronjob = MittwaldAPIV2.Components.Schemas.CronjobCronjob;
 type CronJobComponent = FC<{
     cronjob: CronjobCronjob;
 }>;

package/dist/rendering/react/components/DDEV/DDEVInitSuccess.d.ts

@@ -0,0 +1 @@
+export declare function DDEVInitSuccess(): import("react/jsx-runtime").JSX.Element;

package/dist/rendering/react/components/DDEV/DDEVInitSuccess.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { defaultSuccessColor, Success } from "../Success.js";
+import { Box, Text } from "ink";
+function DDEVCommand({ command, text, dangerous, }) {
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: command.join(" ") }), dangerous ? (_jsxs(Text, { color: "red", bold: true, children: [" ", "(DANGEROUS!)"] })) : undefined] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { wrap: "wrap", children: text }) })] }));
+}
+export function DDEVInitSuccess() {
+    return (_jsxs(Success, { innerText: false, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: defaultSuccessColor, children: "DDEV project successfully initialized! \uD83D\uDE80" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: defaultSuccessColor, children: "You can now use the following commands to get started with your DDEV project:" }) }), _jsx(DDEVCommand, { command: ["ddev", "start"], text: "Start and initialize all project containers" }), _jsx(DDEVCommand, { command: ["ddev", "pull", "mittwald"], text: "Download the latest database and files from the mittwald application linked to this DDEV project" }), _jsx(DDEVCommand, { command: ["ddev", "push", "mittwald"], text: "Upload the latest database and files to the mittwald application linked to this DDEV project", dangerous: true }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: defaultSuccessColor, children: ["You can also use the ", _jsx(Text, { color: "yellow", children: "mw ddev init" }), " command repeatedly to continuously update your DDEV configuration."] }) })] }));
+}

package/dist/rendering/react/components/DnsZone/DnsZoneDetails.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsZone = MittwaldAPIV2.Components.Schemas.DnsZone;
+export declare const DnsZoneDetails: FC<{
+    dnsZone: DnsZone;
+}>;
+export {};

package/dist/rendering/react/components/DnsZone/DnsZoneRecords.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsZone = MittwaldAPIV2.Components.Schemas.DnsZone;
+export declare const DnsZoneRecords: FC<{
+    dnsZone: DnsZone;
+}>;
+export {};

package/dist/rendering/react/components/DnsZone/DnsZoneRecordsA.d.ts

@@ -0,0 +1,5 @@
+import { RecordComponent } from "./RecordComponent.js";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsRecordCombinedA = MittwaldAPIV2.Components.Schemas.DnsRecordCombinedA;
+export declare const DnsZoneRecordsA: RecordComponent<DnsRecordCombinedA>;
+export {};

package/dist/rendering/react/components/DnsZone/DnsZoneRecordsAAAA.d.ts

@@ -0,0 +1,5 @@
+import { RecordComponent } from "./RecordComponent.js";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsRecordCombinedA = MittwaldAPIV2.Components.Schemas.DnsRecordCombinedA;
+export declare const DnsZoneRecordsAAAA: RecordComponent<DnsRecordCombinedA>;
+export {};

package/dist/rendering/react/components/DnsZone/DnsZoneRecordsMX.d.ts

@@ -0,0 +1,5 @@
+import { RecordComponent } from "./RecordComponent.js";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsRecordMX = MittwaldAPIV2.Components.Schemas.DnsRecordMX;
+export declare const DnsZoneRecordsMX: RecordComponent<DnsRecordMX>;
+export {};

package/dist/rendering/react/components/DnsZone/DnsZoneRecordsSRV.d.ts

@@ -0,0 +1,5 @@
+import { RecordComponent } from "./RecordComponent.js";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsRecordSRV = MittwaldAPIV2.Components.Schemas.DnsRecordSRV;
+export declare const DnsZoneRecordsSRV: RecordComponent<DnsRecordSRV>;
+export {};

package/dist/rendering/react/components/DnsZone/DnsZoneRecordsTXT.d.ts

@@ -0,0 +1,5 @@
+import { RecordComponent } from "./RecordComponent.js";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DnsRecordTXT = MittwaldAPIV2.Components.Schemas.DnsRecordTXT;
+export declare const DnsZoneRecordsTXT: RecordComponent<DnsRecordTXT>;
+export {};

package/dist/rendering/react/components/Domain/DomainBaseDetails.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type DomainDomain = MittwaldAPIV2.Components.Schemas.DomainDomain;
+export declare const DomainBaseDetails: FC<{
+    domain: DomainDomain;
+}>;
+export {};