@xh/hoist 57.0.0 → 57.0.2

package/build/types/cmp/tab/TabContainerModel.d.ts

@@ -0,0 +1,114 @@
+import { HoistModel, RefreshContextModel, PersistenceProvider, RefreshMode, RenderMode, PersistOptions } from '@xh/hoist/core';
+import { ReactNode } from 'react';
+import { TabConfig, TabModel } from './TabModel';
+import { TabSwitcherProps } from './TabSwitcherProps';
+export interface TabContainerConfig {
+    /** Tabs to be displayed. */
+    tabs?: TabConfig[];
+    /**
+     * ID of Tab to be shown initially if routing does not specify otherwise. If not set,
+     * will default to first tab in the provided collection.
+     */
+    defaultTabId?: string;
+    /**
+     * Base route name for this container. If set, this container will be route-enabled, with the
+     * route for each tab being "[route]/[tab.id]".  Cannot be used with `persistWith`.
+     */
+    route?: string;
+    /**
+     * Indicates whether to include a default switcher docked within this component. Specify as a
+     * boolean or an object containing props for a TabSwitcher component. Set to false to not
+     * include a switcher. Defaults to true.
+     */
+    switcher?: boolean | TabSwitcherProps;
+    /**
+     * True to enable activity tracking of tab views (default false).  Viewing of each tab will
+     * be tracked with the `oncePerSession` flag, to avoid duplication.
+     */
+    track?: boolean;
+    /**
+     * Strategy for rendering child tabs. Can be set per-tab via `TabModel.renderMode`. See enum
+     * for description of supported modes.
+     */
+    renderMode?: RenderMode;
+    /**
+     * Strategy for refreshing child tabs. Can be set per-tab via `TabModel.refreshMode`.
+     * See enum for description of supported modes.
+     */
+    refreshMode?: RefreshMode;
+    /** Options governing persistence. Cannot be used with `route`. */
+    persistWith?: PersistOptions;
+    /**
+     * Placeholder to display if no tabs are provided or all tabs have been removed via
+     * their `omit` config.
+     */
+    emptyText?: ReactNode;
+    /** @internal */
+    xhImpl?: boolean;
+}
+/**
+ * Model for a TabContainer, representing its layout/contents and the currently displayed Tab.
+ *
+ * This object provides support for routing based navigation, customizable (lazy) mounting and
+ * unmounting of inactive tabs, and customizable refreshing of tabs via a built-in RefreshContextModel.
+ *
+ * Note: Routing is currently enabled for desktop applications only.
+ */
+export declare class TabContainerModel extends HoistModel {
+    config: TabContainerConfig;
+    tabs: TabModel[];
+    activeTabId: string;
+    route: string;
+    defaultTabId: string;
+    switcher: TabSwitcherProps;
+    track: boolean;
+    renderMode: RenderMode;
+    refreshMode: RefreshMode;
+    emptyText: ReactNode;
+    provider: PersistenceProvider;
+    refreshContextModel: RefreshContextModel;
+    private lastActiveTabId;
+    constructor({ tabs, defaultTabId, route, switcher, track, renderMode, refreshMode, persistWith, emptyText, xhImpl }: TabContainerConfig);
+    /**
+     * Set the Tabs displayed by this object.
+     */
+    setTabs(tabs: Array<TabModel | TabConfig>): void;
+    /** Add a Tab for display.*/
+    addTab(tab: TabModel | TabConfig, opts?: AddTabOptions): TabModel;
+    /**
+     * Remove a Tab for display.
+     * @param tab - TabModel or id of TabModel to be removed.
+     */
+    removeTab(tab: TabModel | string): void;
+    findTab(id: string): TabModel;
+    get activeTab(): TabModel;
+    /** The tab immediately before the active tab in the model's tab list. */
+    get prevTab(): TabModel;
+    /** The tab immediately after the active tab in the model's tab list. */
+    get nextTab(): TabModel;
+    /**
+     * Set the currently active Tab.
+     *
+     * If using routing, this method will navigate to the new tab via the router and the active Tab
+     * will only be updated once the router state changes. Otherwise the active Tab will be updated
+     * immediately.
+     *
+     * @param tab - TabModel or id of TabModel to be activated.
+     */
+    activateTab(tab: TabModel | string): void;
+    /** Navigate to the tab immediately before the currently active tab, if any. */
+    activatePrevTab(): void;
+    /** Navigate to the tab immediately after the currently active tab, if any. */
+    activateNextTab(): void;
+    private setActiveTabIdInternal;
+    private syncWithRouter;
+    private forwardRouterToTab;
+    private calculateActiveTabId;
+    private setupStateProvider;
+}
+export interface AddTabOptions {
+    /** Index in tab collection where tab is to be added. */
+    index?: number;
+    /** True to immediately activate new tab. */
+    activateImmediately?: boolean;
+}

