@start9labs/start-sdk 0.3.6-alpha1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Start9 Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# Start SDK
+
+## Config Conversion
+
+- Copy the old config json (from the getConfig.ts)
+- Install the start-sdk with `npm i`
+- paste the config into makeOutput.ts::oldSpecToBuilder (second param)
+- Make the third param
+
+```ts
+  {
+    StartSdk: "start-sdk/lib",
+  }
+```
+
+- run the script `npm run buildOutput` to make the output.ts
+- Copy this whole file into startos/procedures/config/spec.ts
+- Fix all the TODO

package/cjs/lib/Dependency.d.ts

@@ -0,0 +1,23 @@
+import { Checker } from "./emverLite/mod";
+export declare class Dependency {
+    readonly data: {
+        type: "running";
+        versionSpec: Checker;
+        registryUrl: string;
+        healthChecks: string[];
+    } | {
+        type: "exists";
+        versionSpec: Checker;
+        registryUrl: string;
+    };
+    constructor(data: {
+        type: "running";
+        versionSpec: Checker;
+        registryUrl: string;
+        healthChecks: string[];
+    } | {
+        type: "exists";
+        versionSpec: Checker;
+        registryUrl: string;
+    });
+}

package/cjs/lib/Dependency.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependency = void 0;
+class Dependency {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.Dependency = Dependency;
+//# sourceMappingURL=Dependency.js.map

package/cjs/lib/Dependency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dependency.js","sourceRoot":"","sources":["../../../lib/Dependency.ts"],"names":[],"mappings":";;;AAEA,MAAa,UAAU;IACrB,YACW,IAWJ;QAXI,SAAI,GAAJ,IAAI,CAWR;IACJ,CAAC;CACL;AAfD,gCAeC"}

package/cjs/lib/StartSdk.d.ts

@@ -0,0 +1,460 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { SDKManifest } from "./manifest/ManifestTypes";
+import { RequiredDefault, Value } from "./config/builder/value";
+import { Config, ExtractConfigType, LazyBuild } from "./config/builder/config";
+import { DefaultString, ListValueSpecText, Pattern, RandomString, UniqueBy, ValueSpecDatetime, ValueSpecText } from "./config/configTypes";
+import { Variants } from "./config/builder/variants";
+import { CreatedAction } from "./actions/createAction";
+import { ActionMetadata, Effects, ActionResult, BackupOptions, DeepPartial, MaybePromise, ServiceInterfaceId, PackageId, ValidIfNoStupidEscape } from "./types";
+import * as patterns from "./util/patterns";
+import { DependencyConfig, Update } from "./dependencies/DependencyConfig";
+import { BackupSet, Backups } from "./backup/Backups";
+import { Daemons } from "./mainFn/Daemons";
+import { HealthCheckParams } from "./health/HealthCheck";
+import { checkPortListening } from "./health/checkFns/checkPortListening";
+import { List } from "./config/builder/list";
+import { Migration } from "./inits/migrations/Migration";
+import { Install, InstallFn } from "./inits/setupInstall";
+import { SetupBackupsParams } from "./backup/setupBackups";
+import { EnsureUniqueId, Migrations } from "./inits/migrations/setupMigrations";
+import { Uninstall, UninstallFn } from "./inits/setupUninstall";
+import { changeOnFirstSuccess, cooldownTrigger } from "./trigger";
+import { DependenciesReceipt, Read, Save } from "./config/setupConfig";
+import { InterfacesReceipt, SetInterfaces } from "./interfaces/setupInterfaces";
+import { successFailure } from "./trigger/successFailure";
+import { HealthReceipt } from "./health/HealthReceipt";
+import { MultiHost, Scheme, SingleHost, StaticHost } from "./interfaces/Host";
+import { ServiceInterfaceBuilder } from "./interfaces/ServiceInterfaceBuilder";
+import { GetSystemSmtp } from "./util/GetSystemSmtp";
+import nullIfEmpty from "./util/nullIfEmpty";
+import { GetServiceInterface } from "./util/getServiceInterface";
+import { CommandOptions, MountOptions, Overlay } from "./util/Overlay";
+import { Mounts } from "./mainFn/Mounts";
+import { Dependency } from "./Dependency";
+import * as T from "./types";
+import { Checker, EmVer } from "./emverLite/mod";
+import { ExposedStorePaths } from "./store/setupExposeStore";
+import { PathBuilder } from "./store/PathBuilder";
+import { checkAllDependencies } from "./dependencies/dependencies";
+type AnyNeverCond<T extends any[], Then, Else> = T extends [] ? Else : T extends [never, ...Array<any>] ? Then : T extends [any, ...infer U] ? AnyNeverCond<U, Then, Else> : never;
+export type ServiceInterfaceType = "ui" | "p2p" | "api";
+export type MainEffects = Effects & {
+    _type: "main";
+};
+export type Signals = NodeJS.Signals;
+export declare const SIGTERM: Signals;
+export declare const SIGKILL: Signals;
+export declare const NO_TIMEOUT = -1;
+export declare class StartSdk<Manifest extends SDKManifest, Store> {
+    readonly manifest: Manifest;
+    private constructor();
+    static of(): StartSdk<never, never>;
+    withManifest<Manifest extends SDKManifest = never>(manifest: Manifest): StartSdk<Manifest, Store>;
+    withStore<Store extends Record<string, any>>(): StartSdk<Manifest, Store>;
+    build(isReady: AnyNeverCond<[Manifest, Store], "Build not ready", true>): {
+        checkAllDependencies: typeof checkAllDependencies;
+        serviceInterface: {
+            getOwn: <E extends Effects>(effects: E, id: ServiceInterfaceId) => GetServiceInterface & (E extends MainEffects ? {} : {
+                const: never;
+            });
+            get: <E_1 extends Effects>(effects: E_1, opts: {
+                id: ServiceInterfaceId;
+                packageId: PackageId;
+            }) => GetServiceInterface & (E_1 extends MainEffects ? {} : {
+                const: never;
+            });
+            getAllOwn: <E_2 extends Effects>(effects: E_2) => import("./util/getServiceInterfaces").GetServiceInterfaces & (E_2 extends MainEffects ? {} : {
+                const: never;
+            });
+            getAll: <E_3 extends Effects>(effects: E_3, opts: {
+                packageId: PackageId;
+            }) => import("./util/getServiceInterfaces").GetServiceInterfaces & (E_3 extends MainEffects ? {} : {
+                const: never;
+            });
+        };
+        store: {
+            get: <E_4 extends Effects, StoreValue = unknown>(effects: E_4, packageId: string, path: PathBuilder<Store, StoreValue>) => import("./store/getStore").GetStore<Store, StoreValue> & (E_4 extends MainEffects ? {} : {
+                const: never;
+            });
+            getOwn: <E_5 extends Effects, StoreValue_1 = unknown>(effects: E_5, path: PathBuilder<Store, StoreValue_1>) => import("./store/getStore").GetStore<Store, StoreValue_1> & (E_5 extends MainEffects ? {} : {
+                const: never;
+            });
+            setOwn: <E_6 extends Effects, Path extends import("./store/PathBuilder").PathBuilderStored<Store, unknown>>(effects: E_6, path: Path, value: Path extends PathBuilder<Store, infer Value_1> ? Value_1 : never) => Promise<void>;
+        };
+        host: {
+            static: (effects: Effects, id: string) => StaticHost;
+            single: (effects: Effects, id: string) => SingleHost;
+            multi: (effects: Effects, id: string) => MultiHost;
+        };
+        nullIfEmpty: typeof nullIfEmpty;
+        runCommand: <A extends string>(effects: Effects, image: {
+            id: Manifest["images"][number];
+            sharedRun?: boolean;
+        }, command: [string, ...string[]] | ValidIfNoStupidEscape<A>, options: CommandOptions & {
+            mounts?: {
+                path: string;
+                options: MountOptions;
+            }[] | undefined;
+        }) => Promise<{
+            stdout: string | Buffer;
+            stderr: string | Buffer;
+        }>;
+        createAction: <ConfigType extends Record<string, any> | Config<any, never> | Config<any, any>, Type extends Record<string, any> = ExtractConfigType<ConfigType>>(id: string, metaData: Omit<ActionMetadata, "input"> & {
+            input: Config<Type, Store> | Config<Type, never>;
+        }, fn: (options: {
+            effects: Effects;
+            input: Type;
+        }) => Promise<ActionResult>) => CreatedAction<Manifest, Store, ConfigType, Type>;
+        configConstants: {
+            smtpConfig: Value<{
+                unionSelectKey: "disabled";
+                unionValueKey: {};
+            } | {
+                unionSelectKey: "system";
+                unionValueKey: {
+                    customFrom: string | null | undefined;
+                };
+            } | {
+                unionSelectKey: "custom";
+                unionValueKey: {
+                    server: string;
+                    port: number;
+                    from: string;
+                    login: string;
+                    password: string | null | undefined;
+                };
+            }, never>;
+        };
+        createInterface: (effects: Effects, options: {
+            name: string;
+            id: string;
+            description: string;
+            hasPrimary: boolean;
+            disabled: boolean;
+            type: ServiceInterfaceType;
+            username: null | string;
+            path: string;
+            search: Record<string, string>;
+            schemeOverride: {
+                ssl: Scheme;
+                noSsl: Scheme;
+            } | null;
+            masked: boolean;
+        }) => ServiceInterfaceBuilder;
+        getSystemSmtp: <E_7 extends Effects>(effects: E_7) => GetSystemSmtp & (E_7 extends MainEffects ? {} : {
+            const: never;
+        });
+        createDynamicAction: <ConfigType_1 extends Record<string, any> | Config<any, never> | Config<any, any>, Type_1 extends Record<string, any> = ExtractConfigType<ConfigType_1>>(id: string, metaData: (options: {
+            effects: Effects;
+        }) => MaybePromise<Omit<ActionMetadata, "input">>, fn: (options: {
+            effects: Effects;
+            input: Type_1;
+        }) => Promise<ActionResult>, input: Config<Type_1, Store> | Config<Type_1, never>) => CreatedAction<Manifest, Store, ConfigType_1, Type_1>;
+        HealthCheck: {
+            of(o: HealthCheckParams<Manifest>): HealthReceipt;
+        };
+        Dependency: {
+            of(data: Dependency["data"]): Dependency;
+        };
+        healthCheck: {
+            checkPortListening: typeof checkPortListening;
+            checkWebUrl: (effects: Effects, url: string, { timeout, successMessage, errorMessage, }?: {
+                timeout?: number | undefined;
+                successMessage?: string | undefined;
+                errorMessage?: string | undefined;
+            }) => Promise<import("./health/checkFns").CheckResult>;
+            runHealthScript: (effects: Effects, runCommand: string[], overlay: Overlay, { timeout, errorMessage, message, }?: {
+                timeout?: number | undefined;
+                errorMessage?: string | undefined;
+                message?: ((res: string) => string) | undefined;
+            }) => Promise<import("./health/checkFns").CheckResult>;
+        };
+        patterns: typeof patterns;
+        setupActions: (...createdActions: CreatedAction<any, any, any>[]) => {
+            actions: T.ExpectedExports.actions;
+            actionsMetadata: T.ExpectedExports.actionsMetadata;
+        };
+        setupBackups: (...args: SetupBackupsParams<Manifest>) => {
+            createBackup: T.ExpectedExports.createBackup;
+            restoreBackup: T.ExpectedExports.restoreBackup;
+        };
+        setupConfig: <ConfigType_2 extends Config<any, never> | Config<any, Store>, Type_2 extends Record<string, any> = ExtractConfigType<ConfigType_2>>(spec: ConfigType_2, write: Save<Type_2>, read: Read<Manifest, Store, Type_2>) => {
+            setConfig: T.ExpectedExports.setConfig;
+            getConfig: T.ExpectedExports.getConfig;
+        };
+        setupConfigRead: <ConfigSpec extends Config<Record<string, any>, any> | Config<Record<string, never>, never>>(_configSpec: ConfigSpec, fn: Read<Manifest, Store, ConfigSpec>) => Read<Manifest, Store, ConfigSpec>;
+        setupConfigSave: <ConfigSpec_1 extends Config<Record<string, any>, any> | Config<Record<string, never>, never>>(_configSpec: ConfigSpec_1, fn: Save<ConfigSpec_1>) => Save<ConfigSpec_1>;
+        setupDependencyConfig: <Input extends Record<string, any>>(config: Config<Input, Store> | Config<Input, never>, autoConfigs: Manifest["dependencies"] extends infer T ? { [K in keyof T]: DependencyConfig<Manifest, Store, Input, any> | null; } : never) => T.ExpectedExports.dependencyConfig;
+        setupDependencies: <Input_1 extends Record<string, any>>(fn: (options: {
+            effects: Effects;
+            input: Input_1 | null;
+        }) => Promise<((Manifest["dependencies"] extends infer T_2 ? { [K_2 in keyof T_2]: Manifest["dependencies"][K_2]["optional"] extends false ? K_2 : never; } : never) extends infer T_1 ? { [K_1 in keyof T_1]: Dependency; } : never) & ((Manifest["dependencies"] extends infer T_4 ? { [K_4 in keyof T_4]: Manifest["dependencies"][K_4]["optional"] extends true ? K_4 : never; } : never) extends infer T_3 ? { [K_3 in keyof T_3]?: Dependency | undefined; } : never)>) => (options: {
+            effects: Effects;
+            input: Input_1;
+        }) => Promise<DependenciesReceipt>;
+        setupInit: (migrations: Migrations<Manifest, Store>, install: Install<Manifest, Store>, uninstall: Uninstall<Manifest, Store>, setInterfaces: SetInterfaces<Manifest, Store, any, any>, setDependencies: (options: {
+            effects: Effects;
+            input: any;
+        }) => Promise<DependenciesReceipt>, exposedStore: ExposedStorePaths) => {
+            init: T.ExpectedExports.init;
+            uninit: T.ExpectedExports.uninit;
+        };
+        setupInstall: (fn: InstallFn<Manifest, Store>) => Install<Manifest, Store>;
+        setupInterfaces: <ConfigInput extends Record<string, any>, Output extends InterfacesReceipt>(config: Config<ConfigInput, Store>, fn: SetInterfaces<Manifest, Store, ConfigInput, Output>) => SetInterfaces<Manifest, Store, ConfigInput, Output>;
+        setupMain: (fn: (o: {
+            effects: MainEffects;
+            started(onTerm: () => PromiseLike<void>): PromiseLike<void>;
+        }) => Promise<Daemons<Manifest, any>>) => T.ExpectedExports.main;
+        setupMigrations: <Migrations_1 extends Migration<Manifest, Store, any>[]>(...migrations: EnsureUniqueId<Migrations_1>) => Migrations<Manifest, Store>;
+        setupProperties: (fn: (options: {
+            effects: Effects;
+        }) => Promise<T.SdkPropertiesReturn>) => T.ExpectedExports.Properties;
+        setupUninstall: (fn: UninstallFn<Manifest, Store>) => Uninstall<Manifest, Store>;
+        trigger: {
+            defaultTrigger: import("./trigger").Trigger;
+            cooldownTrigger: typeof cooldownTrigger;
+            changeOnFirstSuccess: typeof changeOnFirstSuccess;
+            successFailure: typeof successFailure;
+        };
+        Mounts: {
+            of(): Mounts<Manifest>;
+        };
+        Backups: {
+            volumes: (...volumeNames: Array<Manifest["volumes"][number] & string>) => Backups<Manifest>;
+            addSets: (...options: BackupSet<Manifest["volumes"][number] & string>[]) => Backups<SDKManifest>;
+            withOptions: (options?: Partial<BackupOptions>) => Backups<SDKManifest>;
+        };
+        Config: {
+            of: <Spec extends Record<string, Value<any, never> | Value<any, Store>>>(spec: Spec) => Config<{ [K_5 in keyof Spec]: Spec[K_5] extends Value<infer T_5, never> | Value<infer T_5, Store> ? T_5 : never; }, Store>;
+        };
+        Checker: {
+            parse: typeof Checker.parse;
+        };
+        Daemons: {
+            of(config: {
+                effects: Effects;
+                started: (onTerm: () => PromiseLike<void>) => PromiseLike<void>;
+                healthReceipts: HealthReceipt[];
+            }): Daemons<Manifest, never>;
+        };
+        DependencyConfig: {
+            of<LocalConfig extends Record<string, any>, RemoteConfig extends Record<string, any>>({ localConfigSpec, remoteConfigSpec, dependencyConfig, update, }: {
+                localConfigSpec: Config<LocalConfig, Store> | Config<LocalConfig, never>;
+                remoteConfigSpec: Config<RemoteConfig, any> | Config<RemoteConfig, never>;
+                dependencyConfig: (options: {
+                    effects: Effects;
+                    localConfig: LocalConfig;
+                }) => Promise<void | DeepPartial<RemoteConfig>>;
+                update?: Update<void | DeepPartial<RemoteConfig>, RemoteConfig> | undefined;
+            }): DependencyConfig<Manifest, Store, LocalConfig, RemoteConfig>;
+        };
+        EmVer: {
+            from: typeof EmVer.from;
+            parse: typeof EmVer.parse;
+        };
+        List: {
+            text: typeof List.text;
+            number: typeof List.number;
+            obj: <Type_3 extends Record<string, any>>(a: {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                /** Default [] */
+                default?: [];
+                minLength?: number | null;
+                maxLength?: number | null;
+            }, aSpec: {
+                spec: Config<Type_3, Store>;
+                displayAs?: string | null | undefined;
+                uniqueBy?: UniqueBy | undefined;
+            }) => List<Type_3[], Store>;
+            dynamicText: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                /** Default = [] */
+                default?: string[];
+                minLength?: number | null;
+                maxLength?: number | null;
+                disabled?: false | string;
+                generate?: null | RandomString;
+                spec: {
+                    /** Default = false */
+                    masked?: boolean;
+                    placeholder?: string | null;
+                    minLength?: number | null;
+                    maxLength?: number | null;
+                    patterns: Pattern[];
+                    /** Default = "text" */
+                    inputmode?: ListValueSpecText["inputmode"];
+                };
+            }>) => List<string[], Store>;
+            dynamicNumber: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                /** Default = [] */
+                default?: string[];
+                minLength?: number | null;
+                maxLength?: number | null;
+                disabled?: false | string;
+                spec: {
+                    integer: boolean;
+                    min?: number | null;
+                    max?: number | null;
+                    step?: number | null;
+                    units?: string | null;
+                    placeholder?: string | null;
+                };
+            }>) => List<number[], Store>;
+        };
+        Migration: {
+            of: <Version extends `${number}` | `${number}-${string}` | `${number}.${number}` | `${number}.${number}-${string}` | `${number}.${number}.${number}` | `${number}.${number}.${number}-${string}`>(options: {
+                version: Version;
+                up: (opts: {
+                    effects: Effects;
+                }) => Promise<void>;
+                down: (opts: {
+                    effects: Effects;
+                }) => Promise<void>;
+            }) => Migration<Manifest, Store, Version>;
+        };
+        StorePath: PathBuilder<Store, Store>;
+        Value: {
+            toggle: typeof Value.toggle;
+            text: typeof Value.text;
+            textarea: typeof Value.textarea;
+            number: typeof Value.number;
+            color: typeof Value.color;
+            datetime: typeof Value.datetime;
+            select: typeof Value.select;
+            multiselect: typeof Value.multiselect;
+            object: typeof Value.object;
+            union: typeof Value.union;
+            list: typeof Value.list;
+            dynamicToggle: (a: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                default: boolean;
+                disabled?: false | string;
+            }>) => Value<boolean, Store>;
+            dynamicText: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                required: RequiredDefault<DefaultString>;
+                /** Default = false */
+                masked?: boolean;
+                placeholder?: string | null;
+                minLength?: number | null;
+                maxLength?: number | null;
+                patterns?: Pattern[];
+                /** Default = 'text' */
+                inputmode?: ValueSpecText["inputmode"];
+                generate?: null | RandomString;
+            }>) => Value<string | null | undefined, Store>;
+            dynamicTextarea: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                required: boolean;
+                minLength?: number | null;
+                maxLength?: number | null;
+                placeholder?: string | null;
+                disabled?: false | string;
+                generate?: null | RandomString;
+            }>) => Value<string, Store>;
+            dynamicNumber: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                required: RequiredDefault<number>;
+                min?: number | null;
+                max?: number | null;
+                /** Default = '1' */
+                step?: number | null;
+                integer: boolean;
+                units?: string | null;
+                placeholder?: string | null;
+                disabled?: false | string;
+            }>) => Value<number | null | undefined, Store>;
+            dynamicColor: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                required: RequiredDefault<string>;
+                disabled?: false | string;
+            }>) => Value<string | null | undefined, Store>;
+            dynamicDatetime: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                required: RequiredDefault<string>;
+                /** Default = 'datetime-local' */
+                inputmode?: ValueSpecDatetime["inputmode"];
+                min?: string | null;
+                max?: string | null;
+                disabled?: false | string;
+            }>) => Value<string | null | undefined, Store>;
+            dynamicSelect: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                required: RequiredDefault<string>;
+                values: Record<string, string>;
+                disabled?: false | string;
+            }>) => Value<string | null | undefined, Store>;
+            dynamicMultiselect: (getA: LazyBuild<Store, {
+                name: string;
+                description?: string | null;
+                warning?: string | null;
+                default: string[];
+                values: Record<string, string>;
+                minLength?: number | null;
+                maxLength?: number | null;
+                disabled?: false | string;
+            }>) => Value<string[], Store>;
+            filteredUnion: <Required_1 extends RequiredDefault<string>, Type_4 extends Record<string, any>>(getDisabledFn: LazyBuild<Store, string[]>, a: {
+                name: string;
+                description?: string | null | undefined;
+                warning?: string | null | undefined;
+                required: Required_1;
+            }, aVariants: Variants<Type_4, Store> | Variants<Type_4, never>) => Value<Required_1 extends {
+                default: unknown;
+            } ? Type_4 : Type_4 | null | undefined, Store>;
+            dynamicUnion: <Required_2 extends RequiredDefault<string>, Type_5 extends Record<string, any>>(getA: LazyBuild<Store, {
+                disabled: string[] | false | string;
+                name: string;
+                description?: string | null | undefined;
+                warning?: string | null | undefined;
+                required: Required_2;
+            }>, aVariants: Variants<Type_5, Store> | Variants<Type_5, never>) => Value<Type_5 | null | undefined, Store>;
+        };
+        Variants: {
+            of: <VariantValues extends {
+                [x: string]: {
+                    name: string;
+                    spec: Config<any, Store>;
+                };
+            }>(a: VariantValues) => Variants<{ [K_6 in keyof VariantValues]: {
+                unionSelectKey: K_6;
+                unionValueKey: VariantValues[K_6]["spec"] extends Config<infer B extends Record<string, any>, never> | Config<infer B extends Record<string, any>, Store> ? B : never;
+            }; }[keyof VariantValues], Store>;
+        };
+    };
+}
+export declare function runCommand<Manifest extends SDKManifest>(effects: Effects, image: {
+    id: Manifest["images"][number];
+    sharedRun?: boolean;
+}, command: string | [string, ...string[]], options: CommandOptions & {
+    mounts?: {
+        path: string;
+        options: MountOptions;
+    }[];
+}): Promise<{
+    stdout: string | Buffer;
+    stderr: string | Buffer;
+}>;
+export {};