# JBrowseDesktopSessionModel Auto-generated @jbrowse/mobx-state-tree API for the current JBrowse release — see [pluggable elements](https://jbrowse.org/jb2-staging/docs/developer_guide/) for concepts. [View source](https://github.com/GMOD/jbrowse-components/blob/main/products/jbrowse-desktop/src/sessionModel/sessionModel.ts). JBrowseDesktopSessionModel declares no members of its own — it composes the models below, and everything here is theirs. ## Properties | Member | Description | Defined by | | --- | --- | --- | | **connectionInstances**
connectionInstances: types.stripDefault(
        types.array(pluginManager.pluggableMstType('connection', 'stateModel')),
        [],
      )
 | | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#property-connectioninstances) | | **connectionTrackConfigs**
connectionTrackConfigs: types.stripDefault(
        types.frozen<Record<string, ConnectionTrackConfigEntry>>(),
        {},
      )
 | Persisted configs of connection tracks the user has opened, keyed by trackId. Unlike `connectionInstances` (stripped from snapshots, holds the whole fetched hub), this holds only the tracks in use, so an open connection track resolves synchronously on session load without re-establishing the connection. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#property-connectiontrackconfigs) | | **id**
id: ElementId | | [BaseSessionModel](../basesessionmodel#property-id) | | **name**
name: types.string | | [BaseSessionModel](../basesessionmodel#property-name) | | **focusedViewId**
focusedViewId: types.maybe(types.string) | used to keep track of which view is in focus | [BaseSessionModel](../basesessionmodel#property-focusedviewid) | | **highlightsVisible**
highlightsVisible: types.stripDefault(types.boolean, true) | one session-wide toggle for all region highlight bands (URL/view highlights and bookmark overlays) | [BaseSessionModel](../basesessionmodel#property-highlightsvisible) | | **sessionAssemblies**
sessionAssemblies: types.stripDefault(
        types.array(assemblyConfigSchemasType),
        [],
      )
 | | [AssembliesMixin](../assembliesmixin#property-sessionassemblies) | | **temporaryAssemblies**
temporaryAssemblies: types.stripDefault(
        types.array(assemblyConfigSchemasType),
        [],
      )
 | | [AssembliesMixin](../assembliesmixin#property-temporaryassemblies) | | **viewIds**
viewIds: types.array(types.string) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-viewids) | | **title**
title: types.maybe(types.string) | set only by an explicit rename; otherwise the name is derived from views | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-title) | | **size**
size: types.optional(types.number, 1) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-size) | | **tabs**
tabs: types.array(LayoutTab) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-tabs) | | **activeTabId**
activeTabId: types.maybe(types.string) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-activetabid) | | **size**
size: types.optional(types.number, 1) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-size) | | **direction**
direction: types.enumeration('LayoutDirection', ['row', 'column'])
 | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-direction) | | **children**
children: types.array(
    types.late((): typeof LayoutPanel => LayoutNode as never),
  )
 | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-children) | | **layout**
layout: types.optional(LayoutNode, emptyPanel) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-layout) | | **activePanelId**
activePanelId: types.maybe(types.string) | | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-activepanelid) | | **maximizedPanelId**
maximizedPanelId: types.maybe(types.string) | Show only this cell, at the size of the whole workspace.