package/build/types/cmp/tab/TabModel.d.ts

@@ -0,0 +1,71 @@
+import { HoistModel, RefreshMode, RenderMode, Content, RefreshContextModel, Thunkable } from '@xh/hoist/core';
+import { TabContainerModel } from '@xh/hoist/cmp/tab/TabContainerModel';
+import { ReactElement, ReactNode } from 'react';
+export interface TabConfig {
+    /** Unique ID, used by container for locating tabs and generating routes. */
+    id: string;
+    /**
+     *  Parent TabContainerModel. Provided by the container when constructing these models -
+     *  no need for application to specify directly.
+     */
+    containerModel?: TabContainerModel;
+    /** Display title for the Tab in the container's TabSwitcher. */
+    title?: ReactNode;
+    /** Display icon for the Tab in the container's TabSwitcher. */
+    icon?: ReactElement;
+    /** Tooltip for the Tab in the container's TabSwitcher. */
+    tooltip?: ReactNode;
+    /** True to disable this tab in the TabSwitcher and block routing. */
+    disabled?: boolean;
+    /**
+     * True to hide this Tab in the TabSwitcher, but still be able to activate the tab manually
+     * or via routing.
+     */
+    excludeFromSwitcher?: boolean;
+    /** Display an affordance to allow the user to remove this tab from its container.*/
+    showRemoveAction?: boolean;
+    /** Item to be rendered by this tab.*/
+    content?: Content;
+    /**
+     * Strategy for rendering this tab. If null, will default to its container's mode. See enum
+     * for description of supported modes.
+     */
+    renderMode?: RenderMode;
+    /**
+     * Strategy for refreshing this tab. If null, will default to its container's mode. See enum
+     * for description of supported modes.
+     */
+    refreshMode?: RefreshMode;
+    /** True to skip this tab.  */
+    omit?: Thunkable<boolean>;
+    /** @internal */
+    xhImpl?: boolean;
+}
+/**
+ * Model for a Tab within a TabContainer. Specifies the actual content (child component) to be
+ * rendered within a tab and manages that content's active and refresh state.
+ *
+ * This model is not typically created directly within applications. Instead, specify a
+ * configuration for it via the `TabContainerModel.tabs` constructor config.
+ */
+export declare class TabModel extends HoistModel {
+    id: string;
+    title: ReactNode;
+    icon: ReactElement;
+    tooltip: ReactNode;
+    disabled: boolean;
+    excludeFromSwitcher: boolean;
+    showRemoveAction: boolean;
+    content: Content;
+    private _renderMode;
+    private _refreshMode;
+    containerModel: TabContainerModel;
+    refreshContextModel: RefreshContextModel;
+    get isTabModel(): boolean;
+    constructor({ id, containerModel, title, icon, tooltip, disabled, excludeFromSwitcher, showRemoveAction, content, refreshMode, renderMode, xhImpl }: TabConfig);
+    activate(): void;
+    get renderMode(): RenderMode;
+    get refreshMode(): RefreshMode;
+    get isActive(): boolean;
+    setDisabled(disabled: boolean): void;
+}

package/build/types/cmp/tab/TabSwitcherProps.d.ts

@@ -0,0 +1,16 @@
+import { BoxProps, HoistProps, Side } from '@xh/hoist/core';
+import { TabContainerModel } from './TabContainerModel';
+export interface TabSwitcherProps extends HoistProps<TabContainerModel>, BoxProps {
+    /** Relative position within the parent TabContainer. Defaults to 'top'. */
+    orientation?: Side;
+    /** True to animate the indicator when switching tabs. False (default) to change instantly. */
+    animate?: boolean;
+    /** Enable scrolling and place tabs that overflow into a menu. Default to false. */
+    enableOverflow?: boolean;
+    /** Width (in px) to render tabs. Only applies to horizontal orientations */
+    tabWidth?: number;
+    /** Minimum width (in px) to render tabs. Only applies to horizontal orientations */
+    tabMinWidth?: number;
+    /** Maximum width (in px) to render tabs. Only applies to horizontal orientations */
+    tabMaxWidth?: number;
+}

