recap/node_modules/@start9labs/start-sdk/base/lib/Effects.d.ts

import { ActionId, ActionInput, ActionMetadata, SetMainStatus, DependencyRequirement, CheckDependenciesResult, SetHealth, BindParams, HostId, NetInfo, Host, ExportServiceInterfaceParams, ServiceInterface, CreateTaskParams, MountParams, StatusInfo, Manifest } from './osBindings';
import { PackageId, Dependencies, ServiceInterfaceId, SmtpValue, ActionResult, PluginHostnameInfo } from './types';
/** Used to reach out from the pure js runtime */
export type Effects = {
    readonly eventId: string | null;
    child: (name: string) => Effects;
    constRetry?: () => void;
    isInContext: boolean;
    onLeaveContext: (fn: () => void | null | undefined) => void;
    clearCallbacks: (options: {
        only: number[];
    } | {
        except: number[];
    }) => Promise<null>;
    action: {
        /** Define an action that can be invoked by a user or service */
        export(options: {
            id: ActionId;
            metadata: ActionMetadata;
        }): Promise<null>;
        /** Remove all exported actions */
        clear(options: {
            except: ActionId[];
        }): Promise<null>;
        getInput(options: {
            packageId?: PackageId;
            actionId: ActionId;
        }): Promise<ActionInput | null>;
        run<Input extends Record<string, unknown>>(options: {
            packageId?: PackageId;
            actionId: ActionId;
            input?: Input;
        }): Promise<ActionResult | null>;
        createTask(options: CreateTaskParams): Promise<null>;
        clearTasks(options: {
            only: string[];
        } | {
            except: string[];
        }): Promise<null>;
    };
    /** restart this service's main function */
    restart(): Promise<null>;
    /** stop this service's main function */
    shutdown(): Promise<null>;
    /** ask the host os what the service's current status is */
    getStatus(options: {
        packageId?: PackageId;
        callback?: () => void;
    }): Promise<StatusInfo | null>;
    /** DEPRECATED: indicate to the host os what runstate the service is in */
    setMainStatus(options: SetMainStatus): Promise<null>;
    /** Set the dependencies of what the service needs, usually run during the inputSpec action as a best practice */
    setDependencies(options: {
        dependencies: Dependencies;
    }): Promise<null>;
    /** Get the list of the dependencies, both the dynamic set by the effect of setDependencies and the end result any required in the manifest  */
    getDependencies(): Promise<DependencyRequirement[]>;
    /** Test whether current dependency requirements are satisfied */
    checkDependencies(options: {
        packageIds?: PackageId[];
    }): Promise<CheckDependenciesResult[]>;
    /** mount a volume of a dependency */
    mount(options: MountParams): Promise<string>;
    /** Returns a list of the ids of all installed packages */
    getInstalledPackages(): Promise<string[]>;
    /** Returns the manifest of a service */
    getServiceManifest(options: {
        packageId: PackageId;
        callback?: () => void;
    }): Promise<Manifest>;
    /** sets the result of a health check */
    setHealth(o: SetHealth): Promise<null>;
    subcontainer: {
        /** A low level api used by SubContainer */
        createFs(options: {
            imageId: string;
            name: string | null;
        }): Promise<[string, string]>;
        /** A low level api used by SubContainer */
        destroyFs(options: {
            guid: string;
        }): Promise<null>;
    };
    /** Creates a host connected to the specified port with the provided options */
    bind(options: BindParams): Promise<null>;
    /** Get the port address for a service */
    getServicePortForward(options: {
        packageId?: PackageId;
        hostId: HostId;
        internalPort: number;
    }): Promise<NetInfo>;
    /** Removes all network bindings, called in the setupInputSpec */
    clearBindings(options: {
        except: {
            id: HostId;
            internalPort: number;
        }[];
    }): Promise<null>;
    /** Returns information about the specified host, if it exists */
    getHostInfo(options: {
        packageId?: PackageId;
        hostId: HostId;
        callback?: () => void;
    }): Promise<Host | null>;
    /** Returns the IP address of the container */
    getContainerIp(options: {
        packageId?: PackageId;
        callback?: () => void;
    }): Promise<string>;
    /** Returns the IP address of StartOS */
    getOsIp(): Promise<string>;
    /** Returns the effective outbound gateway for this service */
    getOutboundGateway(options: {
        callback?: () => void;
    }): Promise<string>;
    /** Creates an interface bound to a specific host and port to show to the user */
    exportServiceInterface(options: ExportServiceInterfaceParams): Promise<null>;
    /** Returns an exported service interface */
    getServiceInterface(options: {
        packageId?: PackageId;
        serviceInterfaceId: ServiceInterfaceId;
        callback?: () => void;
    }): Promise<ServiceInterface | null>;
    /** Returns all exported service interfaces for a package */
    listServiceInterfaces(options: {
        packageId?: PackageId;
        callback?: () => void;
    }): Promise<Record<ServiceInterfaceId, ServiceInterface>>;
    /** Removes all service interfaces */
    clearServiceInterfaces(options: {
        except: ServiceInterfaceId[];
    }): Promise<null>;
    plugin: {
        url: {
            register(options: {
                tableAction: ActionId;
            }): Promise<null>;
            exportUrl(options: {
                hostnameInfo: PluginHostnameInfo;
                removeAction: ActionId | null;
                overflowActions: ActionId[];
            }): Promise<null>;
            clearUrls(options: {
                except: PluginHostnameInfo[];
            }): Promise<null>;
        };
    };
    /** Returns a PEM encoded fullchain for the hostnames specified */
    getSslCertificate: (options: {
        hostnames: string[];
        algorithm?: 'ecdsa' | 'ed25519';
        callback?: () => void;
    }) => Promise<[string, string, string]>;
    /** Returns a PEM encoded private key corresponding to the certificate for the hostnames specified */
    getSslKey: (options: {
        hostnames: string[];
        algorithm?: 'ecdsa' | 'ed25519';
    }) => Promise<string>;
    /** sets the version that this service's data has been migrated to */
    setDataVersion(options: {
        version: string | null;
    }): Promise<null>;
    /** returns the version that this service's data has been migrated to */
    getDataVersion(): Promise<string | null>;
    /** Returns globally configured SMTP settings, if they exist */
    getSystemSmtp(options: {
        callback?: () => void;
    }): Promise<SmtpValue | null>;
};