@jbrowse/product-core 2.6.1

package/dist/RootModel/BaseRootModel.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRootModel = exports.BaseRootModelFactory = void 0;
+const assemblyManager_1 = __importDefault(require("@jbrowse/core/assemblyManager"));
+const RpcManager_1 = __importDefault(require("@jbrowse/core/rpc/RpcManager"));
+const mobx_state_tree_1 = require("mobx-state-tree");
+const TextSearchManager_1 = __importDefault(require("@jbrowse/core/TextSearch/TextSearchManager"));
+/**
+ * #stateModel BaseRootModel
+ * #category root
+ * factory function for the Base-level root model shared by all products
+ */
+function BaseRootModelFactory({ pluginManager, jbrowseModelType, sessionModelType, assemblyConfigSchema, }) {
+    return mobx_state_tree_1.types
+        .model('BaseRootModel', {
+        /**
+         * #property
+         * `jbrowse` is a mapping of the config.json into the in-memory state
+         * tree
+         */
+        jbrowse: jbrowseModelType,
+        /**
+         * #property
+         * `session` encompasses the currently active state of the app, including
+         * views open, tracks open in those views, etc.
+         */
+        session: mobx_state_tree_1.types.maybe(sessionModelType),
+        /**
+         * #property
+         */
+        sessionPath: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.string, ''),
+        /**
+         * #property
+         */
+        assemblyManager: mobx_state_tree_1.types.optional((0, assemblyManager_1.default)(assemblyConfigSchema, pluginManager), {}),
+    })
+        .volatile(self => ({
+        rpcManager: new RpcManager_1.default(pluginManager, self.jbrowse.configuration.rpc, {
+            MainThreadRpcDriver: {},
+        }),
+        adminMode: false,
+        isAssemblyEditing: false,
+        error: undefined,
+        textSearchManager: new TextSearchManager_1.default(pluginManager),
+        pluginManager,
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setError(error) {
+            self.error = error;
+        },
+        /**
+         * #action
+         */
+        setSession(sessionSnapshot) {
+            self.session = (0, mobx_state_tree_1.cast)(sessionSnapshot);
+        },
+        /**
+         * #action
+         */
+        setDefaultSession() {
+            this.setSession(self.jbrowse.defaultSession);
+        },
+        /**
+         * #action
+         */
+        setSessionPath(path) {
+            self.sessionPath = path;
+        },
+        /**
+         * #action
+         */
+        renameCurrentSession(newName) {
+            if (self.session) {
+                const snapshot = JSON.parse(JSON.stringify((0, mobx_state_tree_1.getSnapshot)(self.session)));
+                snapshot.name = newName;
+                this.setSession(snapshot);
+            }
+        },
+        /**
+         * #action
+         */
+        setAssemblyEditing(flag) {
+            self.isAssemblyEditing = flag;
+        },
+    }));
+}
+exports.BaseRootModelFactory = BaseRootModelFactory;
+/** Type guard for checking if something is a JB root model */
+function isRootModel(thing) {
+    return ((0, mobx_state_tree_1.isStateTreeNode)(thing) &&
+        'session' in thing &&
+        'jbrowse' in thing &&
+        'assemblyManager' in thing);
+}
+exports.isRootModel = isRootModel;

package/dist/RootModel/InternetAccounts.d.ts