package/build/types/cmp/tab/index.d.ts

@@ -0,0 +1,4 @@
+export * from './TabModel';
+export * from './TabContainer';
+export * from './TabContainerModel';
+export * from './TabSwitcherProps';

package/build/types/cmp/websocket/WebSocketIndicator.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { BoxProps, HoistProps } from '@xh/hoist/core';
+export interface WebSocketIndicatorProps extends HoistProps, BoxProps {
+    /** True to display status as an icon only, without text label. */
+    iconOnly?: boolean;
+}
+/**
+ * Provides a visual indicator of connection status for @see {@link WebSocketService}.
+ */
+export declare const WebSocketIndicator: import("react").FC<WebSocketIndicatorProps>, webSocketIndicator: import("@xh/hoist/core").ElementFactory<WebSocketIndicatorProps>;

package/build/types/cmp/websocket/index.d.ts

@@ -0,0 +1 @@
+export * from './WebSocketIndicator';

package/build/types/core/AppSpec.d.ts

@@ -0,0 +1,106 @@
+import { HoistAppModel, ElementFactory, HoistProps } from '@xh/hoist/core';
+import { Component, ComponentClass, FunctionComponent } from 'react';
+/**
+ * Specification for a client-side Hoist application.
+ * Passed to XH.renderApp() to kick-off app rendering and available thereafter as `XH.appSpec`.
+ */
+export declare class AppSpec<T extends HoistAppModel = HoistAppModel> {
+    /**
+     *  Short code for this particular JS client application.
+     *  Will default to the `appCode` specified within the project's Webpack config, but can be
+     *  set to a more specific value (e.g. 'myAppMobile') to identify the client app in common
+     *  code or configs.
+     */
+    clientAppCode?: string;
+    /**
+     * Display name for this particular JS client application.
+     * As with `clientAppCode` above, this will default to the global `appName` specified by
+     * the project's Webpack config, but can be set here to a more specific value (e.g.
+     * 'MyApp Mobile').
+     */
+    clientAppName?: string;
+    /**
+     * Root Model class for the application. Note this is a reference
+     * to the class itself, not an instance, and must extend {@link HoistAppModel}.
+     */
+    modelClass: new () => T;
+    /**
+     * Root HoistComponent for the application. Despite the name,
+     * functional components are fully supported and expected.
+     */
+    componentClass: ComponentClass<HoistProps> | FunctionComponent<HoistProps>;
+    /**
+     * Container component to be used to host this application.
+     * This class determines the platform used by Hoist. The value should be imported from
+     * either `@xh/hoist/desktop/AppContainer` or `@xh/hoist/mobile/AppContainer`.
+     */
+    containerClass: ComponentClass<HoistProps> | FunctionComponent<HoistProps>;
+    /** True if the app should use the Hoist mobile toolkit.*/
+    isMobileApp: boolean;
+    /** True if SSO auth is enabled, as opposed to a login prompt. */
+    isSSO: boolean;
+    /**
+     * Method for determining if user may access the app.
+     * If a string, will be interpreted as the role required for basic UI access.
+     * Otherwise, function taking a user and returning a boolean or an object of the form
+     * `{hasAccess: boolean, message: 'explanatory message'}`.
+     */
+    checkAccess: string | ((user: object) => boolean | {
+        hasAccess: boolean;
+        message: string;
+    });
+    /**
+     *  Write a track log statement after the app has loaded and fully initialized?
+     *  Message will include elapsed time of asset loading and init.
+     */
+    trackAppLoad?: boolean;
+    /** Enable Hoist websocket connectivity? (default false) */
+    webSocketsEnabled?: boolean;
+    /**
+     * Optional custom Component to display when App has been suspended. The component will
+     * receive a single prop -- onReactivate -- a callback called when the user has acknowledged
+     * the suspension and wishes to reload the app.
+     */
+    idlePanel?: ElementFactory | FunctionComponent | Component;
+    /**
+     * Optional custom Component to display when the user is denied access to app. Intended for
+     * apps that implement custom auth flows. See also `lockoutMessage` for a more lightweight
+     * customization option.
+     */
+    lockoutPanel?: ElementFactory | FunctionComponent | Component;
+    /** Optional message to show on login form (for non-SSO apps). */
+    loginMessage?: string;
+    /** Optional message to show users when denied access to app. */
+    lockoutMessage?: string;
+    /**
+     * True to show the built-in browser context menu when no app-specific menu would be shown
+     * (e.g. from a Grid). False (the default) prevents the browser menu from being shown anywhere
+     * upon right-click.
+     */
+    showBrowserContextMenu?: boolean;
+    /**
+     * True to disable Field-level XSS protection by default across all Stores/Fields in the app.
+     * For use with secure, internal apps that do not display arbitrary/external user input and
+     * have tight performance tolerances and/or load very large recordsets.
+     * @see FieldConfig.disableXssProtection
+     */
+    disableXssProtection?: boolean;
+    constructor({ clientAppCode, clientAppName, modelClass, componentClass, containerClass, isMobileApp, isSSO, checkAccess, trackAppLoad, webSocketsEnabled, idlePanel, lockoutPanel, loginMessage, lockoutMessage, showBrowserContextMenu, disableXssProtection }: {
+        clientAppCode?: string;
+        clientAppName?: string;
+        modelClass: any;
+        componentClass: any;
+        containerClass: any;
+        isMobileApp: any;
+        isSSO: any;
+        checkAccess: any;
+        trackAppLoad?: boolean;
+        webSocketsEnabled?: boolean;
+        idlePanel?: any;
+        lockoutPanel?: any;
+        loginMessage?: any;
+        lockoutMessage?: any;
+        showBrowserContextMenu?: boolean;
+        disableXssProtection?: boolean;
+    });
+}

