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

package/dist/esm/rendering/react/measure/MeasureContextProvider.js

@@ -1,10 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box } from "ink";
-import { useRef } from "react";
-import { createMeasureContext, measureContext } from "./context.js";
-import { MeasureRenderer } from "./MeasureRenderer.js";
-export const MeasureContextProvider = (props) => {
-    const { children } = props;
-    const context = useRef(createMeasureContext()).current;
-    return (_jsx(measureContext.Provider, { value: context, children: _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { children: _jsx(MeasureRenderer, {}) }), _jsx(Box, { children: children })] }) }));
-};

package/dist/esm/rendering/react/measure/MeasureRenderer.d.ts

@@ -1,2 +0,0 @@
-import { FC } from "react";
-export declare const MeasureRenderer: FC;

package/dist/esm/rendering/react/measure/MeasureRenderer.js

@@ -1,22 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Box, measureElement } from "ink";
-import { useEffect, useRef } from "react";
-import { useWatchObservableValue } from "../lib/observable-value/useWatchObservableValue.js";
-import { useMeasureContext } from "./context.js";
-const M = (props) => {
-    const { children, id } = props;
-    const measureContext = useMeasureContext();
-    const ref = useRef(null);
-    useEffect(() => {
-        if (ref.current) {
-            const dimension = measureElement(ref.current);
-            measureContext.updateDimension(id, dimension);
-        }
-    }, [id, measureContext, ref.current]);
-    return (_jsx(Box, { height: 0, overflow: "hidden", flexShrink: 1, ref: ref, children: children }));
-};
-export const MeasureRenderer = () => {
-    const context = useMeasureContext();
-    const watchedNodes = useWatchObservableValue(context.nodes);
-    return (_jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: Object.entries(watchedNodes).map(([id, node]) => (_jsx(M, { id: id, children: node }, id))) }));
-};

package/dist/esm/rendering/react/measure/context.d.ts

@@ -1,18 +0,0 @@
-import { measureElement } from "ink";
-import { ReactNode } from "react";
-import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
-export type MeasureContextNodes = Record<string, ReactNode>;
-export type Dimension = ReturnType<typeof measureElement>;
-export type Dimensions = Record<string, ObservableValue<Dimension>>;
-interface Context {
-    nodes: ObservableValue<MeasureContextNodes>;
-    dimensions: Dimensions;
-    addNode: (id: string, node: ReactNode) => void;
-    removeNode: (id: string) => void;
-    getDimension: (id: string) => ObservableValue<Dimension>;
-    updateDimension: (id: string, dimension: Dimension) => void;
-}
-export declare const createMeasureContext: () => Context;
-export declare const measureContext: import("react").Context<Context>;
-export declare const useMeasureContext: () => Context;
-export {};

package/dist/esm/rendering/react/measure/context.js

@@ -1,48 +0,0 @@
-import { createContext, useContext } from "react";
-import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
-export const createMeasureContext = () => {
-    const context = {
-        nodes: new ObservableValue({}),
-        dimensions: {},
-        addNode: (id, node) => {
-            const existing = context.nodes.value[id];
-            if (existing === node) {
-                return;
-            }
-            context.dimensions[id] = new ObservableValue({
-                height: 0,
-                width: 0,
-            });
-            context.nodes.updateValue({
-                ...context.nodes.value,
-                [id]: node,
-            });
-        },
-        removeNode: (id) => {
-            if (id in context.nodes) {
-                const updatedNodes = {
-                    ...context.nodes.value,
-                };
-                delete updatedNodes[id];
-                context.nodes.updateValue(updatedNodes);
-            }
-        },
-        getDimension: (id) => {
-            const dimension = context.dimensions[id];
-            if (!dimension) {
-                throw new Error(`Could not get dimension for ${id}`);
-            }
-            return dimension;
-        },
-        updateDimension: (id, updatedDimension) => {
-            const dimension = context.getDimension(id);
-            if (dimension.value.width !== updatedDimension.width ||
-                dimension.value.height !== updatedDimension.height) {
-                dimension.updateValue(updatedDimension);
-            }
-        },
-    };
-    return context;
-};
-export const measureContext = createContext(createMeasureContext());
-export const useMeasureContext = () => useContext(measureContext);

