@start9labs/start-sdk 0.4.0-beta.5 → 0.4.0-beta.51

package/package/lib/StartSdk.d.ts

@@ -1,92 +1,78 @@
-import { Value } from "../../base/lib/actions/input/builder/value";
-import { InputSpec, LazyBuild } from "../../base/lib/actions/input/builder/inputSpec";
-import { DefaultString, ListValueSpecText, Pattern, RandomString, ValueSpecDatetime, ValueSpecText } from "../../base/lib/actions/input/inputSpecTypes";
-import { Variants } from "../../base/lib/actions/input/builder/variants";
-import { Action, Actions } from "../../base/lib/actions/setupActions";
-import { SyncOptions, ServiceInterfaceId, PackageId, ServiceInterfaceType, Effects } from "../../base/lib/types";
-import * as patterns from "../../base/lib/util/patterns";
-import { BackupSync, Backups } from "./backup/Backups";
-import { Daemons } from "./mainFn/Daemons";
-import { HealthCheck } from "./health/HealthCheck";
-import { checkPortListening } from "./health/checkFns/checkPortListening";
-import { List } from "../../base/lib/actions/input/builder/list";
-import { InstallFn, PostInstall, PreInstall } from "./inits/setupInstall";
-import { SetupBackupsParams } from "./backup/setupBackups";
-import { UninstallFn } from "./inits/setupUninstall";
-import { changeOnFirstSuccess, cooldownTrigger } from "./trigger";
-import { UpdateServiceInterfaces } from "../../base/lib/interfaces/setupInterfaces";
-import { MultiHost, Scheme } from "../../base/lib/interfaces/Host";
-import { ServiceInterfaceBuilder } from "../../base/lib/interfaces/ServiceInterfaceBuilder";
-import { GetSystemSmtp } from "./util";
-import { nullIfEmpty } from "./util";
-import { CommandOptions, SubContainer } from "./util/SubContainer";
-import { Mounts } from "./mainFn/Mounts";
-import * as T from "../../base/lib/types";
-import { ExposedStorePaths } from "./store/setupExposeStore";
-import { PathBuilder } from "../../base/lib/util/PathBuilder";
-import { CheckDependencies } from "../../base/lib/dependencies/dependencies";
-import { GetSslCertificate } from "./util";
-import { VersionGraph } from "./version";
-import { MaybeFn } from "../../base/lib/actions/setupActions";
-import { GetInput } from "../../base/lib/actions/setupActions";
-import { Run } from "../../base/lib/actions/setupActions";
-import * as actions from "../../base/lib/actions";
-export declare const OSVersion: "0.4.0-alpha.0";
+import { Value } from '../../base/lib/actions/input/builder/value';
+import { InputSpec } from '../../base/lib/actions/input/builder/inputSpec';
+import { Variants } from '../../base/lib/actions/input/builder/variants';
+import { Action, ActionInfo, Actions } from '../../base/lib/actions/setupActions';
+import { ServiceInterfaceType, Effects } from '../../base/lib/types';
+import * as patterns from '../../base/lib/util/patterns';
+import { Backups } from './backup/Backups';
+import { Daemon, Daemons } from './mainFn/Daemons';
+import { checkPortListening } from './health/checkFns/checkPortListening';
+import { List } from '../../base/lib/actions/input/builder/list';
+import { SetupBackupsParams } from './backup/setupBackups';
+import { changeOnFirstSuccess, cooldownTrigger } from './trigger';
+import { MultiHost, Scheme } from '../../base/lib/interfaces/Host';
+import { ServiceInterfaceBuilder } from '../../base/lib/interfaces/ServiceInterfaceBuilder';
+import { GetOutboundGateway, GetSystemSmtp } from './util';
+import { nullIfEmpty } from './util';
+import { getServiceInterface, getServiceInterfaces } from './util';
+import { CommandOptions, SubContainer } from './util/SubContainer';
+import { Mounts } from './mainFn/Mounts';
+import * as T from '../../base/lib/types';
+import { CheckDependencies } from '../../base/lib/dependencies/dependencies';
+import { GetSslCertificate, getServiceManifest } from './util';
+import { getDataVersion, setDataVersion } from './version';
+import { MaybeFn } from '../../base/lib/actions/setupActions';
+import { Run } from '../../base/lib/actions/setupActions';
+import * as actions from '../../base/lib/actions';
+import { setupInit, setupUninit, setupOnInit, setupOnUninit } from '../../base/lib/inits';
+import { DropGenerator } from '../../base/lib/util/Drop';
+import { getOwnServiceInterface } from '../../base/lib/util/getServiceInterface';
+import { getOwnServiceInterfaces } from '../../base/lib/util/getServiceInterfaces';
+import { Volumes } from './util/Volume';
+export declare const OSVersion: "0.4.0-alpha.20";
 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 declare class StartSdk<Manifest extends T.SDKManifest, Store> {
+export declare class StartSdk<Manifest extends T.SDKManifest> {
     readonly manifest: Manifest;
     private constructor();
-    static of(): StartSdk<never, never>;
-    withManifest<Manifest extends T.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>): {
+    static of(): StartSdk<never>;
+    withManifest<Manifest extends T.SDKManifest = never>(manifest: Manifest): StartSdk<Manifest>;
+    private ifPluginEnabled;
+    build(isReady: AnyNeverCond<[Manifest], 'Build not ready', true>): {
+        setDataVersion: typeof setDataVersion;
+        getDataVersion: typeof getDataVersion;
         action: {
             run: <Input extends Record<string, unknown>>(options: {
                 effects: T.Effects;
                 actionId: T.ActionId;
                 input?: actions.RunActionInput<Input>;
             }) => Promise<T.ActionResult | null>;
-            request: <T extends Action<T.ActionId, any, any>>(effects: T.Effects, packageId: T.PackageId, action: T, severity: T.ActionSeverity, options?: actions.ActionRequestOptions<T>) => Promise<null>;
-            requestOwn: <T extends Action<T.ActionId, Store, any>>(effects: T.Effects, action: T, severity: T.ActionSeverity, options?: actions.ActionRequestOptions<T>) => Promise<null>;
-            clearRequest: (effects: T.Effects, ...replayIds: string[]) => Promise<null>;
+            createTask: <T extends ActionInfo<T.ActionId, any>>(effects: T.Effects, packageId: T.PackageId, action: T, severity: T.TaskSeverity, options?: actions.TaskOptions<T>) => Promise<null>;
+            createOwnTask: <T extends ActionInfo<T.ActionId, any>>(effects: T.Effects, action: T, severity: T.TaskSeverity, options?: actions.TaskOptions<T>) => Promise<null>;
+            clearTask: (effects: T.Effects, ...replayIds: string[]) => Promise<null>;
         };
-        checkDependencies: <DependencyId extends keyof Manifest["dependencies"] & PackageId = keyof Manifest["dependencies"] & PackageId>(effects: Effects, packageIds?: DependencyId[]) => Promise<CheckDependencies<DependencyId>>;
+        checkDependencies: <DependencyId extends keyof Manifest["dependencies"] & T.PackageId = keyof Manifest["dependencies"] & T.PackageId>(effects: Effects, packageIds?: DependencyId[]) => Promise<CheckDependencies<DependencyId>>;
         serviceInterface: {
-            getOwn: <E extends Effects>(effects: E, id: ServiceInterfaceId) => import("./util").GetServiceInterface;
-            get: <E extends Effects>(effects: E, opts: {
-                id: ServiceInterfaceId;
-                packageId: PackageId;
-            }) => import("./util").GetServiceInterface;
-            getAllOwn: <E extends Effects>(effects: E) => import("../../base/lib/util/getServiceInterfaces").GetServiceInterfaces;
-            getAll: <E extends Effects>(effects: E, opts: {
-                packageId: PackageId;
-            }) => import("../../base/lib/util/getServiceInterfaces").GetServiceInterfaces;
+            getOwn: typeof getOwnServiceInterface;
+            get: typeof getServiceInterface;
+            getAllOwn: typeof getOwnServiceInterfaces;
+            getAll: typeof getServiceInterfaces;
         };
         getContainerIp: (effects: T.Effects, options?: Omit<Parameters<T.Effects["getContainerIp"]>[0], "callback">) => {
             const: () => Promise<string>;
             once: () => Promise<string>;
-            watch: () => AsyncGenerator<string, void, unknown>;
-            onChange: (callback: (value: string | null, error?: Error) => void | Promise<void>) => void;
-        };
-        store: {
-            get: <E extends Effects, StoreValue = unknown>(effects: E, packageId: string, path: PathBuilder<Store, StoreValue>) => import("./store/getStore").GetStore<Store, StoreValue>;
-            getOwn: <E extends Effects, StoreValue = unknown>(effects: E, path: PathBuilder<Store, StoreValue>) => import("./store/getStore").GetStore<Store, StoreValue>;
-            setOwn: <E extends Effects, Path extends PathBuilder<Store, unknown>>(effects: E, path: Path, value: Path extends PathBuilder<Store, infer Value> ? Value : never) => Promise<null>;
+            watch: (abort?: AbortSignal) => DropGenerator<string, void, unknown>;
+            onChange: (callback: (value: string | null, error?: Error) => {
+                cancel: boolean;
+            } | Promise<{
+                cancel: boolean;
+            }>) => void;
+            waitFor: (pred: (value: string | null) => boolean) => Promise<string | null>;
         };
         MultiHost: {
             of: (effects: Effects, id: string) => MultiHost;
         };
         nullIfEmpty: typeof nullIfEmpty;
         useEntrypoint: (overrideCmd?: string[]) => T.UseEntrypoint;
-        runCommand: <A extends string>(effects: Effects, image: {
-            imageId: keyof Manifest["images"] & T.ImageId;
-            sharedRun?: boolean;
-        }, command: T.CommandType, options: CommandOptions & {
-            mounts: Mounts<Manifest> | null;
-        }, name?: string) => Promise<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
-        }>;
         /**
          * @description Use this class to create an Action. By convention, each Action should receive its own file.
          *
@@ -149,7 +135,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
               )
              * ```
             */
-            withInput: <Id extends T.ActionId, InputSpecType extends Record<string, any> | InputSpec<any, any> | InputSpec<any, never>>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, inputSpec: InputSpecType, getInput: GetInput<InputSpecType>, run: Run<InputSpecType>) => Action<Id, unknown, InputSpecType>;
+            withInput: typeof Action.withInput;
             /**
              * @description Use this function to create an action that does not accept form input
              * @param id - a unique ID for this action
@@ -159,6 +145,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
              * In this example, we create an action that returns a secret phrase for the user to see.
              *
              * ```
+              import { store } from '../file-models/store.json'
               import { sdk } from '../sdk'
     
               export const showSecretPhrase = sdk.Action.withoutInput(
@@ -183,9 +170,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                     'Below is your secret phrase. Use it to gain access to extraordinary places',
                   result: {
                     type: 'single',
-                    value: await sdk.store
-                      .getOwn(effects, sdk.StorePath.secretPhrase)
-                      .const(),
+                    value: (await store.read.once())?.secretPhrase,
                     copyable: true,
                     qr: true,
                     masked: true,
@@ -194,31 +179,44 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
               )
              * ```
             */
-            withoutInput: <Id extends T.ActionId>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, run: Run<{}>) => Action<Id, unknown, {}>;
+            withoutInput: <Id extends T.ActionId>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, run: Run<{}>) => Action<Id, {}>;
         };
         inputSpecConstants: {
-            smtpInputSpec: Value<import("../../base/lib/actions/input/builder/variants").UnionRes<never, {
+            smtpInputSpec: Value<import("../../base/lib/actions/input/builder/variants").UnionRes<{
                 disabled: {
                     name: string;
-                    spec: InputSpec<{}, Store_1>;
+                    spec: InputSpec<{}, {}>;
                 };
                 system: {
                     name: string;
                     spec: InputSpec<{
                         customFrom: string | null;
-                    }, Store_1>;
+                    }, {
+                        customFrom: string | null;
+                    }>;
                 };
                 custom: {
+                    name: string;
+                    spec: InputSpec<T.SmtpValue, T.SmtpValue>;
+                };
+            }>, import("../../base/lib/actions/input/builder/variants").UnionResStaticValidatedAs<{
+                disabled: {
+                    name: string;
+                    spec: InputSpec<{}, {}>;
+                };
+                system: {
                     name: string;
                     spec: InputSpec<{
-                        server: string;
-                        port: number;
-                        from: string;
-                        login: string;
-                        password: string | null | undefined;
-                    }, never>;
+                        customFrom: string | null;
+                    }, {
+                        customFrom: string | null;
+                    }>;
                 };
-            }, "disabled" | "system" | "custom">, never>;
+                custom: {
+                    name: string;
+                    spec: InputSpec<T.SmtpValue, T.SmtpValue>;
+                };
+            }>, unknown>;
         };
         /**
          * @description Use this function to create a service interface.
@@ -237,7 +235,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             schemeOverride: null,
             username: null,
             path: '',
-            search: {},
+            query: {},
           })
          * ```
          */