package/build/types/core/AppState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enumeration of possible App States
+ */
+export declare const AppState: Readonly<{
+    PRE_AUTH: "PRE_AUTH";
+    LOGIN_REQUIRED: "LOGIN_REQUIRED";
+    ACCESS_DENIED: "ACCESS_DENIED";
+    INITIALIZING: "INITIALIZING";
+    RUNNING: "RUNNING";
+    SUSPENDED: "SUSPENDED";
+    LOAD_FAILED: "LOAD_FAILED";
+}>;
+export type AppState = (typeof AppState)[keyof typeof AppState];

package/build/types/core/HoistAppModel.d.ts

@@ -0,0 +1,81 @@
+import { AppOptionSpec, HoistModel, Thunkable } from './';
+import { Route } from 'router5';
+import { ReactNode } from 'react';
+/**
+ * Specialized base class for defining the central model for a Hoist app as specified by its
+ * See the {@link AppSpec.modelClass} config, which should reference a concrete implementation class
+ * extending this base. Hoist will create and then initialize an instance of that class after
+ * the framework has successfully initialized and will make it available to all app code via the
+ * `XH.appModel` getter.
+ *
+ * Applications should specify this class to provide application level state and services and
+ * customize important metadata. Initialization of all resources (e.g. application level services)
+ * should be done in `initAsync()`.
+ *
+ * Hoist will load/reload this Model during the global refresh process. This will occur before the
+ * application's global `XH.refreshContextModel` has been refreshed (when all mounted and 'owned'
+ * HoistModels in the application are refreshed). AppModels should implement `doLoadAsync()` if
+ * required to refresh all other app-wide services and models, respecting any ordering and phasing
+ * requirements specific to its needs.
+ */
+export declare class HoistAppModel extends HoistModel {
+    /**
+     * Hoist will call this method early in the initialization sequence, prior to user
+     * authentication and full Hoist initialization. This means that several core services
+     * (identity, configs, prefs) will *not* be available, but it provides the app a hook to
+     * do early service initialization or other work to support flows such as OAuth.
+     */
+    static preAuthAsync(): Promise<void>;
+    /**
+     * Hoist will call this method after Hoist services have initialized and the application
+     * has mounted. Use to trigger initialization of the app and any app-specific services.
+     *
+     * Applications will typically use this method to install and initialize app-specific
+     * services using one or more phased calls to XH.installServicesAsync().
+     */
+    initAsync(): Promise<void>;
+    /**
+     * Called by {@link IdentityService.logoutAsync} to provide an app-specific hook prior
+     * to logging out an authenticated user. Applicable only to apps that generally support
+     * logout (i.e. not SSO) and require handling in addition to Hoist server logout.
+     */
+    logoutAsync(): Promise<void>;
+    /**
+     * Should the version bar be shown in this application?.
+     * Applications  for which  a version bar might not be appropriate (e.g. a mini-app
+     * being shown in a frame or modal) may override this getter and return false
+     */
+    get supportsVersionBar(): boolean;
+    /**
+     * Provide the initial set of Router5 Routes to be used by this application.
+     */
+    getRoutes(): Route[];
+    /**
+     * Provide a list of app-wide options to be displayed in the App's built-in Options
+     * dialog, accessible from the default AppBar menu when this method returns non-empty.
+     * @see AppOption
+     */
+    getAppOptions(): AppOptionSpec[];
+    /**
+     * Provide a list of app-wide metadata and version information to be displayed in the
+     * App's built-in About dialog.
+     */
+    getAboutDialogItems(): AboutDialogItem[];
+    /**
+     * Resets user preferences and any persistent local application state.
+     *
+     * The default implementation for this method will clear *all* preferences and local storage.
+     *
+     * Applications may wish to override this method to do a more targeted clearing of state.
+     * This is important for complex applications with smaller sub-applications, and/or device
+     * specific applications. These applications will typically want to perform a custom clearing
+     * that is more targeted, and includes any additional app-specific state.
+     */
+    restoreDefaultsAsync(): Promise<void>;
+}
+/** Object Describing an entry in the AboutDialog. */
+export interface AboutDialogItem {
+    label: ReactNode;
+    value: ReactNode;
+    omit?: Thunkable<boolean>;
+}