Deliberately HERE and not a `maximized` flag on `PanelNode`. On the node it would be inside `tree.ts`, the half that carries the risk and is proven by a randomised operation sequence asserting canonical form after every step — and every operation would then have to say what it does to the flag: a split of a maximized panel, a drag of its last tab out, a normalize that collapses it into its parent. Beside `activePanelId` it is the same class of thing as `activePanelId`, including its failure mode, which `livePanelIds` already repairs. | [WorkspaceLayoutMixin](../workspacelayoutmixin#property-maximizedpanelid) | | **views**
views: types.array(
          pluginManager.pluggableMstType('view', 'stateModel'),
        )
 | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#property-views) | | **stickyViewHeaders**
stickyViewHeaders: types.optional(types.boolean, () =>
          localStorageGetBoolean('stickyViewHeaders', true),
        )
 | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#property-stickyviewheaders) | | **useWorkspaces**
useWorkspaces: types.stripDefault(
          types.maybe(types.boolean),
          undefined,
        )
 | enables the tabbed/tiled workspace layout for this session. Undefined means unspecified — read `effectiveUseWorkspaces`. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#property-useworkspaces) | | **drawerPosition**
drawerPosition: types.optional(
        types.string,
        () => localStorageGetItem('drawerPosition') ?? 'right',
      )
 | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#property-drawerposition) | | **drawerWidth**
drawerWidth: types.stripDefault(
        types.refinement(types.integer, width => width >= minDrawerWidth),
        384,
      )
 | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#property-drawerwidth) | | **widgets**
widgets: types.stripDefault(types.map(widgetStateModelType), {}) | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#property-widgets) | | **activeWidgets**
activeWidgets: types.stripDefault(
        types.map(types.safeReference(widgetStateModelType)),
        {},
      )
 | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#property-activewidgets) | | **minimized**
minimized: types.stripDefault(types.boolean, false) | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#property-minimized) | ## Volatiles | Member | Description | Defined by | | --- | --- | --- | | **sessionThemeName**
sessionThemeName: localStorageGetItem('themeName') ?? 'default' | | [ThemeManagerSessionMixin](../thememanagersessionmixin#volatile-sessionthemename) | | **selection**
selection: undefined as unknown | 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. | [BaseSessionModel](../basesessionmodel#volatile-selection) | | **hovered**
hovered: undefined as unknown | this is the globally "hovered" object. can be anything. code that wants to deal with this should examine it to see what kind of thing it is. | [BaseSessionModel](../basesessionmodel#volatile-hovered) | | **queueOfDialogs**
queueOfDialogs: [] as [DialogComponentType, Record<string, unknown>][]
 | | [BaseSessionModel](../basesessionmodel#volatile-queueofdialogs) | | **preferencesOverrides**
preferencesOverrides: observable.map<string, unknown>(undefined, {
        deep: false,
      })
 | runtime user-preference overrides keyed by preference id, resolved by `getPreference` against the `configuration.preferences` admin defaults. Empty here (config-only); products that let users edit preferences load and persist these via localStorage. A runtime override map layered over config defaults, kept off the snapshot since prefs are local UI.

An `observable.map` (not a plain object reassigned wholesale) so each preference is its own tracked key: writing one (`setScrollZoom`) can't invalidate a reader of another (`getDisplayTypeDefault` in a track's `rpcProps`). A single spread-replaced object made every setter wake every reader, so toggling scroll-to-zoom re-fetched every track. For the same reason each promoted per-display-type default is a flat composite key (see `displayTypeDefaultKey`), not a single nested `displayTypeDefaults` object — promoting one default can't wake readers of a different one.

`deep: false` is load-bearing, not a micro-optimization. The default enhancer wraps an object/array value in a MobX Proxy on `set`, and a promoted default is handed straight back out by `getConf` — so an object-valued promotable slot (alignments `colorBy`) put a Proxy into `rpcProps()`, and V8's structured-clone serializer rejects a Proxy: `worker.postMessage` threw `DataCloneError` on the next fetch of any track following that default (electron IPC and `structuredClone` in the share bake likewise). The map still notifies per key on `set`, so shallow values lose no reactivity — and nothing can mutate a preference in place, because `setPreferenceOverride` freezes what it stores. | [BaseSessionModel](../basesessionmodel#volatile-preferencesoverrides) | | **snackbarMessages**
snackbarMessages: observable.array<SnackbarMessage>() | | [SnackbarModel](../snackbarmodel#volatile-snackbarmessages) | | **errorDialog**
errorDialog: undefined as ErrorDialogState | undefined | the error currently shown in the stack-trace dialog. Kept off the dialog queue so it can stack on top of an already-open dialog (e.g. the one whose action raised the error) instead of waiting behind it | [SnackbarModel](../snackbarmodel#volatile-errordialog) | | **poppedOut**
poppedOut: false | true while the visible widget is shown in a modal dialog instead of the drawer. Volatile because a restored session that opened straight into a modal, with no drawer behind it, is disorienting | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#volatile-poppedout) | ## Getters | Member | Description | Defined by | | --- | --- | --- | | **connections**
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
 | | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#getter-connections) | | **themeName**
string | | [ThemeManagerSessionMixin](../thememanagersessionmixin#getter-themename) | | **themeOptions**
SerializableThemeArgs | | [ThemeManagerSessionMixin](../thememanagersessionmixin#getter-themeoptions) | | **palette**
JBrowsePalette | Every color JBrowse renders, resolved to plain strings. This is what rendering reads: it needs no React context, it crosses the RPC worker boundary as itself, and it costs no UI toolkit. Prefer it over `theme` anywhere the answer wanted is a color rather than a Material UI component style. | [ThemeManagerSessionMixin](../thememanagersessionmixin#getter-palette) | | **styleTheme**
JBrowseStyleTheme | The palette plus the sizing tokens `makeStyles` reads — spacing, corner radius, type scale. This is what a product mounts on `StyleThemeProvider`; it costs no UI toolkit, and it is derived from the same `themeOptions` as `theme`, so a config `theme` that sets `spacing` moves JBrowse's own styles and its Material components together. | [ThemeManagerSessionMixin](../thememanagersessionmixin#getter-styletheme) | | **theme**
Theme | The Material UI theme, for the components that are Material UI. Its palette is spliced from the same `resolvePalette` call as `palette` above, so the two cannot disagree. | [ThemeManagerSessionMixin](../thememanagersessionmixin#getter-theme) | | **tracks**
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
 | | [TracksManagerSessionMixin](../tracksmanagersessionmixin#getter-tracks) | | **root**
TypeOrStateTreeNodeToStateTreeNode<ROOT_MODEL_TYPE> | | [BaseSessionModel](../basesessionmodel#getter-root) | | **jbrowse**
any | | [BaseSessionModel](../basesessionmodel#getter-jbrowse) | | **rpcManager**
RpcManager | | [BaseSessionModel](../basesessionmodel#getter-rpcmanager) | | **configuration**
Instance<JB_CONFIG_SCHEMA> | | [BaseSessionModel](../basesessionmodel#getter-configuration) | | **adminMode**
boolean | | [BaseSessionModel](../basesessionmodel#getter-adminmode) | | **textSearchManager**
TextSearchManager | | [BaseSessionModel](../basesessionmodel#getter-textsearchmanager) | | **assemblies**
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
 | | [BaseSessionModel](../basesessionmodel#getter-assemblies) | | **DialogComponent**
DialogComponentType | | [BaseSessionModel](../basesessionmodel#getter-dialogcomponent) | | **DialogProps**
Record<string, unknown> | | [BaseSessionModel](../basesessionmodel#getter-dialogprops) | | **animationMode**
AnimationMode | resolved feature-layout animation mode (never undefined) | [BaseSessionModel](../basesessionmodel#getter-animationmode) | | **scrollZoom**
boolean | resolved scroll-to-zoom preference. Global and personal (never shared in a session snapshot); every wheel-zoom view reads this single value. | [BaseSessionModel](../basesessionmodel#getter-scrollzoom) | | **numberGrouping**
boolean | resolved thousand-separator preference. Read for display in the Preferences dialog; the formatter itself reads a plain module variable set at startup in each realm (see `setNumberGrouping`), because worker- built strings can't see a main-thread observable. | [BaseSessionModel](../basesessionmodel#getter-numbergrouping) | | **snackbarMessageSet**
Map<string, SnackbarMessage> | | [SnackbarModel](../snackbarmodel#getter-snackbarmessageset) | | **assemblyNames**
string[] | names of the assemblies returned by the `assemblies` getter | [AssembliesMixin](../assembliesmixin#getter-assemblynames) | | **version**
string | | [AppSessionMixin](../appsessionmixin#getter-version) | | **gitCommit**
string | undefined | | [AppSessionMixin](../appsessionmixin#getter-gitcommit) | | **history**
{ canUndo: boolean; canRedo: boolean; undo(): void; redo(): void; } | undefined
 | | [AppSessionMixin](../appsessionmixin#getter-history) | | **assemblyManager**
ModelInstanceTypeProps<…> & {…} & {…} & {…} & {…} & {…} & {…} & IStateTreeNode<…>
 | | [AppSessionMixin](../appsessionmixin#getter-assemblymanager) | | **tree**
LayoutTree | The plain tree the pure functions take.

`getSnapshot` is a `keepAlive` computed, so this is cached and referentially stable — which also lets MST's reconcile short-circuit on identity when `apply` writes an untouched subtree back.

Uncast on purpose: the models below and the interfaces in `tree.ts` are two spellings of one shape, and this assignment is the only thing that checks they agree. | [WorkspaceLayoutMixin](../workspacelayoutmixin#getter-tree) | | **panels**
PanelNode[] | | [WorkspaceLayoutMixin](../workspacelayoutmixin#getter-panels) | | **tabs**
TabNode[] | | [WorkspaceLayoutMixin](../workspacelayoutmixin#getter-tabs) | | **visibleTree**
LayoutTree | What to render: the maximized cell alone, or the whole tree.

Sized to 1 rather than handed over as it sits. A pane's `size` is its share of its siblings, and CSS distributes free space by grow factor only up to a total of 1 — so a cell that was a third of a row, alone in the workspace with `flexGrow: 0.33`, draws a third of the window and leaves the rest blank. | [WorkspaceLayoutMixin](../workspacelayoutmixin#getter-visibletree) | | **effectiveUseWorkspaces**
boolean | resolved workspaces flag (never undefined): this session's value, else the user preference over the `configuration.preferences.useWorkspaces` admin default. Every consumer reads this, not the raw property — only sessions built from a snapshot or a spec `layout` set that, so the admin default is what reaches the arrivals that bypass defaultSession. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#getter-effectiveuseworkspaces) | | **defaultUseWorkspaces**
boolean | what `effectiveUseWorkspaces` becomes after `resetUseWorkspaces` — the admin default, with both this session's own value and the user's override out of the way. The Preferences reset diff needs this rather than the override map, which can't see a session-scoped value (a spec `layout`, a "move view to a tab") and so reported nothing to reset. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#getter-defaultuseworkspaces) | | **visibleWidget**
Widget | undefined | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#getter-visiblewidget) | ## Methods | Member | Description | Defined by | | --- | --- | --- | | **getReferringMultiple**
(trackIds: string[]) => Map<string, ReferringNode[]> | Walk the tree once and map each requested trackId to the nodes holding a `types.reference` that resolves to it (a view's track entry, a config editor widget). Track configs are matched by trackId, not identity, so a frozen base and its hydrated MST node compare equal. | [ReferenceManagementSessionMixin](../referencemanagementsessionmixin#method-getreferringmultiple) | | **getReferring**
(trackId: string) => ReferringNode[] | The nodes currently referring to `trackId` (see getReferringMultiple). | [ReferenceManagementSessionMixin](../referencemanagementsessionmixin#method-getreferring) | | **allThemes**
() => ThemeMap | | [ThemeManagerSessionMixin](../thememanagersessionmixin#method-allthemes) | | **getActiveThemeOptions**
(name?: string | undefined) => ThemeOptions & { name?: string | undefined; }
 | Raw `ThemeOptions` for the active theme, or a named override (used by the SVG-export theme picker). Unlike `theme` (a built, non-serializable MUI theme), this is the plain options object every view's SVG export threads into each display's `renderSvg`, which rebuilds the theme via `createJBrowseTheme` outside React context.

The `default` entry is spliced with the config `theme` slot, because the preset is only half of what that entry means — the picker calls it "Default (from config)" and `resolvePalette` merges the two for every other consumer. Returning the bare preset made `view.exportSvg()` silently drop a host's configured palette: a config setting `primary.main` drew `#123456` on screen and exported the stock `#0D233F`, with the export dialog reporting the theme it had not used. Every other named theme is a fixed preset that ignores config, which is the distinction this ternary keeps. | [ThemeManagerSessionMixin](../thememanagersessionmixin#method-getactivethemeoptions) | | **getTrackById**
(id: string) => (ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>) | undefined
 | Config for one trackId — a track, assembly sequence, or connection track — or undefined. Per-id reactive: every display resolves its config through this (via TrackConfigurationReference) and subscribes only to its own id, so one track's settings edit doesn't re-render the others. | [TracksManagerSessionMixin](../tracksmanagersessionmixin#method-gettrackbyid) | | **getTracksById**
() => Record<string, ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<…>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>>
 | Every track config the session can resolve, keyed by trackId. Prefer the per-id reactive `getTrackById(id)`: reading this whole map subscribes the caller to *every* track, so an edit to any one of them wakes it — the reason internal display config resolution moved off it. Kept for plugins that look up ids in a non-reactive context. | [TracksManagerSessionMixin](../tracksmanagersessionmixin#method-gettracksbyid) | | **getPreferenceDefault**
(key: string) => unknown | the admin/embedder `configuration.preferences` value for a key, ignoring any runtime override — i.e. what a reset falls back to. Exposed rather than inlined because "differs from the default" is a question the Preferences reset diff asks about settings this map doesn't hold (see `defaultUseWorkspaces`). | [BaseSessionModel](../basesessionmodel#method-getpreferencedefault) | | **getPreference**
(key: string) => unknown | resolved value of a user preference: a runtime override if the user set one, otherwise the admin/embedder `configuration.preferences` default. The override map is empty unless the product loads it (web/desktop). | [BaseSessionModel](../basesessionmodel#method-getpreference) | | **getDisplayTypeDefault**
(displayType: string, slot: string) => unknown | resolved value of a per-display-type slot default the user promoted (see `setDisplayTypeDefault`); undefined when nothing was promoted. | [BaseSessionModel](../basesessionmodel#method-getdisplaytypedefault) | | **getDisplayTypeDefaults**
() => { displayType: string; slot: string; value: unknown; }[] | every per-display-type default the user has promoted, as `{ displayType, slot, value }` — the inventory the Preferences dialog lists and clears one at a time (`setDisplayTypeDefault(…, undefined)`).

Here rather than filtered out of `getPreferenceChanges` by the dialog, because the composite-key layout is this file's: a consumer that recognized these rows by matching the path head is exactly the coupling `DISPLAY_TYPE_DEFAULTS_PATH_HEAD` stopped being exported over, where a rename on one side alone silently no-ops the other. | [BaseSessionModel](../basesessionmodel#method-getdisplaytypedefaults) | | **getPreferenceChanges**
() => TrackConfigChange[] | every runtime preference-override that currently differs from its config/admin default, as `{ path, from, to }` rows — the exact set `clearPreferenceOverrides` reverts. Backs the confirmation diff shown before "Reset to defaults" (mirrors the per-track changes dialog). A scalar pref (animationMode, scrollZoom) whose override equals the default is omitted (reverting it is a no-op); each promoted per-display-type default is always a difference from the un-promoted state, so `from` reads "(default)". | [BaseSessionModel](../basesessionmodel#method-getpreferencechanges) | | **findAssemblyConf**
(name: unknown) => (ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>) | undefined
 | The assembly config already carrying `name`, from any of the three arrays the assemblyManager draws on, or undefined.

One namespace, because `name` is the assembly config's MST identifier: a second config carrying a name one of the others already has doesn't fail at the add, it makes every `assembly.configuration` safeReference in the manager ambiguous, and MST then throws on every read of one — inside the manager's own autorun and inside `assemblyNameMap`, which takes the session down. So each add path checks all three, not just the array it pushes to. | [AssembliesMixin](../assembliesmixin#method-findassemblyconf) | | **menus**
() => Menu[] | | [AppSessionMixin](../appsessionmixin#method-menus) | | **getTrackActions**
(trackConfig: ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>, view?: TrackActionView | undefined) => MenuItem[]
 | raw track actions (Settings, Copy, Delete, Index) without submenu wrapper | [DesktopSessionTrackMenuMixin](../desktopsessiontrackmenumixin#method-gettrackactions) | | **getTrackListMenuItems**
(config: ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>, view?: TrackActionView | undefined) => MenuItem[]
 | flattened menu items for use in hierarchical track selector | [TrackMenuItemsSessionMixin](../trackmenuitemssessionmixin#method-gettracklistmenuitems) | | **getTrackActionMenuItems**
({…}: { config: ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>; view?: TrackActionView | undefined; }) => MenuItem[]
 | track menu with About + "Track actions" submenu for the in-view label | [TrackMenuItemsSessionMixin](../trackmenuitemssessionmixin#method-gettrackactionmenuitems) | | **hasPanel**
(panelId: string) => boolean | | [WorkspaceLayoutMixin](../workspacelayoutmixin#method-haspanel) | | **findTab**
(tabId: string) => TabHome | undefined | | [WorkspaceLayoutMixin](../workspacelayoutmixin#method-findtab) | | **tabContainingView**
(viewId: string) => TabHome | undefined | | [WorkspaceLayoutMixin](../workspacelayoutmixin#method-tabcontainingview) | | **panelContainingView**
(viewId: string) => PanelNode | undefined | | [WorkspaceLayoutMixin](../workspacelayoutmixin#method-panelcontainingview) | | **viewIdsForTab**
(tabId: string, order: string[]) => string[] | The views a tab renders: its members, in `session.views` order. | [WorkspaceLayoutMixin](../workspacelayoutmixin#method-viewidsfortab) | | **activeTabOf**
(panelId: string) => TabNode | undefined | The tab a panel is showing, or its first. | [WorkspaceLayoutMixin](../workspacelayoutmixin#method-activetabof) | ## Actions | Member | Description | Defined by | | --- | --- | --- | | **dereferenceTrack**
(trackId: string, referring: ReferringNode[]) => void | Remove `trackId` from every view referring to it and close any config editor widget open on it. Runs immediately: the walk that produced `referring` has finished, so mutating those views here is safe. | [ReferenceManagementSessionMixin](../referencemanagementsessionmixin#action-dereferencetrack) | | **makeConnection**
(configuration: ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>, initialSnapshot?: object) => any
 | | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-makeconnection) | | **breakConnection**
(configuration: ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<…>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<…>) => void
 | Remove a live connection instance. Tolerant of an already-dormant connection (its instance is stripped from the session on reload). Leaves persisted open-track configs alone — the connect() error path calls this and the user's already-open tracks must survive a transient failure. Full removal goes through `deleteConnection`. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-breakconnection) | | **teardownConnection**
(configuration: ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<…>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<…>) => void
 | Close every track a connection contributed — the live instance's tracks plus any persisted open-track configs (a dormant connection, never expanded this session, still renders its opened tracks from `connectionTrackConfigs`) — from all views/widgets, drop the live instance, and drop the persisted configs. The session is left as if the connection had never loaded. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-teardownconnection) | | **deleteConnection**
(configuration: ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<…>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>) => any
 | Fully remove a connection: tear down its tracks and live instance, then delete its config. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-deleteconnection) | | **addConnectionConf**
(connectionConf: AnyConfiguration) => any | Adds to the **config**, not the session: `jbrowse.connections`, which every visitor to this instance loads. jbrowse-web overrides this so a non-admin's connection lands in `sessionConnections` instead — see WebSessionConnectionsMixin, whose `addSessionConnectionConf` is what to call when you mean the session specifically rather than "wherever this user's edits go".

Applications without that override (Desktop, the embedded products) have only this one destination, and it is the right one there: their config and session are saved as a single document. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-addconnectionconf) | | **clearConnections**
() => void | | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-clearconnections) | | **captureConnectionTrack**
(trackId: string) => void | Snapshot a just-opened connection track's config into `connectionTrackConfigs` so it survives session reload. No-op if the track isn't connection-provided or is already captured (edits go through `updateConnectionTrackConfig`). | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-captureconnectiontrack) | | **updateConnectionTrackConfig**
(trackConf: Record<string, unknown> & { trackId: string; }) => void
 | Persist an edit to an opened connection track. The full config is stored (not a delta): the connection's fetched "base" isn't present at load, so only a complete config resolves synchronously. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-updateconnectiontrackconfig) | | **setConnectionTrackConfig**
(trackId: string, connectionId: string, config: Record<string, unknown>) => void
 | Upsert one opened connection track's persisted config. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-setconnectiontrackconfig) | | **pruneConnectionTrackConfig**
(trackId: string) => void | Drop a connection track's persisted config once no open view still references it, so the session doesn't accumulate closed tracks. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-pruneconnectiontrackconfig) | | **hydrateConnection**
(connectionId: string) => void | Lazily establish a single connection by id if it isn't already live — used when its category is expanded in the track selector. Fetches silently (no view launch / success snackbar); already-open tracks keep rendering from `connectionTrackConfigs` meanwhile. Idempotent. | [ConnectionManagementSessionMixin](../connectionmanagementsessionmixin#action-hydrateconnection) | | **setThemeName**
(name: string) => void | | [ThemeManagerSessionMixin](../thememanagersessionmixin#action-setthemename) | | **setThemeMode**
(mode: "dark" | "light") => void | Point the session at light or dark, for a host that follows its own dark-mode state rather than offering JBrowse's theme menu. Satisfies `ThemeModeSession`, so `useSessionPalette` works against an app session and an embedded one alike.

Expressed as a write to the config `theme` slot plus a return to the `default` theme, not as `setThemeName('darkStock')`. Only the `default` theme merges `configTheme.palette` (see `resolvePalette`), so selecting a stock theme would discard whatever the host passed as `configuration.theme` — their brand `primary`, say — the first time their toggle fired. Merging at both levels for the same reason: `theme` is a frozen slot, and `mode` and `primary` are siblings under `palette`.

One write, not two: `themeOptions` is derived from the same slot and is what ships to the RPC worker, so the labels baked into a rendered image follow the mode along with what React draws. | [ThemeManagerSessionMixin](../thememanagersessionmixin#action-setthememode) | | **addSessionTrackConf**
(trackConf: AnyConfiguration) => any | Add a track config to *this session*.

This mixin's session has no separate session-track store, so the destination is the jbrowse config — which in the products that compose it (desktop) is the single user's own file rather than something a server hands other visitors, so the two scopes are the same place. Defined here anyway so that every session has it: a feature standing a track up on the user's behalf can then call one action everywhere instead of asking which mixin it landed on. `SessionTracksManagerSessionMixin` overrides it with the real session-scoped store. | [TracksManagerSessionMixin](../tracksmanagersessionmixin#action-addsessiontrackconf) | | **publishTrackConf**
(trackConf: AnyConfiguration) => any | Add a track config wherever *this user's* catalog edits belong — the "Add track" workflows, where an admin adding a track means to add it for the whole site. `SessionTracksManagerSessionMixin` overrides it to send a non-admin's to the session instead; here there is only the one destination.

Anything that is not an Add-track workflow wants `addSessionTrackConf`: a track a feature stands up on the user's behalf — a search result, a computed consensus, a reconstruction's labels — is not a catalog entry, and publishing one writes it into the config.json every visitor is served, once per click. | [TracksManagerSessionMixin](../tracksmanagersessionmixin#action-publishtrackconf) | | **addTrackConf**
(trackConf: AnyConfiguration) => any | Deprecated alias of `addSessionTrackConf`. Call that, or `publishTrackConf`, which say which destination they mean. | [TracksManagerSessionMixin](../tracksmanagersessionmixin#action-addtrackconf) | | **updateTrackConfiguration**
(trackConf: { [key: string]: unknown; trackId: string; }) => void
 | Persist edited track config back to the in-memory jbrowse config. The session-tracks mixin overrides this so a non-admin's edits become a shareable session-track override instead. | [TracksManagerSessionMixin](../tracksmanagersessionmixin#action-updatetrackconfiguration) | | **deleteTrackConf**
(trackConf: ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<…>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>) => any
 | | [TracksManagerSessionMixin](../tracksmanagersessionmixin#action-deletetrackconf) | | **setSelection**
(thing: unknown) => void | set the global selection, i.e. the globally-selected object. can be a feature, a view, just about anything

A feature is unwrapped on the way in, so app state never holds a jexlFeatureProxy. `isFeature` accepts a proxy, but on one `id` is a data field rather than the method the Feature type promises — every consumer doing `isFeature(selection) ? selection.id() : …` would throw. | [BaseSessionModel](../basesessionmodel#action-setselection) | | **clearSelection**
() => void | clears the global selection | [BaseSessionModel](../basesessionmodel#action-clearselection) | | **setHovered**
(thing: unknown) => void | | [BaseSessionModel](../basesessionmodel#action-sethovered) | | **setHighlightsVisible**
(arg: boolean) => void | toggle all region highlight bands across every view | [BaseSessionModel](../basesessionmodel#action-sethighlightsvisible) | | **revealHighlights**
() => void | turn highlight bands back on, so a newly made highlight or bookmark is never silently swallowed by an earlier "highlights off" | [BaseSessionModel](../basesessionmodel#action-revealhighlights) | | **setPreferenceOverride**
(key: string, value: unknown) => void | set a runtime user-preference override (see `getPreference`). Mutates volatile state; products persist these to localStorage. An `undefined` value deletes the key (rather than leaving a phantom entry that `getPreference` reads as absent) so the store never holds dead keys. | [BaseSessionModel](../basesessionmodel#action-setpreferenceoverride) | | **clearPreferenceOverrides**
() => void | clear every runtime preference override at once — scrollZoom, animationMode, and every promoted per-display-type default (see `setDisplayTypeDefault`) — so each falls back to its config/admin default. Backs the Preferences dialog "Reset to defaults" button. | [BaseSessionModel](../basesessionmodel#action-clearpreferenceoverrides) | | **clearPreferenceOverride**
(key: string) => void | clear a single runtime preference override (see `getPreference`) so it falls back to its config/admin default. Backs the per-entry reset in the Preferences dialog "Reset to defaults" confirmation. | [BaseSessionModel](../basesessionmodel#action-clearpreferenceoverride) | | **resetPreferenceChange**
(path: string[]) => void | revert one row emitted by `getPreferenceChanges`, addressed by its display `path`. Backs the per-entry reset in the Preferences dialog's "Reset to defaults" confirmation.

Lives here rather than in that dialog because this model owns both path shapes it has to undo: a promoted per-display-type default, whose row path is a readable label over a flat composite storage key, and every other override, whose path *is* its key. The dialog used to re-derive the first case from an exported path-head constant. | [BaseSessionModel](../basesessionmodel#action-resetpreferencechange) | | **setScrollZoom**
(flag: boolean) => void | set the global scroll-to-zoom preference (see the `scrollZoom` getter) | [BaseSessionModel](../basesessionmodel#action-setscrollzoom) | | **setDisplayTypeDefault**
(displayType: string, slot: string, value: unknown) => void | promote (or, with `value` undefined, clear) a per-display-type slot default. Just a preference override under one flat composite key (see `displayTypeDefaultKey`), so it persists and independently tracks like any other pref, and clearing deletes only that key. | [BaseSessionModel](../basesessionmodel#action-setdisplaytypedefault) | | **setName**
(str: string) => void | | [BaseSessionModel](../basesessionmodel#action-setname) | | **setFocusedViewId**
(viewId: string | undefined) => void | `undefined` is "no view is focused", which the property has always been able to hold (`types.maybe`) and this had no way to spell. Nothing cleared it on teardown as a result: a view that was focused when it left the session left its id behind, and since every consumer compares `focusedViewId === view.id`, the id matched nothing, the focus ring vanished with nothing to say why, and the dead id persisted into a saved or shared session. `takeOut` clears it now. | [BaseSessionModel](../basesessionmodel#action-setfocusedviewid) | | **removeActiveDialog**
() => void | | [BaseSessionModel](../basesessionmodel#action-removeactivedialog) | | **queueDialog**
(doneCallback: DoneCallback) => void | | [BaseSessionModel](../basesessionmodel#action-queuedialog) | | **notify**
(message: string, level?: NotificationLevel | undefined, action?: SnackAction | SnackAction[] | undefined) => void
 | | [SnackbarModel](../snackbarmodel#action-notify) | | **notifyError**
(errorMessage: string, error?: unknown, extra?: unknown, action?: SnackAction | undefined) => void
 | | [SnackbarModel](../snackbarmodel#action-notifyerror) | | **setErrorDialog**
(state: ErrorDialogState | undefined) => void | | [SnackbarModel](../snackbarmodel#action-seterrordialog) | | **pushSnackbarMessage**
(message: string, level?: NotificationLevel | undefined, actions?: SnackAction[] | undefined) => void
 | | [SnackbarModel](../snackbarmodel#action-pushsnackbarmessage) | | **popSnackbarMessage**
() => SnackbarMessage | undefined | | [SnackbarModel](../snackbarmodel#action-popsnackbarmessage) | | **removeSnackbarMessage**
(message: string) => void | | [SnackbarModel](../snackbarmodel#action-removesnackbarmessage) | | **addSessionAssembly**
(conf: AnyConfiguration) => ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>
 | | [AssembliesMixin](../assembliesmixin#action-addsessionassembly) | | **addAssembly**
(conf: AnyConfiguration) => void | | [AssembliesMixin](../assembliesmixin#action-addassembly) | | **removeAssembly**
(name: string) => void | | [AssembliesMixin](../assembliesmixin#action-removeassembly) | | **removeSessionAssembly**
(assemblyName: string) => void | | [AssembliesMixin](../assembliesmixin#action-removesessionassembly) | | **addTemporaryAssembly**
(conf: AnyConfiguration) => ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>
 | used for read vs ref type assemblies. | [AssembliesMixin](../assembliesmixin#action-addtemporaryassembly) | | **removeTemporaryAssembly**
(name: string) => void | | [AssembliesMixin](../assembliesmixin#action-removetemporaryassembly) | | **renameCurrentSession**
(sessionName: string) => void | | [AppSessionMixin](../appsessionmixin#action-renamecurrentsession) | | **setActivePanelId**
(panelId: string | undefined) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-setactivepanelid) | | **toggleMaximizedPanel**
(panelId: string) => void | Show one cell at the size of the workspace, or go back.

A toggle rather than a pair, because the gesture is a toggle: the strip's double-click and the cell menu's one item both mean "this cell, or not any more". Maximizing a DIFFERENT cell while one is already maximized moves the mode rather than restoring, which is what the menu item on another cell's strip is asking for.

Mounts no views that were not mounted — it is the same cell showing the same tab — and unmounts every other cell's, so the WebGL2 context ceiling (`agent-docs/reference/GPU_CONTEXT_BUDGET.md`) can only go down. That is the reason it is this and not a `display: none` over a still-mounted workspace. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-togglemaximizedpanel) | | **restorePanels**
() => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-restorepanels) | | **setActiveTab**
(panelId: string, tabId: string) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-setactivetab) | | **renameTab**
(tabId: string, title: string | undefined) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-renametab) | | **splitPanel**
(panelId: string, direction: "column" | "row", before?: any) => PanelNode | undefined
 | Split a grid cell; the new cell gets one empty tab. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-splitpanel) | | **closePanel**
(panelId: string) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-closepanel) | | **addTab**
(panelId: string, viewIds?: string[]) => TabNode | undefined | "New empty tab": a tab in an existing cell, showing the launcher. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-addtab) | | **closeTab**
(tabId: string) => void | Close a tab, and the cell with it if that was its last.

A cell whose tabs are all gone is the state `pruneEmptyPanel` was written for — "dragging the last tab out of a split and leaving a blank half is the one place an empty panel is clearly not what was meant" — and closing that tab arrives at the identical half by a different gesture. It rendered nothing at all, not even the launcher an empty TAB shows, so the only way back out of it was the `+`.

`pruneEmptyPanel` carries both guards already: a cell with tabs left stays, and the last cell in the workspace stays whatever happens to it, since there is nowhere for the tree to collapse to. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-closetab) | | **addViewToTab**
(tabId: string, viewId: string) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-addviewtotab) | | **dropTabInPanel**
(tabId: string, targetPanelId: string, index?: number | undefined) => void
 | Drop a dragged tab into an existing panel, as a tab.

One action, so the tree never exists in a state where the tab is in both panels or neither. The imperative bridge needed an explicit `runInAction` around the unassign+reassign pair for exactly this, and a comment explaining that without it the reconcile autorun would observe the gap and re-home the view. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-droptabinpanel) | | **dropTabInNewSplit**
(tabId: string, targetPanelId: string, direction: "column" | "row", before: boolean) => string | undefined
 | Drop a dragged tab on a panel edge: split, and land in the new half. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-droptabinnewsplit) | | **setSizes**
(branchId: string, sizes: number[]) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-setsizes) | | **applyLayoutSpec**
(spec: LayoutSpecNode) => string[] | Arrange the workspace as a spec states.

There is no `init` property and no standing request: the spec is converted and *becomes* the layout, here and now. `init` existed only because dockview had to be told, could not be told before it mounted, and had to be told again afterwards — three problems that all came from the layout living somewhere this action could not reach. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-applylayoutspec) | | **moveViewToNewTab**
(viewId: string, allViewIds: string[]) => string | undefined | ViewMenu's "move to new tab": the view leaves its tab for a new one.

`allViewIds` is EVERY view in the session, and is required for that reason — homing drops any view the list does not name, so the `[viewId]` default this used to carry unhomed all the others. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-moveviewtonewtab) | | **moveViewToSplitRight**
(viewId: string, allViewIds: string[]) => string | undefined | ViewMenu's "move to split view": the view leaves for a new cell. `allViewIds` is every view in the session — see `moveViewToNewTab`. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-moveviewtosplitright) | | **homeUnassignedViews**
(viewIds: string[]) => void | | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-homeunassignedviews) | | **setPendingMove**
(move: PendingMove | undefined, allViewIds?: string[] | undefined) => void
 | Move one view relative to the others. PUBLIC API: an external plugin calls this behind a `'setPendingMove' in session` guard (jbrowse-plugin-protein3d, putting a protein view beside its genome view). It survived the last storage change by being kept as sugar, and it survives this one the same way — a capability-detecting caller cannot tell you it lost a capability.

**`allViewIds` is therefore OPTIONAL, and has to stay that way.** The plugin passes the move alone, because that was the whole signature when its call site was written; requiring the second argument threw `undefined.filter` out of a launch the plugin does not wrap, and the figure was again the only thing that noticed. Keeping the NAME is half of not breaking a runtime lookup — the call has to keep working as it is spelled. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-setpendingmove) | | **tileViews**
(mode: TileMode, allViewIds: string[]) => void | The whole-workspace re-arrange: every view one cell, in one of four shapes. Restored from the dockview header's four "Global:" commands, which went with that component and were not reimplemented.

`allViewIds` is passed in rather than read off the session for the same reason `moveViewToNewTab` takes it: this mixin owns the tree and has no view list of its own. Passing `session.views` order means the arrangement it states is already the order views render in, so unlike a session spec's layout there is nothing for `orderViews` to apply. | [WorkspaceLayoutMixin](../workspacelayoutmixin#action-tileviews) | | **moveViewDown**
(id: string, scopeIds?: string[] | undefined) => void | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-moveviewdown) | | **moveViewUp**
(id: string, scopeIds?: string[] | undefined) => void | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-moveviewup) | | **moveViewToTop**
(id: string, scopeIds?: string[] | undefined) => void | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-moveviewtotop) | | **moveViewToBottom**
(id: string, scopeIds?: string[] | undefined) => void | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-moveviewtobottom) | | **orderViews**
(ids: string[]) => void | Put the named views into the given relative order, leaving views not named in their own slots.

`session.views` is the one ordering, so this is how a channel that states an order in some other vocabulary gets it applied: a session spec's `layout` names views per panel, top to bottom, and that used to be honoured by the panel assignment array's order. Now the assignment carries membership only, so the layout says it here instead, once. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-orderviews) | | **addView**
(typeName: string, initialState?: any) => any | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-addview) | | **replaceView**
(view: IBaseViewModel, typeName: string, initialState?: any) => any
 | swap `view` for a new view of `typeName`, in the slot it occupied.

The launchers that build a view of a DIFFERENT type out of one you are already looking at — launch synteny view, read-vs-ref, split view — otherwise append, leaving the source view above the thing it produced and a stack of two views showing the same locus. This is the "replace" half of that offer, and a slot swap rather than remove-then-add so the new view lands where the reader was looking instead of at the bottom of the session.

A launcher whose result is the SAME type as its source does not come here and should not: collapse introns offers "Replace current view" by navigating the view it was invoked on, which keeps the view's identity and so lets its snackbar offer an Undo. Swapping in a new node would leave nothing to undo onto.

The slot is `session.views`, which is the order views render in under both layout modes (a tab's `viewIds` says which tab a view is in, not where in it), so the swap lands in place either way.

WHICH panel is a separate question and this does not answer it: the new view arrives in no tab, and `homeUnassignedViews` puts it in the active panel — the same panel only when the replaced view was in the active one. In practice it is, since clicking into a view activates its panel, and the launch that offers a replace is a click on that view's own menu. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-replaceview) | | **removeView**
(view: IBaseViewModel) => void | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-removeview) | | **takeOutViewsMissingFrom**
(snapshot: unknown) => void | Take out every view the given session snapshot will not keep, before a whole-tree `applySnapshot` destroys it where it stands.

Undo and redo are `applySnapshot` on the session (`core/util/TimeTraveller`, which calls this), and every view carries an `ElementId` — so MST reconciles by identifier and destroys what the target lacks, inside the action, with the components still mounted. Measured on a redo across a closed view, with the restored view repainted first: 4 liveliness reads of its display before this, 0 after.

A view that is present but has changed `type` is destroyed by that same reconciliation (`areSame` runs the type's `is()` before its id check), so identity here is the pair, not the id.

**Views, and deliberately not what is under them.** A track or a display the snapshot drops is still destroyed in place, and that is not this door being worse than the others: `hideTrackGeneric` is a plain `tracks.remove` and measures louder (5 reads to undo's 4). Detaching one would be worse than the destroy it replaced — a detached display is a LIVE root, and `getContainingView` walks parents and throws when the walk finds no view, where a dead node only warns. At or above the view is the only place that walk still lands, which is why ADR-069's rule stops there. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-takeoutviewsmissingfrom) | | **setStickyViewHeaders**
(sticky: boolean) => void | | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-setstickyviewheaders) | | **setUseWorkspaces**
(useWorkspaces: boolean) => void | set the workspaces layout for this session only, leaving the user's personal default untouched. For session-scoped intent — a spec carrying a `layout`, or an ad-hoc "move view to a tab/split" — where rewriting the visitor's global preference would be a surprise. The user-facing default toggle is `setUseWorkspacesPreference`. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-setuseworkspaces) | | **setUseWorkspacesPreference**
(useWorkspaces: boolean) => void | the user-facing workspaces toggle: applies to this session and becomes their default for sessions that don't specify one. Persisted only here, on an explicit toggle — an autorun mirroring the resolved value would bake the admin default into every visitor's localStorage on first load, so a later admin change could never reach them. | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-setuseworkspacespreference) | | **resetUseWorkspaces**
() => void | drop both this session's explicit value and the user's override so workspaces falls back to the admin default | [MultipleViewsSessionMixin](../multipleviewssessionmixin#action-resetuseworkspaces) | | **setDrawerPosition**
(arg: string) => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-setdrawerposition) | | **updateDrawerWidth**
(drawerWidth: number) => number | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-updatedrawerwidth) | | **resizeDrawer**
(distance: number) => number | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-resizedrawer) | | **addWidget**
(typeName: string, id: string, initialState?: any, conf?: unknown) => any
 | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-addwidget) | | **showWidget**
(widget: any) => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-showwidget) | | **hideWidget**
(widget: any) => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-hidewidget) | | **minimizeWidgetDrawer**
() => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-minimizewidgetdrawer) | | **showWidgetDrawer**
() => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-showwidgetdrawer) | | **popoutWidget**
() => void | show the visible widget in a modal dialog, freeing the drawer column | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-popoutwidget) | | **returnWidgetToDrawer**
() => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-returnwidgettodrawer) | | **hideAllWidgets**
() => void | | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-hideallwidgets) | | **editConfiguration**
(configuration: (ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>) | { ...; }, opts?: { ...; } | undefined) => void
 | opens a configuration editor to configure the given thing, and sets the current task to be configuring it | [DrawerWidgetSessionMixin](../drawerwidgetsessionmixin#action-editconfiguration) |