@@ -248,28 +246,29 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             id: string;
             /** The human readable description. */
             description: string;
-            /** Affects how the interface appears to the user. One of: 'ui', 'api', 'p2p'. If 'ui', the user will see a "Launch UI" button */
+            /** Affects how the interface appears to the user. One of: 'ui', 'api', 'p2p'. If 'ui', the user will see an option to open the UI in a new tab */
             type: ServiceInterfaceType;
             /** (optional) prepends the provided username to all URLs. */
             username: null | string;
             /** (optional) appends the provided path to all URLs. */
             path: string;
             /** (optional) appends the provided query params to all URLs. */
-            search: Record<string, string>;
+            query: Record<string, string>;
             /** (optional) overrides the protocol prefix provided by the bind function.
              *
-             * @example `ftp://`
+             * @example `{ ssl: 'ftps', noSsl: 'ftp' }`
              */
             schemeOverride: {
                 ssl: Scheme;
                 noSsl: Scheme;
             } | null;
-            /** TODO Aiden how would someone include a password in the URL? Whether or not to mask the URLs on the screen, for example, when they contain a password */
+            /** mask the url (recommended if it contains credentials such as an API key or password) */
             masked: boolean;
         }) => ServiceInterfaceBuilder;
         getSystemSmtp: <E extends Effects>(effects: E) => GetSystemSmtp;