package/build/types/core/HoistBase.d.ts

@@ -0,0 +1,160 @@
+import { PersistOptions, DebounceSpec } from './';
+import { IAutorunOptions, IReactionOptions } from 'mobx/dist/api/autorun';
+import { IReactionDisposer } from 'mobx/dist/internal';
+export interface HoistBaseClass {
+    new (...args: any[]): HoistBase;
+    isHoistBase: boolean;
+}
+/**
+ * Base class for objects in Hoist.
+ * Provides misc. support for Mobx integration, state persistence, and resource cleanup.
+ *
+ * This class should not typically be extended directly by applications. Applications should
+ * extend one of its subclasses instead, notably:
+ * @see HoistModel
+ * @see HoistService
+ * @see Store
+ */
+export declare abstract class HoistBase {
+    static get isHoistBase(): boolean;
+    get isHoistBase(): boolean;
+    /**
+     * For XH internal use only - marks this instance as created by and for Hoist as part of its
+     * own implementation. Used as a filter within Hoist Inspector to distinguish services and
+     * models that are either created directly by the app developer or important/public parts of
+     * the Hoist API from those that are not.
+     * @internal
+     */
+    xhImpl: boolean;
+    private managedInstances;
+    private disposers;
+    private _destroyed;
+    private _xhImpl;
+    /** Default persistence options for this object. */
+    persistWith: PersistOptions;
+    /**
+     * Add and start one or more managed reactions.
+     *
+     * A reaction's run function will be executed on changes to any/all observables read in its
+     * track function, regardless of whether they - or any other observables - are accessed in
+     * the run function. The reaction will also run only when the output of the track function
+     * changes, and this output is passed to the run function.
+     *
+     * Specify the property 'track' to run the reaction continuously until disposal.
+     * Alternatively, specify the 'when' property to run this reaction only until the predicate
+     * passes, and the run function is executed once. (These map to mobX's native `reaction()`
+     * and `when()` functions, respectively).
+     *
+     * Specify the property 'equals' to determine how successive outputs of track will be compared.
+     * Hoist supports string specification of this (i.e. 'shallow','structural', or 'identity') and
+     * will map it to the underlying MobX `comparer` object.  For returns of arrays and objects,
+     * consider using the value 'shallow' over the default 'identity' to avoid triggering spurious
+     * changes. See MobX for more information.
+     *
+     * Choose this method over an autorun when you wish to explicitly declare which observables
+     * should be tracked. A common pattern is to have the track function return these
+     * observables in a simple array or object, which the run function can use as its input or
+     * (commonly) ignore. This helps to clarify that the track function is only enumerating
+     * the observables to be watched, and not necessarily generating or transforming values.
+     *
+     *  Reactions created in this method will be disposed of automatically when this object is
+     *  destroyed. They can also be ended/disposed of manually using the native MobX disposer
+     *  functions returned by this method.
+     *
+     * @param specs - one or more reactions to add
+     * @returns disposer(s) to manually dispose of each created reaction.
+     */
+    addReaction(...specs: ReactionSpec<any>[]): IReactionDisposer | IReactionDisposer[];
+    /**
+     * Add and start one or more managed autoruns.
+     *
+     * An autorun function will be run on changes to any/all observables read during the last
+     * execution of the function. This provides convenient and often very efficient dynamic
+     * reactivity. This is a core MobX concept and is important to fully understand when
+     * using autorun functions.
+     *
+     * In some cases, however, it is desirable or more clear to explicitly declare which
+     * observables should be tracked and trigger a reaction, regardless of their use within
+     * the function itself. See addReaction() above for that functionality.
+     *
+     * Autoruns created in this method will be disposed of automatically when this object is
+     * destroyed. They can also be ended/disposed of manually using the native mobx disposer
+     * functions returned by this method.
+     *
+     * @param specs - one or more autoruns to add
+     * @returns disposer(s) to manually dispose of each created autorun.
+     */
+    addAutorun(...specs: Array<AutoRunSpec | (() => any)>): IReactionDisposer | Array<IReactionDisposer>;
+    /**
+     * Set an observable/bindable value.
+     *
+     * This method is a convenience method for calling the conventional setXXX method
+     * for updating a mobx observable given the property name.
+     */
+    setBindable(property: string, value: any): void;
+    /** @returns a unique id for this object within the lifetime of this document. */
+    get xhId(): string;
+    /**
+     * Mark an object as managed by this object.
+     *
+     * Managed objects are assumed to hold objects that are created by the referencing object
+     * and therefore should be destroyed when the referencing object is destroyed.
+     *
+     * See also {@link managed}, a decorator that can be used to mark any object held within
+     * a given property as managed.
+     *
+     * @param obj - object to be destroyed when this instance is destroyed
+     * @returns object passed
+     */
+    markManaged<T>(obj: T): T;
+    /**
+     *  Method to make a class property persistent, syncing its value via a configured
+     * `PersistenceProvider` to maintain and restore values across browser sessions.
+     *
+     * This may be used on any `@observable` or `@bindable` class property which is a primitive.
+     * It will initialize the observable's value from the class's default `PersistenceProvider` and
+     * will write back any changes to the property to that Provider. If the Provider has not yet
+     * been populated with a value, or an error occurs, it will use the value set in-code instead.
+     *
+     * See also {@link persist} and {@link persist.with} for a decorator that may be used directly
+     * on the property declaration itself. Use this method in the general case, when you need to
+     * control the timing.
+     *
+     * @param property - name of property on this object to bind to a persistence provider.
+     * @param options - options governing the persistence of this object. These will be applied
+     *      on top of any default persistWith options defined on the instance itself.
+     */
+    markPersist(property: string, options?: PersistOptions): void;
+    /** @returns true if this instance has been destroyed. */
+    get isDestroyed(): boolean;
+    /**
+     * Clean up resources associated with this object
+     */
+    destroy(): void;
+}
+/**
+ * Object containing options accepted by MobX 'reaction' API as well as arguments below.
+ */
+export interface ReactionSpec<T = any> extends IReactionOptions<T, any> {
+    /**
+     * Function returning data to observe - first arg to the underlying reaction() call.
+     * Specify this or `when`.
+     */
+    track?: () => T;
+    /**
+     * Function determining when reaction should fire - first arg to the underlying when() call.
+     * Specify this or `track`.
+     */
+    when?: () => boolean;
+    /** Function to run - second arg to underlying reaction()/when() call. */
+    run?: (curr?: T, prev?: T) => void;
+    /** Specify to debounce run function */
+    debounce?: DebounceSpec;
+}
+/**
+ * Object containing options accepted by MobX 'autorun' API as well as arguments below.
+ */
+export interface AutoRunSpec extends IAutorunOptions {
+    /** Function to run - first arg to underlying autorun() call. */
+    run?: () => void;
+}

package/build/types/core/HoistBaseDecorators.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Decorator to make a property "managed". Managed properties are designed to hold objects that
+ * are created by the referencing object and that implement a `destroy()` method.
+ *
+ * @see HoistBase.markManaged
+ */
+export declare const managed: any;
+/**
+ * Decorator to make a class property persistent.
+ *
+ * This decorator provides the same functionality as {@link HoistBase.markPersist}. See that method
+ * for more details.
+ *
+ * This decorator should always be applied "before" the mobx decorator, i.e. second in file line
+ * order: `@bindable @persist fooBarFlag = true`
+ *
+ * See also `@persist.with`, a higher-order version of this decorator that allows for setting
+ * property-specific persistence options.
+ */
+export declare const persist: any;