@start9labs/start-sdk 0.3.6-alpha8 → 0.3.6-alpha9

package/mjs/lib/StartSdk.d.ts

@@ -1,408 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-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 } 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 { Install, InstallFn } from "./inits/setupInstall";
-import { SetupBackupsParams } from "./backup/setupBackups";
-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 { HealthReceipt } from "./health/HealthReceipt";
-import { MultiHost, Scheme } 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 { ExposedStorePaths } from "./store/setupExposeStore";
-import { PathBuilder } from "./store/PathBuilder";
-import { CheckDependencies } from "./dependencies/dependencies";
-import { GetSslCertificate } from "./util/GetSslCertificate";
-import { VersionGraph } from "./version";
-export declare const SDKVersion: "0.3.6";
-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";
-    clearCallbacks: () => Promise<void>;
-};
-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 T.Manifest, Store> {
-    readonly manifest: Manifest;
-    private constructor();
-    static of(): StartSdk<never, never>;
-    withManifest<Manifest extends T.Manifest = never>(manifest: Manifest): StartSdk<Manifest, Store>;
-    withStore<Store extends Record<string, any>>(): StartSdk<Manifest, Store>;
-    build(isReady: AnyNeverCond<[Manifest, Store], "Build not ready", true>): {
-        checkDependencies: <DependencyId extends keyof Manifest["dependencies"] & string = keyof Manifest["dependencies"] & string>(effects: Effects, packageIds?: DependencyId[] | undefined) => Promise<CheckDependencies<DependencyId>>;
-        serviceInterface: {
-            getOwn: <E extends Effects>(effects: E, id: ServiceInterfaceId) => E extends MainEffects ? GetServiceInterface : Omit<GetServiceInterface, "const" | "watch">;
-            get: <E_1 extends Effects>(effects: E_1, opts: {
-                id: ServiceInterfaceId;
-                packageId: PackageId;
-            }) => E_1 extends MainEffects ? GetServiceInterface : Omit<GetServiceInterface, "const" | "watch">;
-            getAllOwn: <E_2 extends Effects>(effects: E_2) => E_2 extends MainEffects ? import("./util/getServiceInterfaces").GetServiceInterfaces : Omit<import("./util/getServiceInterfaces").GetServiceInterfaces, "const" | "watch">;
-            getAll: <E_3 extends Effects>(effects: E_3, opts: {
-                packageId: PackageId;
-            }) => E_3 extends MainEffects ? import("./util/getServiceInterfaces").GetServiceInterfaces : Omit<import("./util/getServiceInterfaces").GetServiceInterfaces, "const" | "watch">;
-        };
-        store: {
-            get: <E_4 extends Effects, StoreValue = unknown>(effects: E_4, packageId: string, path: PathBuilder<Store, StoreValue>) => E_4 extends MainEffects ? import("./store/getStore").GetStore<Store, StoreValue> : Omit<import("./store/getStore").GetStore<Store, StoreValue>, "const" | "watch">;
-            getOwn: <E_5 extends Effects, StoreValue_1 = unknown>(effects: E_5, path: PathBuilder<Store, StoreValue_1>) => E_5 extends MainEffects ? import("./store/getStore").GetStore<Store, StoreValue_1> : Omit<import("./store/getStore").GetStore<Store, StoreValue_1>, "const" | "watch">;
-            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: {
-            multi: (effects: Effects, id: string) => MultiHost;
-        };
-        nullIfEmpty: typeof nullIfEmpty;
-        runCommand: <A extends string>(effects: Effects, image: {
-            id: keyof Manifest["images"] & T.ImageId;
-            sharedRun?: boolean;
-        }, command: T.CommandType, options: CommandOptions & {
-            mounts?: {
-                path: string;
-                options: MountOptions;
-            }[] | undefined;
-        }) => Promise<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
-        }>;
-        createAction: <ConfigType extends Record<string, any> | Config<any, any> | Config<any, never>, 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<{
-                selection: "disabled";
-                value: {};
-            } | {
-                selection: "system";
-                value: {
-                    customFrom: string | null | undefined;
-                };
-            } | {
-                selection: "custom";
-                value: {
-                    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;
-            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) => E_7 extends MainEffects ? GetSystemSmtp : Omit<GetSystemSmtp, "const" | "watch">;
-        getSslCerificate: <E_8 extends Effects>(effects: E_8, hostnames: string[], algorithm?: T.Algorithm) => E_8 extends MainEffects ? GetSslCertificate : Omit<GetSslCertificate, "const" | "watch">;
-        createDynamicAction: <ConfigType_1 extends Record<string, any> | Config<any, any> | Config<any, never>, 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): 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").HealthCheckResult>;
-            runHealthScript: (runCommand: string[], overlay: Overlay, { timeout, errorMessage, message, }?: {
-                timeout?: number | undefined;
-                errorMessage?: string | undefined;
-                message?: ((res: string) => string) | undefined;
-            }) => Promise<import("./health/checkFns").HealthCheckResult>;
-        };
-        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: (versions: VersionGraph<Manifest["version"]>, 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;
-        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: (o: {
-                duringSuccess: import("./trigger").Trigger;
-                duringError: import("./trigger").Trigger;
-            }) => import("./trigger").Trigger;
-        };
-        Mounts: {
-            of(): Mounts<Manifest>;
-        };
-        Backups: {
-            volumes: (...volumeNames: Array<Manifest["volumes"][number] & string>) => Backups<Manifest>;
-            addSets: (...options: BackupSet<Manifest["volumes"][number] & string>[]) => Backups<T.Manifest>;
-            withOptions: (options?: Partial<BackupOptions>) => Backups<T.Manifest>;
-        };
-        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>;
-        };
-        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>;
-        };
-        List: {
-            text: typeof List.text;
-            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>;
-        };
-        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]: {
-                selection: K_6;
-                value: 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 T.Manifest>(effects: Effects, image: {
-    id: keyof Manifest["images"] & T.ImageId;
-    sharedRun?: boolean;
-}, command: string | [string, ...string[]], options: CommandOptions & {
-    mounts?: {
-        path: string;
-        options: MountOptions;
-    }[];
-}): Promise<{
-    stdout: string | Buffer;
-    stderr: string | Buffer;
-}>;
-export {};

package/mjs/lib/StartSdk.js

@@ -1,247 +0,0 @@
-import { Value } from "./config/builder/value";
-import { Config } from "./config/builder/config";
-import { Variants } from "./config/builder/variants";
-import { createAction } from "./actions/createAction";
-import * as patterns from "./util/patterns";
-import { DependencyConfig } from "./dependencies/DependencyConfig";
-import { Backups } from "./backup/Backups";
-import { smtpConfig } from "./config/configConstants";
-import { Daemons } from "./mainFn/Daemons";
-import { healthCheck } from "./health/HealthCheck";
-import { checkPortListening } from "./health/checkFns/checkPortListening";
-import { checkWebUrl, runHealthScript } from "./health/checkFns";
-import { List } from "./config/builder/list";
-import { Install } from "./inits/setupInstall";
-import { setupActions } from "./actions/setupActions";
-import { setupDependencyConfig } from "./dependencies/setupDependencyConfig";
-import { setupBackups } from "./backup/setupBackups";
-import { setupInit } from "./inits/setupInit";
-import { setupUninstall } from "./inits/setupUninstall";
-import { setupMain } from "./mainFn";
-import { defaultTrigger } from "./trigger/defaultTrigger";
-import { changeOnFirstSuccess, cooldownTrigger } from "./trigger";
-import setupConfig from "./config/setupConfig";
-import { setupInterfaces, } from "./interfaces/setupInterfaces";
-import { successFailure } from "./trigger/successFailure";
-import { MultiHost } from "./interfaces/Host";
-import { ServiceInterfaceBuilder } from "./interfaces/ServiceInterfaceBuilder";
-import { GetSystemSmtp } from "./util/GetSystemSmtp";
-import nullIfEmpty from "./util/nullIfEmpty";
-import { getServiceInterface, } from "./util/getServiceInterface";
-import { getServiceInterfaces } from "./util/getServiceInterfaces";
-import { getStore } from "./store/getStore";
-import { Overlay } from "./util/Overlay";
-import { splitCommand } from "./util/splitCommand";
-import { Mounts } from "./mainFn/Mounts";
-import { Dependency } from "./Dependency";
-import { testTypeVersion } from "./exver";
-import { extractJsonPath, pathBuilder } from "./store/PathBuilder";
-import { checkDependencies, } from "./dependencies/dependencies";
-import { GetSslCertificate } from "./util/GetSslCertificate";
-export const SDKVersion = testTypeVersion("0.3.6");
-export const SIGTERM = "SIGTERM";
-export const SIGKILL = "SIGKILL";
-export const NO_TIMEOUT = -1;
-function removeCallbackTypes(effects) {
-    return (t) => {
-        if ("_type" in effects && effects._type === "main") {
-            return t;
-        }
-        else {
-            if ("const" in t) {
-                delete t.const;
-            }
-            if ("watch" in t) {
-                delete t.watch;
-            }
-            return t;
-        }
-    };
-}
-export class StartSdk {
-    manifest;
-    constructor(manifest) {
-        this.manifest = manifest;
-    }
-    static of() {
-        return new StartSdk(null);
-    }
-    withManifest(manifest) {
-        return new StartSdk(manifest);
-    }
-    withStore() {
-        return new StartSdk(this.manifest);
-    }
-    build(isReady) {
-        return {
-            checkDependencies: checkDependencies,
-            serviceInterface: {
-                getOwn: (effects, id) => removeCallbackTypes(effects)(getServiceInterface(effects, {
-                    id,
-                })),
-                get: (effects, opts) => removeCallbackTypes(effects)(getServiceInterface(effects, opts)),
-                getAllOwn: (effects) => removeCallbackTypes(effects)(getServiceInterfaces(effects, {})),
-                getAll: (effects, opts) => removeCallbackTypes(effects)(getServiceInterfaces(effects, opts)),
-            },
-            store: {
-                get: (effects, packageId, path) => removeCallbackTypes(effects)(getStore(effects, path, {
-                    packageId,
-                })),
-                getOwn: (effects, path) => removeCallbackTypes(effects)(getStore(effects, path)),
-                setOwn: (effects, path, value) => effects.store.set({
-                    value,
-                    path: extractJsonPath(path),
-                }),
-            },
-            host: {
-                // static: (effects: Effects, id: string) =>
-                //   new StaticHost({ id, effects }),
-                // single: (effects: Effects, id: string) =>
-                //   new SingleHost({ id, effects }),
-                multi: (effects, id) => new MultiHost({ id, effects }),
-            },
-            nullIfEmpty,
-            runCommand: async (effects, image, command, options) => {
-                return runCommand(effects, image, command, options);
-            },
-            createAction: (id, metaData, fn) => {
-                const { input, ...rest } = metaData;
-                return createAction(id, rest, fn, input);
-            },
-            configConstants: { smtpConfig },
-            createInterface: (effects, options) => new ServiceInterfaceBuilder({ ...options, effects }),
-            getSystemSmtp: (effects) => removeCallbackTypes(effects)(new GetSystemSmtp(effects)),
-            getSslCerificate: (effects, hostnames, algorithm) => removeCallbackTypes(effects)(new GetSslCertificate(effects, hostnames, algorithm)),
-            createDynamicAction: (id, metaData, fn, input) => {
-                return createAction(id, metaData, fn, input);
-            },
-            HealthCheck: {
-                of(o) {
-                    return healthCheck(o);
-                },
-            },
-            Dependency: {
-                of(data) {
-                    return new Dependency({ ...data });
-                },
-            },
-            healthCheck: {
-                checkPortListening,
-                checkWebUrl,
-                runHealthScript,
-            },
-            patterns,
-            setupActions: (...createdActions) => setupActions(...createdActions),
-            setupBackups: (...args) => setupBackups(this.manifest, ...args),
-            setupConfig: (spec, write, read) => setupConfig(spec, write, read),
-            setupConfigRead: (_configSpec, fn) => fn,
-            setupConfigSave: (_configSpec, fn) => fn,
-            setupDependencyConfig: (config, autoConfigs) => setupDependencyConfig(config, autoConfigs),
-            setupDependencies: (fn) => {
-                return async (options) => {
-                    const dependencyType = await fn(options);
-                    return await options.effects.setDependencies({
-                        dependencies: Object.entries(dependencyType).map(([id, { data: { versionRange, ...x }, },]) => ({
-                            id,
-                            ...x,
-                            ...(x.type === "running"
-                                ? {
-                                    kind: "running",
-                                    healthChecks: x.healthChecks,
-                                }
-                                : {
-                                    kind: "exists",
-                                }),
-                            versionRange: versionRange.toString(),
-                        })),
-                    });
-                };
-            },
-            setupInit: (versions, install, uninstall, setInterfaces, setDependencies, exposedStore) => setupInit(versions, install, uninstall, setInterfaces, setDependencies, exposedStore),
-            setupInstall: (fn) => Install.of(fn),
-            setupInterfaces: (config, fn) => setupInterfaces(config, fn),
-            setupMain: (fn) => setupMain(fn),
-            setupProperties: (fn) => (options) => fn(options).then(nullifyProperties),
-            setupUninstall: (fn) => setupUninstall(fn),
-            trigger: {
-                defaultTrigger,
-                cooldownTrigger,
-                changeOnFirstSuccess,
-                successFailure,
-            },
-            Mounts: {
-                of() {
-                    return Mounts.of();
-                },
-            },
-            Backups: {
-                volumes: (...volumeNames) => Backups.volumes(...volumeNames),
-                addSets: (...options) => Backups.addSets(...options),
-                withOptions: (options) => Backups.with_options(options),
-            },
-            Config: {
-                of: (spec) => Config.of(spec),
-            },
-            Daemons: {
-                of(config) {
-                    return Daemons.of(config);
-                },
-            },
-            DependencyConfig: {
-                of({ localConfigSpec, remoteConfigSpec, dependencyConfig, update, }) {
-                    return new DependencyConfig(dependencyConfig, update);
-                },
-            },
-            List: {
-                text: List.text,
-                obj: (a, aSpec) => List.obj(a, aSpec),
-                dynamicText: (getA) => List.dynamicText(getA),
-            },
-            StorePath: pathBuilder(),
-            Value: {
-                toggle: Value.toggle,
-                text: Value.text,
-                textarea: Value.textarea,
-                number: Value.number,
-                color: Value.color,
-                datetime: Value.datetime,
-                select: Value.select,
-                multiselect: Value.multiselect,
-                object: Value.object,
-                union: Value.union,
-                list: Value.list,
-                dynamicToggle: (a) => Value.dynamicToggle(a),
-                dynamicText: (getA) => Value.dynamicText(getA),
-                dynamicTextarea: (getA) => Value.dynamicTextarea(getA),
-                dynamicNumber: (getA) => Value.dynamicNumber(getA),
-                dynamicColor: (getA) => Value.dynamicColor(getA),
-                dynamicDatetime: (getA) => Value.dynamicDatetime(getA),
-                dynamicSelect: (getA) => Value.dynamicSelect(getA),
-                dynamicMultiselect: (getA) => Value.dynamicMultiselect(getA),
-                filteredUnion: (getDisabledFn, a, aVariants) => Value.filteredUnion(getDisabledFn, a, aVariants),
-                dynamicUnion: (getA, aVariants) => Value.dynamicUnion(getA, aVariants),
-            },
-            Variants: {
-                of: (a) => Variants.of(a),
-            },
-        };
-    }
-}
-export async function runCommand(effects, image, command, options) {
-    const commands = splitCommand(command);
-    return Overlay.with(effects, image, options.mounts || [], (overlay) => overlay.exec(commands));
-}
-function nullifyProperties(value) {
-    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, nullifyProperties_(v)]));
-}
-function nullifyProperties_(value) {
-    if (value.type === "string") {
-        return { description: null, copyable: null, qr: null, ...value };
-    }
-    return {
-        description: null,
-        ...value,
-        value: Object.fromEntries(Object.entries(value.value).map(([k, v]) => [k, nullifyProperties_(v)])),
-    };
-}
-//# sourceMappingURL=StartSdk.js.map