package/dist/esm/rendering/react/process.d.ts

@@ -1,42 +0,0 @@
-import { ReactElement, ReactNode } from "react";
-export type ProcessStepInfo = {
-    type: "info";
-    title: ReactElement;
-};
-export type ProcessStepRunnable = {
-    type: "step";
-    title: ReactElement;
-    phase: "running" | "completed" | "failed" | "aborted";
-    error?: unknown;
-};
-export type ProcessStepConfirm = {
-    type: "confirm";
-    title: ReactElement;
-    confirmed: boolean | undefined;
-};
-export type ProcessStepInput = {
-    type: "input";
-    title: ReactElement;
-    mask?: boolean;
-    value?: string;
-};
-export type ProcessStep = ProcessStepInfo | ProcessStepRunnable | ProcessStepConfirm | ProcessStepInput;
-export declare class RunnableHandler {
-    private readonly listener;
-    private readonly processStep;
-    constructor(state: ProcessStepRunnable, l: () => void);
-    get done(): boolean;
-    abort(): void;
-    complete(): void;
-    error(err: unknown): void;
-}
-export interface ProcessRenderer {
-    start(): void;
-    addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
-    addInfo(title: ReactElement): void;
-    addConfirmation(question: ReactElement): Promise<boolean>;
-    addInput(question: ReactElement, mask?: boolean): Promise<string>;
-    complete(summary: ReactElement): void;
-    error(err: unknown): void;
-}

package/dist/esm/rendering/react/process.js

@@ -1,24 +0,0 @@
-export class RunnableHandler {
-    listener;
-    processStep;
-    constructor(state, l) {
-        this.processStep = state;
-        this.listener = l;
-    }
-    get done() {
-        return this.processStep.phase !== "running";
-    }
-    abort() {
-        this.processStep.phase = "aborted";
-        this.listener();
-    }
-    complete() {
-        this.processStep.phase = "completed";
-        this.listener();
-    }
-    error(err) {
-        this.processStep.phase = "failed";
-        this.processStep.error = err;
-        this.listener();
-    }
-}

package/dist/esm/rendering/react/process_fancy.d.ts

@@ -1,28 +0,0 @@
-import React, { ReactElement, ReactNode } from "react";
-import { ProcessRenderer, ProcessStep, ProcessStepInput, RunnableHandler } from "./process.js";
-export declare class FancyProcessRenderer implements ProcessRenderer {
-    private readonly title;
-    private started;
-    private currentHandler;
-    constructor(title: string);
-    start(): void;
-    addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
-    addInfo(title: ReactElement): void;
-    addInput(question: React.ReactElement, mask?: boolean): Promise<string>;
-    addConfirmation(question: ReactElement): Promise<boolean>;
-    complete(summary: ReactElement): void;
-    error(err: unknown): void;
-    private renderStart;
-}
-export declare const ProcessState: React.FC<{
-    step: ProcessStep;
-}>;
-export declare const ProcessConfirmation: React.FC<{
-    step: ProcessStep;
-    onConfirm: (confirmed: boolean) => void;
-}>;
-export declare const ProcessInput: React.FC<{
-    step: ProcessStepInput;
-    onSubmit: (value: string) => void;
-}>;

package/dist/esm/rendering/react/process_fancy.js