@@ -0,0 +1,31 @@
+import PluginManager from '@jbrowse/core/PluginManager';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import { UriLocation } from '@jbrowse/core/util';
+import { Instance } from 'mobx-state-tree';
+/**
+ * #stateModel InternetAccountsMixin
+ * #category root
+ */
+export declare function InternetAccountsRootModelMixin(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
+    internetAccounts: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyType>;
+}, {
+    /**
+     * #action
+     */
+    initializeInternetAccount(internetAccountConfig: AnyConfigurationModel, initialSnapshot?: {}): any;
+    /**
+     * #action
+     */
+    createEphemeralInternetAccount(internetAccountId: string, initialSnapshot: {} | undefined, url: string): any;
+    /**
+     * #action
+     */
+    findAppropriateInternetAccount(location: UriLocation): any;
+} & {
+    afterCreate(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export type RootModelWithInternetAccountsType = ReturnType<typeof InternetAccountsRootModelMixin>;
+export type RootModelWithInternetAccounts = Instance<RootModelWithInternetAccountsType>;

package/dist/RootModel/InternetAccounts.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternetAccountsRootModelMixin = void 0;
+const mobx_1 = require("mobx");
+const mobx_state_tree_1 = require("mobx-state-tree");
+/**
+ * #stateModel InternetAccountsMixin
+ * #category root
+ */
+function InternetAccountsRootModelMixin(pluginManager) {
+    return mobx_state_tree_1.types
+        .model({
+        /**
+         * #property
+         */
+        internetAccounts: mobx_state_tree_1.types.array(pluginManager.pluggableMstType('internet account', 'stateModel')),
+    })
+        .actions(self => ({
+        /**
+         * #action
+         */
+        initializeInternetAccount(internetAccountConfig, initialSnapshot = {}) {
+            const internetAccountType = pluginManager.getInternetAccountType(internetAccountConfig.type);
+            if (!internetAccountType) {
+                throw new Error(`unknown internet account type ${internetAccountConfig.type}`);
+            }
+            const length = self.internetAccounts.push({
+                ...initialSnapshot,
+                type: internetAccountConfig.type,
+                configuration: internetAccountConfig,
+            });
+            return self.internetAccounts[length - 1];
+        },
+        /**
+         * #action
+         */
+        createEphemeralInternetAccount(internetAccountId, initialSnapshot = {}, url) {
+            let hostUri;
+            try {
+                hostUri = new URL(url).origin;
+            }
+            catch (e) {
+                // ignore
+            }
+            // id of a custom new internaccount is `${type}-${name}`
+            const internetAccountSplit = internetAccountId.split('-');
+            const configuration = {
+                type: internetAccountSplit[0],
+                internetAccountId: internetAccountId,
+                name: internetAccountSplit.slice(1).join('-'),
+                description: '',
+                domains: hostUri ? [hostUri] : [],
+            };
+            const type = pluginManager.getInternetAccountType(configuration.type);
+            const internetAccount = type.stateModel.create({
+                ...initialSnapshot,
+                type: configuration.type,
+                configuration,
+            });
+            self.internetAccounts.push(internetAccount);
+            return internetAccount;
+        },
+        /**
+         * #action
+         */
+        findAppropriateInternetAccount(location) {
+            // find the existing account selected from menu
+            const selectedId = location.internetAccountId;
+            if (selectedId) {
+                const selectedAccount = self.internetAccounts.find(account => {
+                    return account.internetAccountId === selectedId;
+                });
+                if (selectedAccount) {
+                    return selectedAccount;
+                }
+            }
+            // if no existing account or not found, try to find working account
+            for (const account of self.internetAccounts) {
+                const handleResult = account.handlesLocation(location);
+                if (handleResult) {
+                    return account;
+                }
+            }
+            // if still no existing account, create ephemeral config to use
+            return selectedId
+                ? this.createEphemeralInternetAccount(selectedId, {}, location.uri)
+                : null;
+        },
+    }))
+        .actions(self => ({
+        afterCreate() {
+            (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(() => {
+                const { jbrowse } = self;
+                jbrowse.internetAccounts.forEach(self.initializeInternetAccount);
+            }));
+        },
+    }));
+}
+exports.InternetAccountsRootModelMixin = InternetAccountsRootModelMixin;

package/dist/RootModel/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BaseRootModel';
+export * from './InternetAccounts';

package/dist/RootModel/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BaseRootModel"), exports);
+__exportStar(require("./InternetAccounts"), exports);

package/dist/Session/BaseSession.d.ts

@@ -0,0 +1,99 @@
+import PluginManager from '@jbrowse/core/PluginManager';
+import { IAnyStateTreeNode, Instance } from 'mobx-state-tree';
+import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { BaseRootModelType } from '../RootModel/BaseRootModel';
+/**
+ * #stateModel BaseSessionModel
+ * base session shared by **all** JBrowse products. Be careful what you include
+ * here, everything will use it.
+ */
+export declare function BaseSessionModel<ROOT_MODEL_TYPE extends BaseRootModelType, JB_CONFIG_SCHEMA extends AnyConfigurationSchemaType>(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    name: import("mobx-state-tree").ISimpleType<string>;
+    margin: import("mobx-state-tree").IType<number | undefined, number, number>;
+}, {
+    /**
+     * #volatile
+     * this is the globally "selected" object. can be anything. code that
+     * wants to deal with this should examine it to see what kind of thing it
+     * is.
+     */
+    selection: unknown;
+} & {
+    readonly root: import("mobx-state-tree").TypeOrStateTreeNodeToStateTreeNode<ROOT_MODEL_TYPE>;
+} & {
+    /**
+     * #getter
+     */
+    readonly jbrowse: any;
+    /**
+     * #getter
+     */
+    readonly rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
+    /**
+     * #getter
+     */
+    readonly configuration: Instance<JB_CONFIG_SCHEMA>;
+    /**
+     * #getter
+     */
+    readonly adminMode: boolean;
+    /**
+     * #getter
+     */
+    readonly textSearchManager: import("@jbrowse/core/util").TextSearchManager;
+} & {
+    /**
+     * #getter
+     */
+    readonly assemblies: ({
+        [x: string]: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: unknown): any;
+    } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        aliases: {
+            type: string;
+            defaultValue: never[];
+            description: string;
+        };
+        sequence: AnyConfigurationSchemaType;
+        refNameColors: {
+            type: string;
+            defaultValue: never[];
+            description: string;
+        };
+        refNameAliases: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            adapter: import("mobx-state-tree").IAnyModelType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        cytobands: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            adapter: import("mobx-state-tree").IAnyModelType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        displayName: {
+            type: string;
+            defaultValue: string;
+            description: string; /**
+             * #getter
+             */
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "name">>>)[];
+} & {
+    /**
+     * #action
+     * set the global selection, i.e. the globally-selected object. can be a
+     * feature, a view, just about anything
+     */
+    setSelection(thing: unknown): void;
+    /**
+     * #action
+     * clears the global selection
+     */
+    clearSelection(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+/** Session mixin MST type for the most basic session */
+export type BaseSessionType = ReturnType<typeof BaseSessionModel>;
+/** Instance of the most basic possible session */
+export type BaseSession = Instance<BaseSessionType>;
+/** Type guard for BaseSession */
+export declare function isBaseSession(thing: IAnyStateTreeNode): thing is BaseSession;
+/** Type guard for whether a thing is JBrowse session */
+export declare function isSession(thing: unknown): thing is BaseSession;

package/dist/Session/BaseSession.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSession = exports.isBaseSession = exports.BaseSessionModel = void 0;
+const shortid_1 = __importDefault(require("shortid"));
+const mobx_state_tree_1 = require("mobx-state-tree");
+/**
+ * #stateModel BaseSessionModel
+ * base session shared by **all** JBrowse products. Be careful what you include
+ * here, everything will use it.
+ */
+function BaseSessionModel(pluginManager) {
+    return mobx_state_tree_1.types
+        .model({
+        /**
+         * #property
+         */
+        id: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.identifier, (0, shortid_1.default)()),
+        /**
+         * #property
+         */
+        name: mobx_state_tree_1.types.string,
+        /**
+         * #property
+         */
+        margin: 0,
+    })
+        .volatile(() => ({
+        /**
+         * #volatile
+         * this is the globally "selected" object. can be anything. code that
+         * wants to deal with this should examine it to see what kind of thing it
+         * is.
+         */
+        selection: undefined,
+    }))
+        .views(self => ({
+        get root() {
+            return (0, mobx_state_tree_1.getParent)(self);
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get jbrowse() {
+            return self.root.jbrowse;
+        },
+        /**
+         * #getter
+         */
+        get rpcManager() {
+            return self.root.rpcManager;
+        },
+        /**
+         * #getter
+         */
+        get configuration() {
+            return this.jbrowse.configuration;
+        },
+        /**
+         * #getter
+         */
+        get adminMode() {
+            return self.root.adminMode;
+        },
+        /**
+         * #getter
+         */
+        get textSearchManager() {
+            return self.root.textSearchManager;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get assemblies() {
+            return self.jbrowse.assemblies;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         * set the global selection, i.e. the globally-selected object. can be a
+         * feature, a view, just about anything
+         */
+        setSelection(thing) {
+            self.selection = thing;
+        },
+        /**
+         * #action
+         * clears the global selection
+         */
+        clearSelection() {
+            self.selection = undefined;
+        },
+    }));
+}
+exports.BaseSessionModel = BaseSessionModel;
+/** Type guard for BaseSession */
+function isBaseSession(thing) {
+    return 'id' in thing && 'name' in thing && 'root' in thing;
+}
+exports.isBaseSession = isBaseSession;
+/** Type guard for whether a thing is JBrowse session */
+function isSession(thing) {
+    return (0, mobx_state_tree_1.isStateTreeNode)(thing) && isBaseSession(thing);
+}
+exports.isSession = isSession;

package/dist/Session/Connections.d.ts

@@ -0,0 +1,174 @@
+import PluginManager from '@jbrowse/core/PluginManager';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import { IAnyStateTreeNode, Instance } from 'mobx-state-tree';
+import { BaseConnectionConfigModel } from '@jbrowse/core/pluggableElementTypes/models/baseConnectionConfig';
+/**
+ * #stateModel ConnectionManagementSessionMixin
+ */
+export declare function ConnectionManagementSessionMixin(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
+    connectionInstances: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+        name: import("mobx-state-tree").ISimpleType<string>;
+        tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>;
+        configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            name: {
+                type: string;
+                defaultValue: string;
+                description: string;
+            };
+            assemblyNames: {
+                type: string; /**
+                 * #property
+                 */
+                defaultValue: never[];
+                description: string;
+            };
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>;
+    }, {
+        afterAttach(): void;
+        addTrackConf(trackConf: {
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>): any;
+        addTrackConfs(trackConfs: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): any[];
+        setTrackConfs(trackConfs: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IAnyModelType> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>>;
+        clear(): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+}, {
+    /**
+     * #getter
+     */
+    readonly connections: ({
+        [x: string]: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: unknown): any;
+    } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        name: {
+            type: string;
+            defaultValue: string;
+            description: string;
+        };
+        assemblyNames: {
+            type: string;
+            defaultValue: never[];
+            description: string;
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>>)[];
+} & {
+    /**
+     * #action
+     */
+    makeConnection(configuration: AnyConfigurationModel, initialSnapshot?: {}): {
+        name: string;
+        tracks: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IAnyModelType> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>>;
+        configuration: {
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            name: {
+                type: string;
+                defaultValue: string;
+                description: string;
+            };
+            assemblyNames: {
+                type: string; /**
+                 * #property
+                 */
+                defaultValue: never[];
+                description: string;
+            };
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>>;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        afterAttach(): void;
+        addTrackConf(trackConf: {
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>): any;
+        addTrackConfs(trackConfs: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): any[];
+        setTrackConfs(trackConfs: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IAnyModelType> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>>;
+        clear(): void;
+    } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+        name: import("mobx-state-tree").ISimpleType<string>;
+        tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>;
+        configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            name: {
+                type: string;
+                defaultValue: string;
+                description: string;
+            };
+            assemblyNames: {
+                type: string; /**
+                 * #property
+                 */
+                defaultValue: never[];
+                description: string;
+            };
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>;
+    }, {
+        afterAttach(): void;
+        addTrackConf(trackConf: {
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>): any;
+        addTrackConfs(trackConfs: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): any[];
+        setTrackConfs(trackConfs: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IAnyModelType> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>>;
+        clear(): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    /**
+     * #action
+     */
+    prepareToBreakConnection(configuration: AnyConfigurationModel): (Record<string, number> | (() => void))[] | undefined;
+    /**
+     * #action
+     */
+    breakConnection(configuration: AnyConfigurationModel): void;
+    /**
+     * #action
+     */
+    deleteConnection(configuration: AnyConfigurationModel): any;
+    /**
+     * #action
+     */
+    addConnectionConf(connectionConf: BaseConnectionConfigModel): any;
+    /**
+     * #action
+     */
+    clearConnections(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+/** Session mixin MST type for a session that has connections */
+export type SessionWithConnectionsType = ReturnType<typeof ConnectionManagementSessionMixin>;
+/** Instance of a session that has connections: `connectionInstances`,
+ * `makeConnection()`, etc. */
+export type SessionWithConnections = Instance<SessionWithConnectionsType>;
+/** Type guard for SessionWithConnections */
+export declare function isSessionWithConnections(session: IAnyStateTreeNode): session is SessionWithConnections;