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

package/package/lib/StartSdk.js

@@ -0,0 +1,810 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = exports.StartSdk = exports.SDKVersion = void 0;
+const value_1 = require("../../base/lib/actions/input/builder/value");
+const inputSpec_1 = require("../../base/lib/actions/input/builder/inputSpec");
+const variants_1 = require("../../base/lib/actions/input/builder/variants");
+const setupActions_1 = require("../../base/lib/actions/setupActions");
+const patterns = __importStar(require("../../base/lib/util/patterns"));
+const Backups_1 = require("./backup/Backups");
+const inputSpecConstants_1 = require("../../base/lib/actions/input/inputSpecConstants");
+const Daemons_1 = require("./mainFn/Daemons");
+const HealthCheck_1 = require("./health/HealthCheck");
+const checkPortListening_1 = require("./health/checkFns/checkPortListening");
+const checkFns_1 = require("./health/checkFns");
+const list_1 = require("../../base/lib/actions/input/builder/list");
+const setupInstall_1 = require("./inits/setupInstall");
+const setupBackups_1 = require("./backup/setupBackups");
+const setupUninstall_1 = require("./inits/setupUninstall");
+const mainFn_1 = require("./mainFn");
+const defaultTrigger_1 = require("./trigger/defaultTrigger");
+const trigger_1 = require("./trigger");
+const setupInterfaces_1 = require("../../base/lib/interfaces/setupInterfaces");
+const successFailure_1 = require("./trigger/successFailure");
+const Host_1 = require("../../base/lib/interfaces/Host");
+const ServiceInterfaceBuilder_1 = require("../../base/lib/interfaces/ServiceInterfaceBuilder");
+const util_1 = require("./util");
+const util_2 = require("./util");
+const util_3 = require("./util");
+const getStore_1 = require("./store/getStore");
+const SubContainer_1 = require("./util/SubContainer");
+const util_4 = require("./util");
+const Mounts_1 = require("./mainFn/Mounts");
+const Dependency_1 = require("../../base/lib/dependencies/Dependency");
+const setupDependencies_1 = require("../../base/lib/dependencies/setupDependencies");
+const exver_1 = require("../../base/lib/exver");
+const PathBuilder_1 = require("../../base/lib/util/PathBuilder");
+const dependencies_1 = require("../../base/lib/dependencies/dependencies");
+const util_5 = require("./util");
+const actions = __importStar(require("../../base/lib/actions"));
+const setupInit_1 = require("./inits/setupInit");
+exports.SDKVersion = (0, exver_1.testTypeVersion)("0.3.6");
+class StartSdk {
+    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) {
+        const startSdkEffectWrapper = {
+            restart: (effects, ...args) => effects.restart(...args),
+            setDependencies: (effects, ...args) => effects.setDependencies(...args),
+            checkDependencies: (effects, ...args) => effects.checkDependencies(...args),
+            mount: (effects, ...args) => effects.mount(...args),
+            getInstalledPackages: (effects, ...args) => effects.getInstalledPackages(...args),
+            exposeForDependents: (effects, ...args) => effects.exposeForDependents(...args),
+            getServicePortForward: (effects, ...args) => effects.getServicePortForward(...args),
+            clearBindings: (effects, ...args) => effects.clearBindings(...args),
+            getContainerIp: (effects, ...args) => effects.getContainerIp(...args),
+            getSslKey: (effects, ...args) => effects.getSslKey(...args),
+            setDataVersion: (effects, ...args) => effects.setDataVersion(...args),
+            getDataVersion: (effects, ...args) => effects.getDataVersion(...args),
+            shutdown: (effects, ...args) => effects.shutdown(...args),
+            getDependencies: (effects, ...args) => effects.getDependencies(...args),
+        };
+        return {
+            ...startSdkEffectWrapper,
+            action: {
+                run: actions.runAction,
+                request: (effects, packageId, action, severity, options) => actions.requestAction({
+                    effects,
+                    packageId,
+                    action,
+                    severity,
+                    options: options,
+                }),
+                requestOwn: (effects, action, severity, options) => actions.requestAction({
+                    effects,
+                    packageId: this.manifest.id,
+                    action,
+                    severity,
+                    options: options,
+                }),
+                clearRequest: (effects, ...replayIds) => effects.action.clearRequests({ only: replayIds }),
+            },
+            checkDependencies: dependencies_1.checkDependencies,
+            serviceInterface: {
+                getOwn: (effects, id) => (0, util_3.getServiceInterface)(effects, {
+                    id,
+                }),
+                get: (effects, opts) => (0, util_3.getServiceInterface)(effects, opts),
+                getAllOwn: (effects) => (0, util_3.getServiceInterfaces)(effects, {}),
+                getAll: (effects, opts) => (0, util_3.getServiceInterfaces)(effects, opts),
+            },
+            store: {
+                get: (effects, packageId, path) => (0, getStore_1.getStore)(effects, path, {
+                    packageId,
+                }),
+                getOwn: (effects, path) => (0, getStore_1.getStore)(effects, path),
+                setOwn: (effects, path, value) => effects.store.set({
+                    value,
+                    path: (0, PathBuilder_1.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 Host_1.MultiHost({ id, effects }),
+            },
+            nullIfEmpty: util_2.nullIfEmpty,
+            runCommand: async (effects, image, command, options, name) => {
+                return runCommand(effects, image, command, options, name);
+            },
+            /**
+             * TODO: rewrite this
+             * @description Use this function to create a static Action, including optional form input.
+             *
+             *   By convention, each Action should receive its own file.
+             *
+             * @param id
+             * @param metaData
+             * @param fn
+             * @returns
+             * @example
+             * In this example, we create an Action that prints a name to the console. We present a user
+             * with a form for optionally entering a temp name. If no temp name is provided, we use the name
+             * from the underlying `inputSpec.yaml` file. If no name is there, we use "Unknown". Then, we return
+             * a message to the user informing them what happened.
+             *
+             * ```
+              import { sdk } from '../sdk'
+              const { InputSpec, Value } = sdk
+              import { yamlFile } from '../file-models/inputSpec.yml'
+      
+              const input = InputSpec.of({
+                nameToPrint: Value.text({
+                  name: 'Temp Name',
+                  description: 'If no name is provided, the name from inputSpec will be used',
+                  required: false,
+                }),
+              })
+      
+              export const nameToLog = sdk.createAction(
+                // id
+                'nameToLogs',
+      
+                // metadata
+                {
+                  name: 'Name to Logs',
+                  description: 'Prints "Hello [Name]" to the service logs.',
+                  warning: null,
+                  disabled: false,
+                  input,
+                  allowedStatuses: 'onlyRunning',
+                  group: null,
+                },
+      
+                // the execution function
+                async ({ effects, input }) => {
+                  const name =
+                    input.nameToPrint || (await yamlFile.read(effects))?.name || 'Unknown'
+      
+                  console.info(`Hello ${name}`)
+      
+                  return {
+                    version: '0',
+                    message: `"Hello ${name}" has been written to the service logs. Open your logs to view it.`,
+                    value: name,
+                    copyable: true,
+                    qr: false,
+                  }
+                },
+              )
+             * ```
+             */
+            Action: {
+                withInput: (id, metadata, inputSpec, getInput, run) => setupActions_1.Action.withInput(id, metadata, inputSpec, getInput, run),
+                withoutInput: (id, metadata, run) => setupActions_1.Action.withoutInput(id, metadata, run),
+            },
+            inputSpecConstants: { smtpInputSpec: inputSpecConstants_1.smtpInputSpec },
+            /**
+             * @description Use this function to create a service interface.
+             * @param effects
+             * @param options
+             * @example
+             * In this example, we create a standard web UI
+             *
+             * ```
+              const ui = sdk.createInterface(effects, {
+                name: 'Web UI',
+                id: 'ui',
+                description: 'The primary web app for this service.',
+                type: 'ui',
+                hasPrimary: false,
+                masked: false,
+                schemeOverride: null,
+                username: null,
+                path: '',
+                search: {},
+              })
+             * ```
+             */
+            createInterface: (effects, options) => new ServiceInterfaceBuilder_1.ServiceInterfaceBuilder({ ...options, effects }),
+            getSystemSmtp: (effects) => new util_1.GetSystemSmtp(effects),
+            getSslCerificate: (effects, hostnames, algorithm) => new util_5.GetSslCertificate(effects, hostnames, algorithm),
+            HealthCheck: {
+                of(o) {
+                    return (0, HealthCheck_1.healthCheck)(o);
+                },
+            },
+            Dependency: {
+                /**
+                 * @description Use this function to create a dependency for the service.
+                 * @property {DependencyType} type
+                 * @property {VersionRange} versionRange
+                 * @property {string[]} healthChecks
+                 */
+                of(data) {
+                    return new Dependency_1.Dependency({ ...data });
+                },
+            },
+            healthCheck: {
+                checkPortListening: checkPortListening_1.checkPortListening,
+                checkWebUrl: checkFns_1.checkWebUrl,
+                runHealthScript: checkFns_1.runHealthScript,
+            },
+            patterns,
+            /**
+             * @description Use this function to list every Action offered by the service. Actions will be displayed in the provided order.
+             *
+             *   By convention, each Action should receive its own file in the "actions" directory.
+             * @example
+             *
+             * ```
+              import { sdk } from '../sdk'
+              import { config } from './config'
+              import { nameToLogs } from './nameToLogs'
+      
+              export const actions = sdk.Actions.of().addAction(config).addAction(nameToLogs)
+             * ```
+             */
+            Actions: (setupActions_1.Actions),
+            /**
+             * @description Use this function to determine which volumes are backed up when a user creates a backup, including advanced options.
+             * @example
+             * In this example, we back up the entire "main" volume and nothing else.
+             *
+             * ```
+              export const { createBackup, restoreBackup } = sdk.setupBackups(sdk.Backups.addVolume('main'))
+             * ```
+             * @example
+             * In this example, we back up the "main" and the "other" volume, but exclude hypothetical directory "excludedDir" from the "other".
+             *
+             * ```
+              export const { createBackup, restoreBackup } = sdk.setupBackups(sdk.Backups
+                .addVolume('main')
+                .addVolume('other', { exclude: ['path/to/excludedDir'] })
+              )
+             * ```
+             */
+            setupBackups: (options) => (0, setupBackups_1.setupBackups)(options),
+            /**
+             * @description Use this function to set dependency information.
+             *
+             *   The function executes on service install, update, and inputSpec save. "input" will be of type `Input` for inputSpec save. It will be `null` for install and update.
+             * @example
+             * In this example, we create a static dependency on Hello World >=1.0.0:0, where Hello World must be running and passing its "webui" health check.
+             *
+             * ```
+              export const setDependencies = sdk.setupDependencies(
+                async ({ effects, input }) => {
+                  return {
+                    'hello-world': sdk.Dependency.of({
+                      type: 'running',
+                      versionRange: VersionRange.parse('>=1.0.0:0'),
+                      healthChecks: ['webui'],
+                    }),
+                  }
+                },
+              )
+             * ```
+             * @example
+             * In this example, we create a conditional dependency on Hello World based on a hypothetical "needsWorld" boolean in the store.
+             *
+             * ```
+              export const setDependencies = sdk.setupDependencies(
+                async ({ effects }) => {
+                  if (sdk.store.getOwn(sdk.StorePath.needsWorld).const()) {
+                    return {
+                      'hello-world': sdk.Dependency.of({
+                        type: 'running',
+                        versionRange: VersionRange.parse('>=1.0.0:0'),
+                        healthChecks: ['webui'],
+                      }),
+                    }
+                  }
+                  return {}
+                },
+              )
+             * ```
+             */
+            setupDependencies: (setupDependencies_1.setupDependencies),
+            setupInit: (setupInit_1.setupInit),
+            /**
+             * @description Use this function to execute arbitrary logic *once*, on initial install only.
+             * @example
+             * In the this example, we bootstrap our Store with a random, 16-char admin password.
+             *
+             * ```
+              const install = sdk.setupInstall(async ({ effects }) => {
+                await sdk.store.setOwn(
+                  effects,
+                  sdk.StorePath.adminPassword,
+                  utils.getDefaultString({
+                    charset: 'a-z,A-Z,1-9,!,@,$,%,&,',
+                    len: 16,
+                  }),
+                )
+              })
+             * ```
+             */
+            setupInstall: (fn) => setupInstall_1.Install.of(fn),
+            /**
+             * @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
+             * In this example, we create two UIs from one multi-host, and one API from another multi-host.
+             *
+             * ```
+              export const setInterfaces = sdk.setupInterfaces(
+                inputSpecSpec,
+                async ({ effects, input }) => {
+                  // ** UI multi-host **
+                  const uiMulti = sdk.host.multi(effects, 'ui-multi')
+                  const uiMultiOrigin = await uiMulti.bindPort(80, {
+                    protocol: 'http',
+                  })
+                  // Primary UI
+                  const primaryUi = sdk.createInterface(effects, {
+                    name: 'Primary UI',
+                    id: 'primary-ui',
+                    description: 'The primary web app for this service.',
+                    type: 'ui',
+                    hasPrimary: false,
+                    masked: false,
+                    schemeOverride: null,
+                    username: null,
+                    path: '',
+                    search: {},
+                  })
+                  // Admin UI
+                  const adminUi = sdk.createInterface(effects, {
+                    name: 'Admin UI',
+                    id: 'admin-ui',
+                    description: 'The admin web app for this service.',
+                    type: 'ui',
+                    hasPrimary: false,
+                    masked: false,
+                    schemeOverride: null,
+                    username: null,
+                    path: '/admin',
+                    search: {},
+                  })
+                  // UI receipt
+                  const uiReceipt = await uiMultiOrigin.export([primaryUi, adminUi])
+             
+                  // ** API multi-host **
+                  const apiMulti = sdk.host.multi(effects, 'api-multi')
+                  const apiMultiOrigin = await apiMulti.bindPort(5959, {
+                    protocol: 'http',
+                  })
+                  // API
+                  const api = sdk.createInterface(effects, {
+                    name: 'Admin API',
+                    id: 'api',
+                    description: 'The advanced API for this service.',
+                    type: 'api',
+                    hasPrimary: false,
+                    masked: false,
+                    schemeOverride: null,
+                    username: null,
+                    path: '',
+                    search: {},
+                  })
+                  // API receipt
+                  const apiReceipt = await apiMultiOrigin.export([api])
+             
+                  // ** Return receipts **
+                  return [uiReceipt, apiReceipt]
+                },
+              )
+             * ```
+             */
+            setupInterfaces: setupInterfaces_1.setupServiceInterfaces,
+            setupMain: (fn) => (0, mainFn_1.setupMain)(fn),
+            /**
+             * Use this function to execute arbitrary logic *once*, on uninstall only. Most services will not use this.
+             */
+            setupUninstall: (fn) => (0, setupUninstall_1.setupUninstall)(fn),
+            trigger: {
+                defaultTrigger: defaultTrigger_1.defaultTrigger,
+                cooldownTrigger: trigger_1.cooldownTrigger,
+                changeOnFirstSuccess: trigger_1.changeOnFirstSuccess,
+                successFailure: successFailure_1.successFailure,
+            },
+            Mounts: {
+                of() {
+                    return Mounts_1.Mounts.of();
+                },
+            },
+            Backups: {
+                volumes: (...volumeNames) => Backups_1.Backups.withVolumes(...volumeNames),
+                addSets: (...options) => Backups_1.Backups.withSyncs(...options),
+                withOptions: (options) => Backups_1.Backups.withOptions(options),
+            },
+            InputSpec: {
+                /**
+                 * @description Use this function to define the inputSpec specification that will ultimately present to the user as validated form inputs.
+                 *
+                 *   Most form controls are supported, including text, textarea, number, toggle, select, multiselect, list, color, datetime, object (sub form), and union (conditional sub form).
+                 * @example
+                 * In this example, we define a inputSpec form with two value: name and makePublic.
+                 *
+                 * ```
+                  import { sdk } from '../sdk'
+                  const { InputSpec, Value } = sdk
+                 
+                  export const inputSpecSpec = InputSpec.of({
+                    name: Value.text({
+                      name: 'Name',
+                      description:
+                        'When you launch the Hello World UI, it will display "Hello [Name]"',
+                      required: { default: 'World' },
+                    }),
+                    makePublic: Value.toggle({
+                      name: 'Make Public',
+                      description: 'Whether or not to expose the service to the network',
+                      default: false,
+                    }),
+                  })
+                 * ```
+                 */
+                of: (spec) => inputSpec_1.InputSpec.of(spec),
+            },
+            Daemons: {
+                of(options) {
+                    return Daemons_1.Daemons.of(options);
+                },
+            },
+            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: list_1.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: (a, aSpec) => list_1.List.obj(a, aSpec),
+                /**
+                 * @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) => list_1.List.dynamicText(getA),
+            },
+            StorePath: (0, PathBuilder_1.pathBuilder)(),
+            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: value_1.Value.toggle,
+                /**
+                 * @description Displays a text input field
+                 * @example
+                 * ```
+                  textExample: Value.text({
+                    // required
+                    name: 'Text Example',
+                    required: false,
+                 
+                    // optional
+                    description: null,
+                    placeholder: null,
+                    warning: null,
+                    generate: null,
+                    inputmode: 'text',
+                    masked: false,
+                    minLength: null,
+                    maxLength: null,
+                    patterns: [],
+                    immutable: false,
+                  }),
+                 * ```
+                 */
+                text: value_1.Value.text,
+                /**
+                 * @description Displays a large textarea field for long form entry.
+                 * @example
+                 * ```
+                  textareaExample: Value.textarea({
+                    // required
+                    name: 'Textarea Example',
+                    required: false,
+                 
+                    // optional
+                    description: null,
+                    placeholder: null,
+                    warning: null,
+                    minLength: null,
+                    maxLength: null,
+                    immutable: false,
+                  }),
+                 * ```
+                 */
+                textarea: value_1.Value.textarea,
+                /**
+                 * @description Displays a number input field
+                 * @example
+                 * ```
+                  numberExample: Value.number({
+                    // required
+                    name: 'Number Example',
+                    required: false,
+                    integer: true,
+                 
+                    // optional
+                    description: null,
+                    placeholder: null,
+                    warning: null,
+                    min: null,
+                    max: null,
+                    immutable: false,
+                    step: null,
+                    units: null,
+                  }),
+                 * ```
+                 */
+                number: value_1.Value.number,
+                /**
+                 * @description Displays a browser-native color selector.
+                 * @example
+                 * ```
+                  colorExample: Value.color({
+                    // required
+                    name: 'Color Example',
+                    required: false,
+                 
+                    // optional
+                    description: null,
+                    warning: null,
+                    immutable: false,
+                  }),
+                 * ```
+                 */
+                color: value_1.Value.color,
+                /**
+                 * @description Displays a browser-native date/time selector.
+                 * @example
+                 * ```
+                  datetimeExample: Value.datetime({
+                    // required
+                    name: 'Datetime Example',
+                    required: false,
+                 
+                    // optional
+                    description: null,
+                    warning: null,
+                    immutable: false,
+                    inputmode: 'datetime-local',
+                    min: null,
+                    max: null,
+                  }),
+                 * ```
+                 */
+                datetime: value_1.Value.datetime,
+                /**
+                 * @description Displays a select modal with radio buttons, allowing for a single selection.
+                 * @example
+                 * ```
+                  selectExample: Value.select({
+                    // required
+                    name: 'Select Example',
+                    required: false,
+                    values: {
+                      radio1: 'Radio 1',
+                      radio2: 'Radio 2',
+                    },
+                 
+                    // optional
+                    description: null,
+                    warning: null,
+                    immutable: false,
+                    disabled: false,
+                  }),
+                 * ```
+                 */
+                select: value_1.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: value_1.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: value_1.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',
+                      required: false,
+                 
+                      // 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: value_1.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: value_1.Value.list,
+                dynamicToggle: (a) => value_1.Value.dynamicToggle(a),
+                dynamicText: (getA) => value_1.Value.dynamicText(getA),
+                dynamicTextarea: (getA) => value_1.Value.dynamicTextarea(getA),
+                dynamicNumber: (getA) => value_1.Value.dynamicNumber(getA),
+                dynamicColor: (getA) => value_1.Value.dynamicColor(getA),
+                dynamicDatetime: (getA) => value_1.Value.dynamicDatetime(getA),
+                dynamicSelect: (getA) => value_1.Value.dynamicSelect(getA),
+                dynamicMultiselect: (getA) => value_1.Value.dynamicMultiselect(getA),
+                filteredUnion: (getDisabledFn, a, aVariants) => value_1.Value.filteredUnion(getDisabledFn, a, aVariants),
+                dynamicUnion: (getA, aVariants) => value_1.Value.dynamicUnion(getA, aVariants),
+            },
+            Variants: {
+                of: (a) => variants_1.Variants.of(a),
+            },
+        };
+    }
+}
+exports.StartSdk = StartSdk;
+async function runCommand(effects, image, command, options, name) {
+    const commands = (0, util_4.splitCommand)(command);
+    return SubContainer_1.SubContainer.with(effects, image, options.mounts || [], name, (subcontainer) => subcontainer.exec(commands));
+}
+exports.runCommand = runCommand;
+//# sourceMappingURL=StartSdk.js.map