@@ -1,213 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from "react";
-import { RunnableHandler, } from "./process.js";
-import { Header } from "./components/Header.js";
-import { Box, render, Text, useInput, useStdin } from "ink";
-import TextInput from "ink-text-input";
-export class FancyProcessRenderer {
-    title;
-    started = false;
-    currentHandler = null;
-    constructor(title) {
-        this.title = title;
-    }
-    start() {
-        if (this.started) {
-            return;
-        }
-        this.started = true;
-        render(this.renderStart(), {}).unmount();
-    }
-    addStep(title) {
-        this.start();
-        if (this.currentHandler !== null) {
-            this.currentHandler.abort();
-        }
-        title = _jsx(_Fragment, { children: title });
-        const state = { type: "step", title, phase: "running" };
-        const renderHandle = render(_jsx(ProcessState, { step: state }));
-        this.currentHandler = new RunnableHandler(state, () => {
-            renderHandle.rerender(_jsx(ProcessState, { step: state }));
-            if (this.currentHandler?.done) {
-                this.currentHandler = null;
-                renderHandle.unmount();
-            }
-        });
-        return this.currentHandler;
-    }
-    async runStep(title, fn) {
-        const step = this.addStep(title);
-        try {
-            const result = await fn();
-            step.complete();
-            return result;
-        }
-        catch (err) {
-            step.error(err);
-            throw err;
-        }
-    }
-    addInfo(title) {
-        this.start();
-        if (this.currentHandler !== null) {
-            this.currentHandler.complete();
-        }
-        const state = { type: "info", title };
-        render(_jsx(ProcessState, { step: state })).unmount();
-    }
-    addInput(question, mask) {
-        this.start();
-        if (this.currentHandler !== null) {
-            this.currentHandler.complete();
-        }
-        const state = {
-            type: "input",
-            title: question,
-            mask,
-        };
-        return new Promise((res) => {
-            const onInput = (value) => {
-                res(value);
-                state.value = value;
-                if (renderHandle) {
-                    renderHandle.rerender(_jsx(ProcessInput, { step: state, onSubmit: onInput }));
-                    renderHandle.unmount();
-                }
-            };
-            const renderHandle = render(_jsx(ProcessInput, { step: state, onSubmit: onInput }));
-        });
-    }
-    addConfirmation(question) {
-        this.start();
-        if (this.currentHandler !== null) {
-            this.currentHandler.complete();
-        }
-        const state = {
-            type: "confirm",
-            title: question,
-            confirmed: undefined,
-        };
-        return new Promise((res) => {
-            const onConfirm = (confirmed) => {
-                res(confirmed);
-                state.confirmed = confirmed;
-                if (renderHandle) {
-                    renderHandle.rerender(_jsx(ProcessConfirmation, { step: state, onConfirm: onConfirm }));
-                    renderHandle.unmount();
-                }
-            };
-            const renderHandle = render(_jsx(ProcessConfirmation, { step: state, onConfirm: onConfirm }));
-        });
-    }
-    complete(summary) {
-        if (this.currentHandler) {
-            this.currentHandler.complete();
-        }
-        render(_jsx(Box, { marginY: 1, marginX: 2, children: summary })).unmount();
-    }
-    error(err) {
-        if (this.currentHandler) {
-            this.currentHandler.error(err);
-        }
-        else {
-            render(_jsx(Box, { marginY: 1, marginX: 2, borderStyle: "round", borderColor: "red", children: _jsxs(Text, { color: "red", children: ["Error: ", err?.toString()] }) })).unmount();
-        }
-    }
-    renderStart() {
-        return (_jsx(Box, { marginY: 1, marginX: 2, children: _jsx(Header, { title: this.title }) }));
-    }
-}
-const ProcessStateIcon = ({ step }) => {
-    if (step.type === "info") {
-        return _jsxs(Text, { children: ["\u2139\uFE0F", "  "] });
-    }
-    else if (step.type === "confirm" || step.type === "input") {
-        return _jsx(Text, { children: "\u2753" });
-    }
-    else if (step.phase === "completed") {
-        return _jsx(Text, { children: "\u2705" });
-    }
-    else if (step.phase === "aborted") {
-        return _jsx(Text, { children: "\u23E9\uFE0F " });
-    }
-    else if (step.phase === "failed") {
-        return _jsx(Text, { children: "\u274C" });
-    }
-    else {
-        return _jsx(Text, { children: "\uD83D\uDD01 " });
-    }
-};
-const ProcessInputStateSummary = ({ step }) => {
-    if (step.value && step.mask) {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": " }), _jsx(Text, { color: "blue", children: "[secret]" })] }));
-    }
-    if (step.value) {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": " }), _jsx(Text, { color: "green", children: step.value })] }));
-    }
-    else {
-        return _jsx(Text, { children: ": " });
-    }
-};
-const InteractiveConfirmationDisabled = () => (_jsxs(Text, { color: "red", children: [" ", "interactive input required; start this command with --force or --quiet to disable interactive prompts"] }));
-const InteractiveInputDisabled = () => (_jsx(Text, { color: "red", children: "interactive input required; inspect this command's --help page to learn how to pass the required input non-interactively." }));
-const ProcessConfirmationStateSummary = ({ step }) => {
-    const { isRawModeSupported } = useStdin();
-    if (!isRawModeSupported) {
-        return _jsx(InteractiveConfirmationDisabled, {});
-    }
-    if (step.confirmed) {
-        return _jsx(Text, { color: "green", children: " confirmed" });
-    }
-    else if (step.confirmed === false) {
-        return _jsx(Text, { color: "yellow", children: " not confirmed" });
-    }
-    else {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": press " }), _jsx(Text, { color: "blue", children: "y" }), _jsx(Text, { children: " or " }), _jsx(Text, { color: "blue", children: "n" }), _jsxs(Text, { color: "gray", children: [" ", "(use the --force or --quiet flags to disable this prompt)"] })] }));
-    }
-};
-const ProcessStateSummary = ({ step }) => {
-    if (step.type === "info") {
-        return _jsx(_Fragment, {});
-    }
-    else if (step.type === "confirm") {
-        return _jsx(ProcessConfirmationStateSummary, { step: step });
-    }
-    else if (step.type === "input") {
-        return _jsx(ProcessInputStateSummary, { step: step });
-    }
-    else if (step.phase === "completed") {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ". " }), _jsx(Text, { color: "green", children: "done" })] }));
-    }
-    else if (step.phase === "aborted") {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ". " }), _jsx(Text, { color: "yellow", children: "cancelled" })] }));
-    }
-    else if (step.phase === "failed") {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ". " }), _jsx(Text, { color: "red", children: "error" })] }));
-    }
-    else {
-        return _jsx(Text, { children: "..." });
-    }
-};
-const ProcessError = ({ err }) => {
-    return (_jsxs(Box, { marginY: 1, marginX: 5, flexDirection: "column", children: [_jsx(Text, { color: "red", children: "An error occurred during this operation:" }), _jsx(Text, { color: "red", bold: true, children: err?.toString() })] }));
-};
-export const ProcessState = ({ step }) => {
-    return (_jsxs(_Fragment, { children: [_jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsx(Text, { children: step.title }), _jsx(ProcessStateSummary, { step: step })] }), step.type === "step" && step.error ? (_jsx(ProcessError, { err: step.error })) : null] }));
-};
-export const ProcessConfirmation = ({ step, onConfirm }) => {
-    const { isRawModeSupported } = useStdin();
-    if (isRawModeSupported) {
-        useInput((input) => {
-            onConfirm(input === "y");
-        });
-    }
-    return _jsx(ProcessState, { step: step });
-};
-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(ProcessState, { step: step });
-};

