@jbrowse/core 3.7.0 → 4.0.1

package/esm/configuration/configurationSchema.d.ts

@@ -0,0 +1,37 @@
+import type { ConfigSlotDefinition } from './configurationSlot.ts';
+import type { AnyConfigurationSchemaType } from './types.ts';
+import type { IAnyType } from '@jbrowse/mobx-state-tree';
+export type { AnyConfigurationModel, AnyConfigurationSchemaType, AnyConfigurationSlot, AnyConfigurationSlotType, } from './types.ts';
+export interface ConfigurationSchemaDefinition {
+    [n: string]: ConfigSlotDefinition | ConfigurationSchemaDefinition | string | number | IAnyType;
+}
+export interface ConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfigurationSchemaType | undefined, EXPLICIT_IDENTIFIER extends string | undefined> {
+    explicitlyTyped?: boolean;
+    explicitIdentifier?: EXPLICIT_IDENTIFIER;
+    implicitIdentifier?: string | boolean;
+    baseConfiguration?: BASE_SCHEMA;
+    actions?: (self: unknown) => any;
+    views?: (self: unknown) => any;
+    extend?: (self: unknown) => any;
+    preProcessSnapshot?: (snapshot: Record<string, unknown>) => Record<string, unknown>;
+}
+declare function makeConfigurationSchemaModel<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions<any, any>>(modelName: string, schemaDefinition: DEFINITION, options: OPTIONS): import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<Record<string, any>, {
+    setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+        [x: string]: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+            [x: string]: any;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & any & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
+export interface ConfigurationSchemaType<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions<any, any>> extends ReturnType<typeof makeConfigurationSchemaModel<DEFINITION, OPTIONS>> {
+    isJBrowseConfigurationSchema: boolean;
+    jbrowseSchemaDefinition: DEFINITION;
+    jbrowseSchemaOptions: OPTIONS;
+    type: string;
+    [key: string]: unknown;
+}
+export declare function ConfigurationSchema<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER>, BASE_SCHEMA extends AnyConfigurationSchemaType | undefined = undefined, EXPLICIT_IDENTIFIER extends string | undefined = undefined>(modelName: string, inputSchemaDefinition: DEFINITION, inputOptions?: ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER>): ConfigurationSchemaType<DEFINITION, OPTIONS>;
+export declare function TrackConfigurationReference(schemaType: IAnyType): import("@jbrowse/mobx-state-tree").ISnapshotProcessor<import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>, import("@jbrowse/mobx-state-tree")._NotCustomized, any>;
+export declare function DisplayConfigurationReference(schemaType: IAnyType): import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>;
+export declare function ConfigurationReference<SCHEMATYPE extends AnyConfigurationSchemaType>(schemaType: SCHEMATYPE): SCHEMATYPE;

package/esm/configuration/configurationSchema.js

@@ -0,0 +1,230 @@
+import { getEnv, getRoot, getSnapshot, isLateType, isStateTreeNode, isType, resolveIdentifier, types, } from '@jbrowse/mobx-state-tree';
+import ConfigSlot from "./configurationSlot.js";
+import { isConfigurationSchemaType } from "./util.js";
+import { getContainingTrack, getSession } from "../util/index.js";
+import { ElementId } from "../util/types/mst.js";
+function isEmptyObject(thing) {
+    return (typeof thing === 'object' &&
+        !Array.isArray(thing) &&
+        thing !== null &&
+        Object.keys(thing).length === 0);
+}
+function isEmptyArray(thing) {
+    return Array.isArray(thing) && thing.length === 0;
+}
+function preprocessConfigurationSchemaArguments(modelName, inputSchemaDefinition, inputOptions = {}) {
+    if (typeof modelName !== 'string') {
+        throw new Error('first arg must be string name of the model that this config schema goes with');
+    }
+    let schemaDefinition = inputSchemaDefinition;
+    let options = inputOptions;
+    if (inputOptions.baseConfiguration?.jbrowseSchemaDefinition) {
+        schemaDefinition = {
+            ...inputOptions.baseConfiguration.jbrowseSchemaDefinition,
+            ...schemaDefinition,
+        };
+        options = {
+            ...inputOptions.baseConfiguration.jbrowseSchemaOptions,
+            ...inputOptions,
+            baseConfiguration: undefined,
+        };
+    }
+    return { schemaDefinition, options };
+}
+function makeConfigurationSchemaModel(modelName, schemaDefinition, options) {
+    const modelDefinition = {};
+    let identifier;
+    if (options.explicitlyTyped) {
+        modelDefinition.type = types.optional(types.literal(modelName), modelName);
+    }
+    if (options.explicitIdentifier && options.implicitIdentifier) {
+        throw new Error(`Cannot have both explicit and implicit identifiers in ${modelName}`);
+    }
+    if (options.explicitIdentifier) {
+        if (typeof options.explicitIdentifier === 'string') {
+            modelDefinition[options.explicitIdentifier] = types.identifier;
+            identifier = options.explicitIdentifier;
+        }
+        else {
+            modelDefinition.id = types.identifier;
+            identifier = 'id';
+        }
+    }
+    else if (options.implicitIdentifier) {
+        if (typeof options.implicitIdentifier === 'string') {
+            modelDefinition[options.implicitIdentifier] = ElementId;
+            identifier = options.implicitIdentifier;
+        }
+        else {
+            modelDefinition.id = ElementId;
+            identifier = 'id';
+        }
+    }
+    const volatileConstants = {
+        isJBrowseConfigurationSchema: true,
+        jbrowseSchema: {
+            modelName,
+            definition: schemaDefinition,
+            options,
+        },
+    };
+    for (const [slotName, slotDefinition] of Object.entries(schemaDefinition)) {
+        if ((isType(slotDefinition) && isLateType(slotDefinition)) ||
+            isConfigurationSchemaType(slotDefinition)) {
+            modelDefinition[slotName] = slotDefinition;
+        }
+        else if (typeof slotDefinition === 'string' ||
+            typeof slotDefinition === 'number') {
+            volatileConstants[slotName] = slotDefinition;
+        }
+        else if (typeof slotDefinition === 'object') {
+            if (!slotDefinition.type) {
+                throw new Error(`no type set for config slot ${modelName}.${slotName}`);
+            }
+            try {
+                modelDefinition[slotName] = ConfigSlot(slotName, slotDefinition);
+            }
+            catch (e) {
+                throw new Error(`invalid config slot definition for ${modelName}.${slotName}: ${e}`);
+            }
+        }
+        else {
+            throw new Error(`invalid configuration schema definition, "${slotName}" must be either a valid configuration slot definition, a constant, or a nested configuration schema`);
+        }
+    }
+    let completeModel = types
+        .model(`${modelName}ConfigurationSchema`, modelDefinition)
+        .actions(self => ({
+        setSubschema(slotName, data) {
+            if (!isConfigurationSchemaType(modelDefinition[slotName])) {
+                throw new Error(`${slotName} is not a subschema, cannot replace`);
+            }
+            const newSchema = isStateTreeNode(data)
+                ? data
+                : modelDefinition[slotName].create(data);
+            self[slotName] = newSchema;
+            return newSchema;
+        },
+    }));
+    if (Object.keys(volatileConstants).length) {
+        completeModel = completeModel.volatile(() => volatileConstants);
+    }
+    if (options.actions) {
+        completeModel = completeModel.actions(options.actions);
+    }
+    if (options.views) {
+        completeModel = completeModel.views(options.views);
+    }
+    if (options.extend) {
+        completeModel = completeModel.extend(options.extend);
+    }
+    const identifierDefault = identifier ? { [identifier]: 'placeholderId' } : {};
+    const modelDefault = options.explicitlyTyped
+        ? { type: modelName, ...identifierDefault }
+        : identifierDefault;
+    const defaultSnap = getSnapshot(completeModel.create(modelDefault));
+    completeModel = completeModel.postProcessSnapshot(snap => {
+        const newSnap = {};
+        let matchesDefault = true;
+        for (const [key, value] of Object.entries(snap)) {
+            if (matchesDefault) {
+                if (typeof defaultSnap[key] === 'object' && typeof value === 'object') {
+                    if (JSON.stringify(defaultSnap[key]) !== JSON.stringify(value)) {
+                        matchesDefault = false;
+                    }
+                }
+                else if (defaultSnap[key] !== value) {
+                    matchesDefault = false;
+                }
+            }
+            if (value !== undefined &&
+                volatileConstants[key] === undefined &&
+                !isEmptyObject(value) &&
+                !isEmptyArray(value)) {
+                newSnap[key] = value;
+            }
+        }
+        if (matchesDefault) {
+            return {};
+        }
+        return newSnap;
+    });
+    if (options.preProcessSnapshot) {
+        completeModel = completeModel.preProcessSnapshot(options.preProcessSnapshot);
+    }
+    return types.optional(completeModel, modelDefault);
+}
+export function ConfigurationSchema(modelName, inputSchemaDefinition, inputOptions) {
+    const { schemaDefinition, options } = preprocessConfigurationSchemaArguments(modelName, inputSchemaDefinition, inputOptions);
+    const schemaType = makeConfigurationSchemaModel(modelName, schemaDefinition, options);
+    schemaType.isJBrowseConfigurationSchema = true;
+    schemaType.jbrowseSchemaDefinition = schemaDefinition;
+    schemaType.jbrowseSchemaOptions = options;
+    return schemaType;
+}
+export function TrackConfigurationReference(schemaType) {
+    const trackRef = types.reference(schemaType, {
+        get(id, parent) {
+            const session = getSession(parent);
+            let ret = session.tracksById[id];
+            if (!ret) {
+                ret = resolveIdentifier(schemaType, getRoot(parent), id);
+            }
+            if (!ret) {
+                throw new Error(`Could not resolve identifier "${id}"`);
+            }
+            return isStateTreeNode(ret) ? ret : schemaType.create(ret, getEnv(parent));
+        },
+        set(value) {
+            return value.trackId;
+        },
+    });
+    return types.snapshotProcessor(types.union({
+        dispatcher: snapshot => typeof snapshot === 'string' ? trackRef : schemaType,
+    }, trackRef, schemaType), {
+        postProcessor(snapshot) {
+            if (typeof snapshot === 'object' &&
+                snapshot !== null &&
+                'trackId' in snapshot) {
+                return snapshot.trackId;
+            }
+            return snapshot;
+        },
+    });
+}
+export function DisplayConfigurationReference(schemaType) {
+    const displayRef = types.reference(schemaType, {
+        get(id, parent) {
+            const track = getContainingTrack(parent);
+            const displays = track.configuration.displays || [];
+            let ret = displays.find((d) => d.displayId === id);
+            if (!ret) {
+                const displayType = `${id}`.split('-').slice(1).join('-');
+                if (displayType) {
+                    ret = { displayId: `${id}`, type: displayType };
+                }
+            }
+            if (!ret) {
+                throw new Error(`Display configuration "${id}" not found`);
+            }
+            return isStateTreeNode(ret) ? ret : schemaType.create(ret, getEnv(parent));
+        },
+        set(value) {
+            return value.displayId;
+        },
+    });
+    return types.union({
+        dispatcher: snapshot => typeof snapshot === 'string' ? displayRef : schemaType,
+    }, displayRef, schemaType);
+}
+export function ConfigurationReference(schemaType) {
+    const name = schemaType.name;
+    if (name.includes('TrackConfigurationSchema') &&
+        !name.includes('DisplayConfigurationSchema')) {
+        return TrackConfigurationReference(schemaType);
+    }
+    if (name.includes('DisplayConfigurationSchema')) {
+        return DisplayConfigurationReference(schemaType);
+    }
+    return types.union(types.reference(schemaType), schemaType);
+}

package/esm/configuration/configurationSlot.d.ts

@@ -0,0 +1,33 @@
+import type { IAnyComplexType, IAnyModelType } from '@jbrowse/mobx-state-tree';
+export interface ConfigSlotDefinition {
+    description?: string;
+    model?: IAnyModelType | IAnyComplexType;
+    type: string;
+    defaultValue: any;
+    contextVariable?: string[];
+}
+export default function ConfigSlot(slotName: string, { description, model, type, defaultValue, contextVariable, }: ConfigSlotDefinition): import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<{
+    name: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    description: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    value: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>, [undefined]>;
+}, {
+    contextVariable: string[];
+} & {
+    readonly isCallback: boolean;
+} & {
+    readonly expr: any;
+    readonly valueJSON: any[] | Record<string, any> | string | undefined;
+} & {
+    getValue(args?: Record<string, unknown>): any;
+} & {
+    set(newVal: any): void;
+    reset(): void;
+    convertToCallback(): void;
+    convertToValue(): void;
+}, import("@jbrowse/mobx-state-tree").ModelCreationType<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<{
+    name: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    description: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    value: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>, [undefined]>;
+}>>, any>, [undefined]>;

package/esm/configuration/configurationSlot.js

@@ -0,0 +1,239 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { getEnv } from "../util/index.js";
+import { stringToJexlExpression } from "../util/jexlStrings.js";
+import { FileLocation } from "../util/types/mst.js";
+function isValidColorString(_str) {
+    return true;
+}
+const typeModels = {
+    stringArray: types.array(types.string),
+    stringArrayMap: types.map(types.array(types.string)),
+    numberMap: types.map(types.number),
+    boolean: types.boolean,
+    color: types.refinement('Color', types.string, isValidColorString),
+    integer: types.integer,
+    number: types.number,
+    string: types.string,
+    text: types.string,
+    fileLocation: FileLocation,
+    frozen: types.frozen(),
+};
+const fallbackDefaults = {
+    stringArray: [],
+    stringArrayMap: {},
+    numberMap: {},
+    boolean: true,
+    color: 'black',
+    integer: 1,
+    number: 1,
+    string: '',
+    text: '',
+    fileLocation: { uri: '/path/to/resource.txt', locationType: 'UriLocation' },
+    frozen: {},
+};
+const literalJSON = (self) => ({
+    views: {
+        get valueJSON() {
+            return self.value;
+        },
+    },
+});
+const objectJSON = (self) => ({
+    views: {
+        get valueJSON() {
+            return JSON.stringify(self.value);
+        },
+    },
+});
+const typeModelExtensions = {
+    fileLocation: objectJSON,
+    number: literalJSON,
+    integer: literalJSON,
+    boolean: literalJSON,
+    frozen: objectJSON,
+    stringArray: (self) => ({
+        views: {
+            get valueJSON() {
+                return JSON.stringify(self.value);
+            },
+        },
+        actions: {
+            add(val) {
+                self.value.push(val);
+            },
+            removeAtIndex(idx) {
+                self.value.splice(idx, 1);
+            },
+            setAtIndex(idx, val) {
+                self.value[idx] = val;
+            },
+        },
+    }),
+    stringArrayMap: (self) => ({
+        views: {
+            get valueJSON() {
+                return JSON.stringify(self.value);
+            },
+        },
+        actions: {
+            add(key, val) {
+                self.value.set(key, val);
+            },
+            remove(key) {
+                self.value.delete(key);
+            },
+            addToKey(key, val) {
+                const ar = self.value.get(key);
+                if (!ar) {
+                    throw new Error(`${key} not found`);
+                }
+                ar.push(val);
+            },
+            removeAtKeyIndex(key, idx) {
+                const ar = self.value.get(key);
+                if (!ar) {
+                    throw new Error(`${key} not found`);
+                }
+                ar.splice(idx, 1);
+            },
+            setAtKeyIndex(key, idx, val) {
+                const ar = self.value.get(key);
+                if (!ar) {
+                    throw new Error(`${key} not found`);
+                }
+                ar[idx] = val;
+            },
+        },
+    }),
+    numberMap: (self) => ({
+        views: {
+            get valueJSON() {
+                return JSON.stringify(self.value);
+            },
+        },
+        actions: {
+            add(key, val) {
+                self.value.set(key, val);
+            },
+            remove(key) {
+                self.value.delete(key);
+            },
+        },
+    }),
+};
+const JexlStringType = types.refinement('JexlString', types.string, str => str.startsWith('jexl:'));
+function json(value) {
+    return value?.toJSON ? value.toJSON() : `"${value}"`;
+}
+export default function ConfigSlot(slotName, { description = '', model, type, defaultValue, contextVariable = [], }) {
+    if (!type) {
+        throw new Error('type name required');
+    }
+    if (!model) {
+        model = typeModels[type];
+    }
+    if (!model) {
+        throw new Error(`no builtin config slot type "${type}", and no 'model' param provided`);
+    }
+    if (defaultValue === undefined) {
+        throw new Error("no 'defaultValue' provided");
+    }
+    const configSlotModelName = `${slotName.charAt(0).toUpperCase()}${slotName.slice(1)}ConfigSlot`;
+    let slot = types
+        .model(configSlotModelName, {
+        name: types.literal(slotName),
+        description: types.literal(description),
+        type: types.literal(type),
+        value: types.optional(types.union(JexlStringType, model), defaultValue),
+    })
+        .volatile(() => ({
+        contextVariable,
+    }))
+        .views(self => ({
+        get isCallback() {
+            return String(self.value).startsWith('jexl:');
+        },
+    }))
+        .views(self => ({
+        get expr() {
+            return self.isCallback
+                ? stringToJexlExpression(String(self.value), getEnv(self).pluginManager.jexl)
+                : {
+                    eval: () => self.value,
+                };
+        },
+        get valueJSON() {
+            return self.isCallback ? undefined : json(self.value);
+        },
+    }))
+        .views(self => ({
+        getValue(args = {}) {
+            const v = self.value;
+            return typeof v === 'string' && v.startsWith('jexl:')
+                ? self.expr.eval(args)
+                : v;
+        },
+    }))
+        .preProcessSnapshot(val => typeof val === 'object' && val.name === slotName
+        ? val
+        : {
+            name: slotName,
+            description,
+            type,
+            value: val,
+        })
+        .postProcessSnapshot(snap => {
+        if (typeof snap.value === 'object') {
+            return JSON.stringify(snap.value) !== JSON.stringify(defaultValue)
+                ? snap.value
+                : undefined;
+        }
+        return snap.value !== defaultValue ? snap.value : undefined;
+    })
+        .actions(self => ({
+        set(newVal) {
+            self.value = newVal;
+        },
+        reset() {
+            self.value = defaultValue;
+        },
+        convertToCallback() {
+            if (self.isCallback) {
+                return;
+            }
+            self.value = `jexl:${self.valueJSON || "''"}`;
+        },
+        convertToValue() {
+            if (!self.isCallback) {
+                return;
+            }
+            try {
+                const funcResult = self.expr.eval();
+                if (funcResult !== undefined) {
+                    self.value = funcResult;
+                    return;
+                }
+            }
+            catch (e) {
+            }
+            self.value = defaultValue;
+            if (!(type in fallbackDefaults)) {
+                throw new Error(`no fallbackDefault defined for type ${type}`);
+            }
+            self.value = fallbackDefaults[type];
+        },
+    }));
+    if (typeModelExtensions[type]) {
+        slot = slot.extend(typeModelExtensions[type]);
+    }
+    const completeModel = types.optional(slot, {
+        name: slotName,
+        type,
+        description,
+        value: defaultValue,
+    });
+    Object.defineProperty(completeModel, 'isJBrowseConfigurationSlot', {
+        value: true,
+    });
+    return completeModel;
+}

package/esm/configuration/index.d.ts

@@ -0,0 +1,3 @@
+export { ConfigurationReference, ConfigurationSchema, } from './configurationSchema.ts';
+export type { AnyConfiguration, AnyConfigurationModel, AnyConfigurationSchemaType, AnyConfigurationSlot, AnyConfigurationSlotType, } from './types.ts';
+export * from './util.ts';

package/esm/configuration/index.js

@@ -0,0 +1,2 @@
+export { ConfigurationReference, ConfigurationSchema, } from "./configurationSchema.js";
+export * from "./util.js";

package/esm/configuration/types.d.ts

@@ -0,0 +1,14 @@
+import type { ConfigurationSchemaOptions, ConfigurationSchemaType } from './configurationSchema.ts';
+import type ConfigSlot from './configurationSlot.ts';
+import type { IStateTreeNode, Instance, SnapshotOut } from '@jbrowse/mobx-state-tree';
+export type GetOptions<SCHEMA> = SCHEMA extends ConfigurationSchemaType<any, infer OPTIONS> ? OPTIONS : never;
+export type GetBase<SCHEMA> = SCHEMA extends undefined ? never : GetOptions<SCHEMA> extends ConfigurationSchemaOptions<undefined, any> ? undefined : GetOptions<SCHEMA> extends ConfigurationSchemaOptions<infer BASE extends AnyConfigurationSchemaType, any> ? BASE : never;
+export type GetExplicitIdentifier<SCHEMA> = GetOptions<SCHEMA> extends ConfigurationSchemaOptions<any, infer EXPLICIT_IDENTIFIER extends string> ? EXPLICIT_IDENTIFIER : never;
+export type ConfigurationSchemaForModel<MODEL> = MODEL extends IStateTreeNode<infer SCHEMA extends AnyConfigurationSchemaType> ? SCHEMA : never;
+export type ConfigurationSlotName<SCHEMA> = SCHEMA extends undefined ? never : SCHEMA extends ConfigurationSchemaType<infer D, any> ? (keyof D & string) | GetExplicitIdentifier<SCHEMA> | (GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSlotName<GetBase<SCHEMA>> : never) : never;
+export type AnyConfigurationSchemaType = ConfigurationSchemaType<any, any>;
+export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
+export type AnyConfigurationSlotType = ReturnType<typeof ConfigSlot>;
+export type AnyConfigurationSlot = Instance<AnyConfigurationSlotType>;
+export type AnyConfiguration = AnyConfigurationModel | SnapshotOut<AnyConfigurationModel>;
+export type ConfigurationModel<SCHEMA extends AnyConfigurationSchemaType> = Instance<SCHEMA>;

package/esm/configuration/types.js

@@ -0,0 +1 @@
+export {};

package/esm/configuration/util.d.ts

@@ -0,0 +1,10 @@
+import type { AnyConfigurationModel, AnyConfigurationSchemaType, ConfigurationSchemaForModel, ConfigurationSlotName } from './types.ts';
+export declare function readConfObject<CONFMODEL extends AnyConfigurationModel>(confObject: CONFMODEL, slotPath?: ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>> | string[], args?: Record<string, unknown>): any;
+export declare function getConf<CONFMODEL extends AnyConfigurationModel>(model: {
+    configuration: CONFMODEL;
+}, slotPath?: Parameters<typeof readConfObject<CONFMODEL>>[1], args?: Parameters<typeof readConfObject<CONFMODEL>>[2]): any;
+export declare function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType: unknown): string[];
+export declare function isBareConfigurationSchemaType(thing: unknown): thing is AnyConfigurationSchemaType;
+export declare function isConfigurationSchemaType(thing: unknown): thing is AnyConfigurationSchemaType;
+export declare function isConfigurationModel(thing: unknown): thing is AnyConfigurationModel;
+export declare function isConfigurationSlotType(thing: unknown): thing is object & Record<"isJBrowseConfigurationSlot", unknown>;