-        getSslCerificate: <E extends Effects>(effects: E, hostnames: string[], algorithm?: T.Algorithm) => GetSslCertificate;
-        HealthCheck: typeof HealthCheck;
+        getOutboundGateway: <E extends Effects>(effects: E) => GetOutboundGateway;
+        getSslCertificate: <E extends Effects>(effects: E, hostnames: string[], algorithm?: T.Algorithm) => GetSslCertificate;
+        getServiceManifest: typeof getServiceManifest;
         healthCheck: {
             checkPortListening: typeof checkPortListening;
             checkWebUrl: (effects: Effects, url: string, { timeout, successMessage, errorMessage, }?: {
@@ -299,8 +298,8 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
          * ```
          */
         Actions: {
-            new (actions: {}): Actions<Store, {}>;
-            of<Store_2>(): Actions<Store_2, {}>;
+            new (actions: {}): Actions<{}>;
+            of(): Actions<{}>;
         };
         /**
          * @description Use this function to determine which volumes are backed up when a user creates a backup, including advanced options.
@@ -329,16 +328,16 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
          */
         setupBackups: (options: SetupBackupsParams<Manifest>) => {
             createBackup: T.ExpectedExports.createBackup;
-            restoreBackup: T.ExpectedExports.restoreBackup;
+            restoreInit: import("../../base/lib/inits").InitScript;
         };
         /**
          * @description Use this function to set dependency information.
          * @example
-         * In this example, we create a perpetual dependency on Hello World >=1.0.0:0, where Hello World must be running and passing its "primary" health check.
+         * In this example, we create a dependency on Hello World >=1.0.0:0, where Hello World must be running and passing its "primary" health check.
          *
          * ```
           export const setDependencies = sdk.setupDependencies(
-            async ({ effects, input }) => {
+            async ({ effects }) => {
               return {
                 'hello-world': {
                   kind: 'running',
@@ -349,76 +348,59 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             },
           )
          * ```
-         * @example
-         * In this example, we create a conditional dependency on Hello World based on a hypothetical "needsWorld" boolean in our Store.
-         * Using .const() ensures that if the "needsWorld" boolean changes, setupDependencies will re-run.
-         *
-         * ```
-          export const setDependencies = sdk.setupDependencies(
-            async ({ effects }) => {
-              if (sdk.store.getOwn(sdk.StorePath.needsWorld).const()) {
-                return {
-                  'hello-world': {
-                    kind: 'running',
-                    versionRange: '>=1.0.0',
-                    healthChecks: ['primary'],
-                  },
-                }
-              }
-              return {}
-            },
-          )
-         * ```
          */
         setupDependencies: (fn: (options: {
             effects: T.Effects;
-        }) => Promise<T.CurrentDependenciesResult<Manifest>>) => (options: {
-            effects: T.Effects;
-        }) => Promise<null>;
-        setupInit: (versions: VersionGraph<string>, preInstall: PreInstall<Manifest, Store>, postInstall: PostInstall<Manifest, Store>, uninstall: import("./inits/setupUninstall").Uninstall<Manifest, Store>, setServiceInterfaces: UpdateServiceInterfaces<any>, setDependencies: (options: {
-            effects: T.Effects;
-        }) => Promise<null | void | undefined>, actions: Actions<Store, any>, initStore: Store, exposedStore: ExposedStorePaths) => {
-            packageInit: T.ExpectedExports.packageInit;
-            packageUninit: T.ExpectedExports.packageUninit;
-            containerInit: T.ExpectedExports.containerInit;
-        };
+        }) => Promise<T.CurrentDependenciesResult<Manifest>>) => (effects: T.Effects) => Promise<null>;
         /**
-         * @description Use this function to execute arbitrary logic *once*, on initial install *before* interfaces, actions, and dependencies are updated.
+         * @description Use this function to create an InitScript that runs every time the service initializes (install, update, restore, rebuild, and server bootup)
+         */
+        setupOnInit: typeof setupOnInit;
+        /**
+         * @description Use this function to create an UninitScript that runs every time the service uninitializes (update, uninstall, and server shutdown)
+         */
+        setupOnUninit: typeof setupOnUninit;
+        /**
+         * @description Use this function to setup what happens when the service initializes.
+         *
+         *    This happens when the server boots, or a service is installed, updated, or restored
+         *
+         *    Not every init script does something on every initialization. For example, versions only does something on install or update
+         *
+         *    These scripts are run in the order they are supplied
          * @example
-         * In the this example, we initialize a config file
          *
          * ```
-          const preInstall = sdk.setupPreInstall(async ({ effects }) => {
-            await configFile.write(effects, { name: 'World' })
-          })
+          export const init = sdk.setupInit(
+            restoreInit,
+            versions,
+            setDependencies,
+            setInterfaces,
+            actions,
+            postInstall,
+          )
          * ```
          */
-        setupPreInstall: (fn: InstallFn<Manifest, Store>) => PreInstall<Manifest, Store>;
+        setupInit: typeof setupInit;
         /**
-         * @description Use this function to execute arbitrary logic *once*, on initial install *after* interfaces, actions, and dependencies are updated.
+         * @description Use this function to setup what happens when the service uninitializes.
+         *
+         *    This happens when the server shuts down, or a service is uninstalled or updated
+         *
+         *    Not every uninit script does something on every uninitialization. For example, versions only does something on uninstall or update
+         *
+         *    These scripts are run in the order they are supplied
          * @example
-         * In the this example, we bootstrap our Store with a random, 16-char admin password.
          *
          * ```
-          const postInstall = sdk.setupPostInstall(async ({ effects }) => {
-            await sdk.store.setOwn(
-              effects,
-              sdk.StorePath.adminPassword,
-              utils.getDefaultString({
-                charset: 'a-z,A-Z,1-9,!,@,$,%,&,',
-                len: 16,
-              }),
-            )
-          })
+          export const uninit = sdk.setupUninit(
+            versions,
+          )
          * ```
          */
-        setupPostInstall: (fn: InstallFn<Manifest, Store>) => PostInstall<Manifest, Store>;
+        setupUninit: typeof setupUninit;
         /**
          * @description Use this function to determine how this service will be hosted and served. The function executes on service install, service update, and inputSpec save.
-         *
-         *   "input" will be of type `Input` for inputSpec save. It will be `null` for install and update.
-         *
-         *   To learn about creating multi-hosts and interfaces, check out the {@link https://docs.start9.com/packaging-guide/learn/interfaces documentation}.
          * @param inputSpec - The inputSpec spec of this service as exported from /inputSpec/spec.
          * @param fn - an async function that returns an array of interface receipts. The function always has access to `effects`; it has access to `input` only after inputSpec save, otherwise `input` will be null.
          * @example
@@ -426,8 +408,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
          *
          * ```
           export const setInterfaces = sdk.setupInterfaces(
-            inputSpecSpec,
-            async ({ effects, input }) => {
+            async ({ effects }) => {
               // ** UI multi-host **
               const uiMulti = sdk.MultiHost.of(effects, 'ui-multi')
               const uiMultiOrigin = await uiMulti.bindPort(80, {
@@ -443,7 +424,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 schemeOverride: null,
                 username: null,
                 path: '',
-                search: {},
+                query: {},
               })
               // Admin UI
               const adminUi = sdk.createInterface(effects, {
@@ -455,7 +436,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 schemeOverride: null,
                 username: null,
                 path: '/admin',
-                search: {},
+                query: {},
               })
               // UI receipt
               const uiReceipt = await uiMultiOrigin.export([primaryUi, adminUi])
@@ -475,7 +456,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 schemeOverride: null,
                 username: null,
                 path: '',
-                search: {},
+                query: {},
               })
               // API receipt
               const apiReceipt = await apiMultiOrigin.export([api])
@@ -489,12 +470,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
         setupInterfaces: import("../../base/lib/interfaces/setupInterfaces").SetupServiceInterfaces;
         setupMain: (fn: (o: {
             effects: Effects;
-            started(onTerm: () => PromiseLike<void>): PromiseLike<null>;
         }) => Promise<Daemons<Manifest, any>>) => T.ExpectedExports.main;
-        /**
-         * Use this function to execute arbitrary logic *once*, on uninstall only. Most services will not use this.
-         */
-        setupUninstall: (fn: UninstallFn<Manifest, Store>) => import("./inits/setupUninstall").Uninstall<Manifest, Store>;
         trigger: {
             defaultTrigger: import("./trigger").Trigger;
             cooldownTrigger: typeof cooldownTrigger;
@@ -505,12 +481,12 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             }) => import("./trigger").Trigger;
         };
         Mounts: {
-            of(): Mounts<Manifest, never>;
+            of: () => Mounts<Manifest, never>;
         };
         Backups: {
-            volumes: (...volumeNames: Array<Manifest["volumes"][number] & string>) => Backups<Manifest>;
-            addSets: (...options: BackupSync<Manifest["volumes"][number] & string>[]) => Backups<Manifest>;
-            withOptions: (options?: Partial<SyncOptions>) => Backups<Manifest>;
+            ofVolumes: (...volumeNames: Manifest["volumes"][number][]) => Backups<Manifest>;
+            ofSyncs: (...syncs: import("./backup/Backups").BackupSync<Manifest["volumes"][number]>[]) => Backups<Manifest>;
+            withOptions: (options?: Partial<T.SyncOptions>) => Backups<Manifest>;
         };
         InputSpec: {
             /**
@@ -540,10 +516,13 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
               })
              * ```
              */
-            of: <Spec extends Record<string, Value<any, Store> | Value<any, never>>>(spec: Spec) => InputSpec<{ [K in keyof Spec]: Spec[K] extends Value<infer T, never> | Value<infer T, Store> ? T : never; }, Store>;
+            of: <Spec extends Record<string, Value<any>>>(spec: Spec) => InputSpec<{ [K in keyof Spec]: Spec[K] extends Value<infer T extends any, any, unknown> ? T : never; }, { [K_1 in keyof Spec]: Spec[K_1] extends Value<any, infer T_1, unknown> ? T_1 : never; }>;
+        };
+        Daemon: {
+            readonly of: <C extends SubContainer<Manifest, Effects> | null>(effects: T.Effects, subcontainer: C, exec: import("./mainFn/Daemons").DaemonCommandType<Manifest, C>) => Daemon<Manifest, SubContainer<Manifest, Effects> | null>;
         };
         Daemons: {
-            of(effects: Effects, started: (onTerm: () => PromiseLike<void>) => PromiseLike<null>, healthChecks: HealthCheck[]): Daemons<Manifest, never>;
+            of(effects: Effects): Daemons<Manifest, never>;
         };
         SubContainer: {
             /**
@@ -556,467 +535,67 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             of(effects: Effects, image: {
                 imageId: T.ImageId & keyof Manifest["images"];
                 sharedRun?: boolean;
-            }, mounts: Mounts<Manifest> | null, name: string): Promise<SubContainer<T.SDKManifest, Effects>>;
+            }, mounts: Mounts<Manifest> | null, name: string): Promise<import("./util/SubContainer").SubContainerRc<Manifest, Effects>>;
             /**
-             * @description Create a new SubContainer
+             * @description Run a function with a temporary SubContainer
              * @param effects
              * @param image - what container image to use
              * @param mounts - what to mount to the subcontainer
              * @param name - a name to use to refer to the ephemeral subcontainer for debugging purposes
              */
-            with<T>(effects: T.Effects, image: {
+            withTemp<T>(effects: T.Effects, image: {
                 imageId: T.ImageId & keyof Manifest["images"];
                 sharedRun?: boolean;
             }, mounts: Mounts<Manifest> | null, name: string, fn: (subContainer: SubContainer<Manifest>) => Promise<T>): Promise<T>;
         };
-        List: {
-            /**
-             * @description Create a list of text inputs.
-             * @param a - attributes of the list itself.
-             * @param aSpec - attributes describing each member of the list.
-             */
-            text: typeof List.text;
-            /**
-             * @description Create a list of objects.
-             * @param a - attributes of the list itself.
-             * @param aSpec - attributes describing each member of the list.
-             */
-            obj: <Type extends Record<string, any>>(a: Parameters<typeof List.obj<Type, Store>>[0], aSpec: Parameters<typeof List.obj<Type, Store>>[1]) => List<Type[], Store>;
-            /**
-             * @description Create a list of dynamic text inputs.
-             * @param a - attributes of the list itself.
-             * @param aSpec - attributes describing each member of the list.
-             */
-            dynamicText: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default?: string[];
-                minLength?: number | null;
-                maxLength?: number | null;
-                disabled?: false | string;
-                generate?: null | RandomString;
-                spec: {
-                    masked?: boolean;
-                    placeholder?: string | null;
-                    minLength?: number | null;
-                    maxLength?: number | null;
-                    patterns?: Pattern[];
-                    inputmode?: ListValueSpecText["inputmode"];
-                };
-            }>) => List<string[], Store>;
-        };
-        StorePath: PathBuilder<Store, Store>;
-        Value: {
-            /**
-             * @description Displays a boolean toggle to enable/disable
-             * @example
-             * ```
-              toggleExample: Value.toggle({
-                // required
-                name: 'Toggle Example',
-                default: true,
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-              }),
-             * ```
-             */
-            toggle: typeof Value.toggle;
-            /**
-             * @description Displays a text input field
-             * @example
-             * ```
-              textExample: Value.text({
-                // required
-                name: 'Text Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                placeholder: null,
-                warning: null,
-                generate: null,
-                inputmode: 'text',
-                masked: false,
-                minLength: null,
-                maxLength: null,
-                patterns: [],
-                immutable: false,
-              }),
-             * ```
-             */
-            text: typeof Value.text;
-            /**
-             * @description Displays a large textarea field for long form entry.
-             * @example
-             * ```
-              textareaExample: Value.textarea({
-                // required
-                name: 'Textarea Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                placeholder: null,
-                warning: null,
-                minLength: null,
-                maxLength: null,
-                immutable: false,
-              }),
-             * ```
-             */
-            textarea: typeof Value.textarea;
-            /**
-             * @description Displays a number input field
-             * @example
-             * ```
-              numberExample: Value.number({
-                // required
-                name: 'Number Example',
-                required: false,
-                default: null,
-                integer: true,
-             
-                // optional
-                description: null,
-                placeholder: null,
-                warning: null,
-                min: null,
-                max: null,
-                immutable: false,
-                step: null,
-                units: null,
-              }),
-             * ```
-             */
-            number: typeof Value.number;
-            /**
-             * @description Displays a browser-native color selector.
-             * @example
-             * ```
-              colorExample: Value.color({
-                // required
-                name: 'Color Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-              }),
-             * ```
-             */
-            color: typeof Value.color;
-            /**
-             * @description Displays a browser-native date/time selector.
-             * @example
-             * ```
-              datetimeExample: Value.datetime({
-                // required
-                name: 'Datetime Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-                inputmode: 'datetime-local',
-                min: null,
-                max: null,
-              }),
-             * ```
-             */
-            datetime: typeof Value.datetime;
-            /**
-             * @description Displays a select modal with radio buttons, allowing for a single selection.
-             * @example
-             * ```
-              selectExample: Value.select({
-                // required
-                name: 'Select Example',
-                default: 'radio1',
-                values: {
-                  radio1: 'Radio 1',
-                  radio2: 'Radio 2',
-                },
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-                disabled: false,
-              }),
-             * ```
-             */
-            select: typeof Value.select;
-            /**
-             * @description Displays a select modal with checkboxes, allowing for multiple selections.
-             * @example
-             * ```
-              multiselectExample: Value.multiselect({
-                // required
-                name: 'Multiselect Example',
-                values: {
-                  option1: 'Option 1',
-                  option2: 'Option 2',
-                },
-                default: [],
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-                disabled: false,
-                minlength: null,
-                maxLength: null,
-              }),
-             * ```
-             */
-            multiselect: typeof Value.multiselect;
-            /**
-             * @description Display a collapsable grouping of additional fields, a "sub form". The second value is the inputSpec spec for the sub form.
-             * @example
-             * ```
-              objectExample: Value.object(
-                {
-                  // required
-                  name: 'Object Example',
-             
-                  // optional
-                  description: null,
-                  warning: null,
-                },
-                InputSpec.of({}),
-              ),
-             * ```
-             */
-            object: typeof Value.object;
-            /**
-             * @description Displays a dropdown, allowing for a single selection. Depending on the selection, a different object ("sub form") is presented.
-             * @example
-             * ```
-              unionExample: Value.union(
-                {
-                  // required
-                  name: 'Union Example',
-                  default: 'option1',
-             
-                  // optional
-                  description: null,
-                  warning: null,
-                  disabled: false,
-                  immutable: false,
-                },
-                Variants.of({
-                  option1: {
-                    name: 'Option 1',
-                    spec: InputSpec.of({}),
-                  },
-                  option2: {
-                    name: 'Option 2',
-                    spec: InputSpec.of({}),
-                  },
-                }),
-              ),
-             * ```
-             */
-            union: typeof Value.union;
-            /**
-             * @description Presents an interface to add/remove/edit items in a list.
-             * @example
-             * In this example, we create a list of text inputs.
-             *
-             * ```
-              listExampleText: Value.list(
-                List.text(
-                  {
-                    // required
-                    name: 'Text List',
-    
-                    // optional
-                    description: null,
-                    warning: null,
-                    default: [],
-                    minLength: null,
-                    maxLength: null,
-                  },
-                  {
-                    // required
-                    patterns: [],
-    
-                    // optional
-                    placeholder: null,
-                    generate: null,
-                    inputmode: 'url',
-                    masked: false,
-                    minLength: null,
-                    maxLength: null,
-                  },
-                ),
-              ),
-             * ```
-             * @example
-             * In this example, we create a list of objects.
-             *
-             * ```
-              listExampleObject: Value.list(
-                List.obj(
-                  {
-                    // required
-                    name: 'Object List',
-    
-                    // optional
-                    description: null,
-                    warning: null,
-                    default: [],
-                    minLength: null,
-                    maxLength: null,
-                  },
-                  {
-                    // required
-                    spec: InputSpec.of({}),
-    
-                    // optional
-                    displayAs: null,
-                    uniqueBy: null,
-                  },
-                ),
-              ),
-             * ```
-             */
-            list: typeof Value.list;
-            hidden: typeof Value.hidden;
-            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;
-                default: DefaultString | null;
-                required: boolean;
-                masked?: boolean;
-                placeholder?: string | null;
-                minLength?: number | null;
-                maxLength?: number | null;
-                patterns?: Pattern[];
-                inputmode?: ValueSpecText["inputmode"];
-                disabled?: string | false;
-                generate?: null | RandomString;
-            }>) => Value<string | null, Store>;
-            dynamicTextarea: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string | null;
-                required: boolean;
-                minLength?: number | null;
-                maxLength?: number | null;
-                placeholder?: string | null;
-                disabled?: false | string;
-            }>) => Value<string | null, Store>;
-            dynamicNumber: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: number | null;
-                required: boolean;
-                min?: number | null;
-                max?: number | null;
-                step?: number | null;
-                integer: boolean;
-                units?: string | null;
-                placeholder?: string | null;
-                disabled?: false | string;
-            }>) => Value<number | null, Store>;
-            dynamicColor: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string | null;
-                required: boolean;
-                disabled?: false | string;
-            }>) => Value<string | null, Store>;
-            dynamicDatetime: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string | null;
-                required: boolean;
-                inputmode?: ValueSpecDatetime["inputmode"];
-                min?: string | null;
-                max?: string | null;
-                disabled?: false | string;
-            }>) => Value<string | null, Store>;
-            dynamicSelect: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string;
-                values: Record<string, string>;
-                disabled?: false | string | string[];
-            }>) => Value<string, 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 | string[];
-            }>) => Value<string[], Store>;
-            filteredUnion: <VariantValues extends { [K in string]: {
-                name: string;
-                spec: InputSpec<any, Store> | InputSpec<any, never>;
-            }; }>(getDisabledFn: Parameters<typeof Value.filteredUnion<VariantValues, Store>>[0], a: Parameters<typeof Value.filteredUnion<VariantValues, Store>>[1], aVariants: Parameters<typeof Value.filteredUnion<VariantValues, Store>>[2]) => Value<import("../../base/lib/actions/input/builder/variants").UnionRes<Store, VariantValues, keyof VariantValues & string> | import("../../base/lib/actions/input/builder/variants").UnionRes<never, VariantValues, keyof VariantValues & string>, Store>;
-            dynamicUnion: <VariantValues extends { [K in string]: {
-                name: string;
-                spec: InputSpec<any, Store> | InputSpec<any, never>;
-            }; }>(getA: Parameters<typeof Value.dynamicUnion<VariantValues, Store>>[0], aVariants: Parameters<typeof Value.dynamicUnion<VariantValues, Store>>[1]) => Value<import("../../base/lib/actions/input/builder/variants").UnionRes<Store, VariantValues, keyof VariantValues & string> | import("../../base/lib/actions/input/builder/variants").UnionRes<never, VariantValues, keyof VariantValues & string>, Store>;
-        };
-        Variants: {
-            of: <VariantValues extends { [K in string]: {
-                name: string;
-                spec: InputSpec<any, Store>;
-            }; }>(a: VariantValues) => Variants<VariantValues, Store>;
+        List: typeof List;
+        Value: typeof Value;
+        Variants: typeof Variants;
+        plugin: {
+            url: Manifest extends {
+                plugins: "url-v0"[];
+            } ? {
+                register: (effects: T.Effects, options: {
+                    tableAction: ActionInfo<T.ActionId, {
+                        urlPluginMetadata: {
+                            packageId: T.PackageId;
+                            interfaceId: T.ServiceInterfaceId;
+                            hostId: T.HostId;
+                            internalPort: number;
+                        };
+                    }>;
+                }) => Promise<null>;
+                exportUrl: (effects: T.Effects, options: {
+                    hostnameInfo: T.PluginHostnameInfo;
+                    removeAction: ActionInfo<T.ActionId, {
+                        urlPluginMetadata: T.PluginHostnameInfo & {
+                            interfaceId: T.ServiceInterfaceId;
+                        };
+                    }> | null;
+                    overflowActions: ActionInfo<T.ActionId, {
+                        urlPluginMetadata: T.PluginHostnameInfo & {
+                            interfaceId: T.ServiceInterfaceId;
+                        };
+                    }>[];
+                }) => Promise<null>;
+                setupExportedUrls: import("../../base/lib/interfaces/setupExportedUrls").SetupExportedUrls;
+            } : null;
         };
         restart: (effects: Effects) => Promise<null>;
         shutdown: (effects: Effects) => Promise<null>;
         getStatus: (effects: Effects, options: {
-            packageId?: PackageId;
+            packageId?: T.PackageId;
             callback?: () => void;
-        }) => Promise<T.MainStatus>;
+        }) => Promise<T.StatusInfo>;
         setDependencies: (effects: Effects, options: {
             dependencies: T.Dependencies;
         }) => Promise<null>;
         getDependencies: (effects: Effects) => Promise<T.DependencyRequirement[]>;