package/dist/esm/rendering/react/process_flags.d.ts

@@ -1,9 +0,0 @@
-import { ProcessRenderer } from "./process.js";
-import { InferredFlags } from "@oclif/core/lib/interfaces/index.js";
-export declare const processFlags: {
-    quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-};
-export type ProcessFlags = InferredFlags<typeof processFlags>;
-export declare const makeProcessRenderer: (flags: {
-    quiet: boolean;
-}, title: string) => ProcessRenderer;

package/dist/esm/rendering/react/process_flags.js

@@ -1,15 +0,0 @@
-import { FancyProcessRenderer } from "./process_fancy.js";
-import { Flags } from "@oclif/core";
-import { SilentProcessRenderer } from "./process_quiet.js";
-export const processFlags = {
-    quiet: Flags.boolean({
-        char: "q",
-        description: "Suppress process output and only display a machine-readable summary.",
-    }),
-};
-export const makeProcessRenderer = (flags, title) => {
-    if (flags.quiet) {
-        return new SilentProcessRenderer();
-    }
-    return new FancyProcessRenderer(title);
-};

package/dist/esm/rendering/react/process_quiet.d.ts

@@ -1,12 +0,0 @@
-import { ReactElement, ReactNode } from "react";
-import { ProcessRenderer, RunnableHandler } from "./process.js";
-export declare class SilentProcessRenderer implements ProcessRenderer {
-    start(): void;
-    addStep(title: ReactElement): RunnableHandler;
-    runStep<TRes>(unusedTitle: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
-    addInfo(): void;
-    complete(): void;
-    error(err: unknown): void;
-    addConfirmation(): Promise<boolean>;
-    addInput(): Promise<string>;
-}

package/dist/esm/rendering/react/process_quiet.js

@@ -1,29 +0,0 @@
-import { RunnableHandler } from "./process.js";
-export class SilentProcessRenderer {
-    start() {
-        // 🤐
-    }
-    addStep(title) {
-        return new RunnableHandler({ type: "step", title, phase: "aborted" }, () => {
-            // empty
-        });
-    }
-    runStep(unusedTitle, fn) {
-        return fn();
-    }
-    addInfo() {
-        // 🤐
-    }
-    complete() {
-        // 🤐
-    }
-    error(err) {
-        console.error(err);
-    }
-    addConfirmation() {
-        return Promise.resolve(true);
-    }
-    addInput() {
-        throw new Error("no interactive input available in quiet mode");
-    }
-}

package/dist/esm/rendering/setup/FlagSupportedSetup.d.ts

@@ -1,15 +0,0 @@
-import { FlagInput } from "@oclif/core/lib/interfaces/parser.js";
-import { InferredFlags } from "@oclif/core/lib/interfaces/index.js";
-import { Class } from "type-fest";
-export type InferredOutput<T> = T extends Class<FlagSupportedSetup<FlagInput, any, infer TOut>, // eslint-disable-line
-any> ? TOut : never;
-export declare abstract class FlagSupportedSetup<TFlags extends FlagInput, TSettings, TSetupObject> {
-    flags: TFlags;
-    settings: TSettings;
-    protected constructor(flagsInput: TFlags, settings: TSettings);
-    getSetup(flags: InferredFlags<TFlags>): TSettings & TSetupObject;
-    protected abstract getFlagsOutput(flags: InferredFlags<TFlags>): TSetupObject;
-    static build: <TFlags_1 extends FlagInput<{
-        [flag: string]: any;
-    }>, TSettings_1, TOutput>(flags: TFlags_1, defaultSettings: TSettings_1, buildFlagsOutput: (flags: InferredFlags<TFlags_1>, settings: TSettings_1) => TOutput) => Class<FlagSupportedSetup<TFlags_1, TSettings_1, TOutput>, [] | [Partial<TSettings_1>]>;
-}

package/dist/esm/rendering/setup/FlagSupportedSetup.js

@@ -1,22 +0,0 @@
-import { mergeObjects } from "../../lib/mergeObjects.js";
-export class FlagSupportedSetup {
-    flags;
-    settings;
-    constructor(flagsInput, settings) {
-        this.flags = flagsInput;
-        this.settings = settings;
-    }
-    getSetup(flags) {
-        return mergeObjects(this.settings, this.getFlagsOutput(flags));
-    }
-    static build = (flags, defaultSettings, buildFlagsOutput) => {
-        return class ConcreteRenderSetup extends FlagSupportedSetup {
-            constructor(settings) {
-                super(flags, mergeObjects(defaultSettings, settings ?? {}));
-            }
-            getFlagsOutput(flags) {
-                return buildFlagsOutput(flags, this.settings);
-            }
-        };
-    };
-}

package/dist/esm/rendering/setup/TableRenderSetup.d.ts

@@ -1,11 +0,0 @@
-import { FlagSupportedSetup, InferredOutput } from "./FlagSupportedSetup.js";
-export declare const TableRenderSetup: import("type-fest").Class<FlagSupportedSetup<{
-    columns: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    extended: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-    noTruncate: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-}, {}, {
-    visibleColumns: string[] | undefined;
-    extended: boolean;
-    noTruncate: boolean;
-}>, [] | [Partial<{}>]>;
-export type TableRenderSetupOutput = InferredOutput<typeof TableRenderSetup>;

package/dist/esm/rendering/setup/TableRenderSetup.js

@@ -1,24 +0,0 @@
-import { Flags } from "@oclif/core";
-import { FlagSupportedSetup } from "./FlagSupportedSetup.js";
-export const TableRenderSetup = FlagSupportedSetup.build({
-    columns: Flags.string({
-        exclusive: ["additional"],
-        description: "only show provided columns (comma-seperated)",
-    }),
-    extended: Flags.boolean({
-        description: "show extra columns",
-    }),
-    noTruncate: Flags.boolean({
-        default: false,
-        description: "do not truncate output to fit screen",
-    }),
-}, {}, (flags) => {
-    const visibleColumns = flags.columns
-        ?.split(",")
-        .map((colName) => colName.trim());
-    return {
-        visibleColumns,
-        extended: flags.extended,
-        noTruncate: flags.noTruncate,
-    };
-});

package/dist/esm/rendering/setup/usePromiseSetup.d.ts

@@ -1,12 +0,0 @@
-import { FlagSupportedSetup } from "./FlagSupportedSetup.js";
-import { usePromise } from "@mittwald/react-use-promise";
-import { Simplify } from "@mittwald/api-client-commons";
-type UsePromiseOptions = Simplify<Parameters<typeof usePromise>[2]>;
-export declare const UsePromiseRenderSetup: import("type-fest").Class<FlagSupportedSetup<{
-    wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<any>;
-}, {
-    refreshIntervalSeconds: number;
-}, UsePromiseOptions>, [] | [Partial<{
-    refreshIntervalSeconds: number;
-}>]>;
-export {};

package/dist/esm/rendering/setup/usePromiseSetup.js

@@ -1,11 +0,0 @@
-import { FlagSupportedSetup } from "./FlagSupportedSetup.js";
-import { Flags } from "@oclif/core";
-export const UsePromiseRenderSetup = FlagSupportedSetup.build({
-    wait: Flags.boolean(),
-}, { refreshIntervalSeconds: 5 }, (flags, settings) => ({
-    autoRefresh: flags.wait
-        ? {
-            seconds: settings.refreshIntervalSeconds,
-        }
-        : undefined,
-}));

package/dist/esm/types.d.ts

@@ -1,8 +0,0 @@
-import { Response } from "@mittwald/api-client-commons";
-import { BaseCommand } from "./BaseCommand.js";
-import { Interfaces } from "@oclif/core";
-export type SuccessfulResponse<T extends Response, S extends T["status"]> = T & {
-    status: S;
-};
-export type CommandFlags<T extends typeof BaseCommand> = Interfaces.InferredFlags<T["flags"]>;
-export type CommandArgs<T extends typeof BaseCommand> = Interfaces.InferredArgs<T["args"]>;