-        mount: (effects: Effects, options: {
-            location: string;
-            target: {
-                packageId: string;
-                volumeId: string;
-                subpath: string | null;
-                readonly: boolean;
-            };
-        }) => Promise<string>;
+        mount: (effects: Effects, options: T.MountParams) => Promise<string>;
         getInstalledPackages: (effects: Effects) => Promise<string[]>;
-        exposeForDependents: (effects: Effects, options: {
-            paths: string[];
-        }) => Promise<null>;
+        setHealth: (effects: Effects, o: T.SetHealth) => Promise<null>;
         getServicePortForward: (effects: Effects, options: {
-            packageId?: PackageId;
+            packageId?: T.PackageId;
             hostId: T.HostId;
             internalPort: number;
         }) => Promise<T.NetInfo>;
@@ -1031,15 +610,12 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             hostnames: string[];
             algorithm?: "ecdsa" | "ed25519";
         }) => Promise<string>;
-        setDataVersion: (effects: Effects, options: {
-            version: string;
-        }) => Promise<null>;
-        getDataVersion: (effects: Effects) => Promise<string | null>;
         manifest: Manifest;
+        volumes: Volumes<Manifest>;
     };
 }
 export declare function runCommand<Manifest extends T.SDKManifest>(effects: Effects, image: {
-    imageId: keyof Manifest["images"] & T.ImageId;
+    imageId: keyof Manifest['images'] & T.ImageId;
     sharedRun?: boolean;
 }, command: T.CommandType, options: CommandOptions & {
     mounts: Mounts<Manifest> | null;