@sdeverywhere/check-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,907 @@
+declare type SourceName = string;
+declare type VarId = string;
+declare type ScenarioKey = string;
+declare type ScenarioGroupKey = string;
+declare type DatasetKey = string;
+declare type Dataset = Map<number, number>;
+declare type DatasetMap = Map<DatasetKey, Dataset>;
+
+declare type InputPosition = 'at-default' | 'at-minimum' | 'at-maximum';
+interface PositionSetting {
+    kind: 'position';
+    inputVarId: VarId;
+    position: InputPosition;
+}
+interface ValueSetting {
+    kind: 'value';
+    inputVarId: VarId;
+    value: number;
+}
+declare type InputSetting = PositionSetting | ValueSetting;
+interface SettingsScenario {
+    kind: 'settings';
+    key: ScenarioKey;
+    groupKey: ScenarioGroupKey;
+    settings: InputSetting[];
+}
+interface AllInputsScenario {
+    kind: 'all-inputs';
+    key: ScenarioKey;
+    groupKey: ScenarioGroupKey;
+    position: InputPosition;
+}
+declare type Scenario = SettingsScenario | AllInputsScenario;
+declare function positionSetting(inputVarId: VarId, position: InputPosition): InputSetting;
+declare function valueSetting(inputVarId: VarId, value: number): InputSetting;
+declare function settingsScenario(key: ScenarioKey, groupKey: ScenarioGroupKey, settings: InputSetting[]): Scenario;
+declare function inputAtPositionScenario(inputVarId: VarId, groupKey: ScenarioGroupKey, position: InputPosition): Scenario;
+declare function inputAtValueScenario(inputVarId: VarId, groupKey: ScenarioGroupKey, value: number): Scenario;
+declare function allInputsAtPositionScenario(position: InputPosition): Scenario;
+/**
+ * Return an array of scenarios that can be used to run the model
+ * with a matrix of output/input scenarios.
+ *
+ * For each output variable, run the model:
+ *   - once with all inputs at their default
+ *   - once with all inputs at their minimum
+ *   - once with all inputs at their maximum
+ *   - twice for each input
+ *       - once with single input at its minimum
+ *       - once with single input at its maximum
+ */
+declare function matrixScenarios(inputVarIds: VarId[]): Scenario[];
+
+interface DatasetsResult {
+    /**
+     * The map of datasets for the scenario.
+     */
+    datasetMap: DatasetMap;
+    /**
+     * The number of milliseconds that elapsed when running the model, or undefined if the model
+     * wasn't run for this scenario.
+     */
+    modelRunTime?: number;
+}
+interface DataSource {
+    /** Return the datasets that result from running the given scenario. */
+    getDatasetsForScenario(scenario: Scenario, datasetKeys: DatasetKey[]): Promise<DatasetsResult>;
+}
+
+/**
+ * Holds information about an item related to a variable used in the model.
+ * For example, this can be used to attach information about a graph that
+ * an output variable is used in, or a slider that controls an input variable.
+ */
+interface RelatedItem {
+    id: string;
+    locationPath: string[];
+}
+/**
+ * Holds information about an input variable used in the model.
+ */
+interface InputVar {
+    varId: VarId;
+    varName: string;
+    defaultValue: number;
+    minValue: number;
+    maxValue: number;
+    relatedItem?: RelatedItem;
+}
+/**
+ * Holds information about an output variable used in the model.
+ */
+interface OutputVar {
+    sourceName?: SourceName;
+    varId: VarId;
+    varName: string;
+    relatedItems?: RelatedItem[];
+}
+/**
+ * Holds information about a subscript used in the model.
+ */
+interface Subscript {
+    /** The subscript identifier, as used in SDE. */
+    id: string;
+    /** The subscript name, as used in Vensim. */
+    name: string;
+}
+/**
+ * Holds information about a dimension (subscript family) used in the model.
+ */
+interface Dimension {
+    /** The dimension identifier, as used in SDE. */
+    id: string;
+    /** The dimension name, as used in Vensim. */
+    name: string;
+    /** The set of subscripts in this dimension. */
+    subscripts: Subscript[];
+}
+/**
+ * Holds information about a variable used in the model implementation.
+ */
+interface ImplVar {
+    /** The variable identifier, as used in SDE. */
+    varId: VarId;
+    /** The variable name, as used in Vensim. */
+    varName: string;
+    /** The variable index, used by SDE to reference the value in the generated model. */
+    varIndex: number;
+    /** The set of dimensions for this variable. */
+    dimensions: Dimension[];
+    /** The variable type (e.g. 'level', 'const'). */
+    varType: string;
+}
+
+/**
+ * Includes the properties needed to display a legend item in the UI.
+ */
+interface LegendItem {
+    /** The item text. */
+    label: string;
+    /** The color of the item (in CSS/hex format). */
+    color: string;
+}
+/**
+ * Includes the properties needed to display a link item in the UI.
+ */
+interface LinkItem {
+    /** Whether content is a URL or text to be copied to the clipboard. */
+    kind: 'url' | 'copy';
+    /** The link text that appears in the UI. */
+    text: string;
+    /** The link content (a URL or text). */
+    content: string;
+}
+declare type BundleGraphId = string;
+/**
+ * Describes a dataset in a bundle-specific graph.
+ */
+interface BundleGraphDatasetSpec {
+    /** The dataset key. */
+    datasetKey: DatasetKey;
+    /** The dataset or variable name. */
+    varName: string;
+    /** The source name. */
+    sourceName?: string;
+    /** The label string (as it appears in the graph legend). */
+    label?: string;
+    /** The color of the plot (in CSS/hex format). */
+    color: string;
+}
+/**
+ * Describes a bundle-specific graph.
+ */
+interface BundleGraphSpec {
+    /** The graph identifier. */
+    id: BundleGraphId;
+    /** The graph title. */
+    title: string;
+    /** The legend items for the graph. */
+    legendItems: LegendItem[];
+    /** The datasets displayed in this graph. */
+    datasets: BundleGraphDatasetSpec[];
+    /** Metadata for the graph that can be used to diff to another graph. */
+    metadata: Map<string, string>;
+}
+/**
+ * Allows for displaying a bundle-specific graph.
+ */
+interface BundleGraphView {
+    /** Destroy the underlying graph view and any associated resources. */
+    destroy(): void;
+}
+/**
+ * Wrapper around data that can be used to initialize a graph view.
+ */
+interface BundleGraphData {
+    /** Return a graph view that can be attached to the given canvas element. */
+    createGraphView(canvas: HTMLCanvasElement): BundleGraphView;
+}
+/**
+ * Describes the model that is contained in this bundle.
+ */
+interface ModelSpec {
+    /** The size of the model binary, in bytes. */
+    modelSizeInBytes: number;
+    /** The size of the static data, in bytes. */
+    dataSizeInBytes: number;
+    /** The map of all input variables in this version of the model. */
+    inputVars: Map<VarId, InputVar>;
+    /** The map of all output (and static data) variables in this version of the model. */
+    outputVars: Map<DatasetKey, OutputVar>;
+    /** The map of all variables (both internal and exported) in this version of the model. */
+    implVars: Map<DatasetKey, ImplVar>;
+    /** The custom input variable groups defined for this model. */
+    inputGroups: Map<string, InputVar[]>;
+    /** The custom dataset (output variable) groups defined for this model. */
+    datasetGroups: Map<string, DatasetKey[]>;
+    /** The start time (year) for the model. */
+    startTime?: number;
+    /** The end time (year) for the model. */
+    endTime?: number;
+    /** The specs for the bundled graphs. */
+    graphSpecs?: BundleGraphSpec[];
+}
+/**
+ * An interface that allows for running the bundled model under different input scenarios
+ * and capturing the resulting output data.
+ */
+interface BundleModel extends DataSource {
+    /** The spec for the bundled model. */
+    modelSpec: ModelSpec;
+    /**
+     * Return the set of context graphs to be displayed for the given dataset.  If left
+     * undefined, the set of graphs will be determined using the advertised graph specs.
+     */
+    getGraphsForDataset?(datasetKey: DatasetKey): BundleGraphId[];
+    /**
+     * Load the data used to display the graph by running the model with inputs
+     * configured for the given scenario.
+     */
+    getGraphDataForScenario(scenario: Scenario, graphId: BundleGraphId): Promise<BundleGraphData>;
+    /** Return the links to be displayed for the graph in the given scenario. */
+    getGraphLinksForScenario(scenario: Scenario, graphId: BundleGraphId): LinkItem[];
+}
+/**
+ * Provides access to the model that is contained in this bundle for use in
+ * model-check packages.
+ */
+interface Bundle {
+    /**
+     * The version of the bundle.  This should be incremented when there is an
+     * incompatible change to the bundle format.  The model-check tools can use
+     * this value to skip tests if two bundles have different version numbers.
+     */
+    version: number;
+    /** The spec for the bundled model. */
+    modelSpec: ModelSpec;
+    /** Asynchronously initialize the underlying model. */
+    initModel(): Promise<BundleModel>;
+}
+/**
+ * Associates a name with a `Bundle`.
+ */
+interface NamedBundle {
+    /** The name of the bundle, for example, "Current" or "Baseline". */
+    name: string;
+    /** The associated bundle. */
+    bundle: Bundle;
+}
+/**
+ * Represents a bundle that has had its model initialized.
+ */
+interface LoadedBundle {
+    /** The name of the bundle, for example, "Current" or "Baseline". */
+    name: string;
+    /** The version of the bundle. */
+    version: number;
+    /** The initialized model. */
+    model: BundleModel;
+}
+
+declare type CheckDataRequestKey = string;
+/**
+ * Coordinates on-demand loading of data used to display a graph representation
+ * of a check/predicate.
+ */
+declare class CheckDataCoordinator {
+    readonly bundleModel: BundleModel;
+    private readonly taskQueue;
+    constructor(bundleModel: BundleModel);
+    requestDataset(requestKey: CheckDataRequestKey, scenario: Scenario, datasetKey: DatasetKey, onResponse: (dataset: Dataset) => void): void;
+    cancelRequest(key: CheckDataRequestKey): void;
+}
+
+declare type CheckPredicateOp = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'approx';
+
+declare type CheckPredicateTimeSingle = number;
+declare type CheckPredicateTimeRange = [number, number];
+interface CheckPredicateTimeOptions {
+    after_excl?: number;
+    after_incl?: number;
+    before_excl?: number;
+    before_incl?: number;
+}
+declare type CheckPredicateTimeSpec = CheckPredicateTimeSingle | CheckPredicateTimeRange | CheckPredicateTimeOptions;
+
+interface CheckResultErrorInfo {
+    kind: 'unknown-dataset' | 'unknown-input' | 'unknown-input-group' | 'empty-input-group';
+    name: string;
+}
+interface CheckResult {
+    status: 'passed' | 'failed' | 'error';
+    message?: string;
+    failValue?: number;
+    failOp?: CheckPredicateOp;
+    failRefValue?: number;
+    failTime?: number;
+    errorInfo?: CheckResultErrorInfo;
+}
+
+declare type CheckDatasetError = 'no-matches-for-dataset' | 'no-matches-for-group' | 'no-matches-for-type';
+interface CheckDataset {
+    /** The key for the matched dataset; can be undefined if no dataset matched. */
+    datasetKey?: DatasetKey;
+    /** The name of the matched dataset, or the name associated with the error, if defined. */
+    name: string;
+    /** The error info if the dataset query failed to match. */
+    error?: CheckDatasetError;
+}
+
+interface CheckScenarioError {
+    kind: 'unknown-input-group' | 'empty-input-group';
+    /** The name of the input group that failed to match. */
+    name: string;
+}
+interface CheckScenarioInputDesc {
+    /** The name of the input. */
+    name: string;
+    /** The matched input variable; can be undefined if no input matched. */
+    inputVar?: InputVar;
+    /** The position of the input, if this is a position scenario. */
+    position?: InputPosition;
+    /** The value of the input, for the given position or explicit value. */
+    value?: number;
+}
+interface CheckScenario {
+    /** The scenario for the matched input(s); can be undefined if input(s) failed to match. */
+    scenario?: Scenario;
+    /** The name of the associated input group, if any. */
+    inputGroupName?: string;
+    /** The descriptions of the inputs; if empty, it is an "all inputs" scenario. */
+    inputDescs: CheckScenarioInputDesc[];
+    /** The error info if the scenario/input query failed to match. */
+    error?: CheckScenarioError;
+}
+
+/**
+ * The key type for data references (in the form `<ScenarioKey::DatasetKey>`).
+ */
+declare type CheckDataRefKey = string;
+/**
+ * The scenario and dataset referenced by a particular predicate (for cases
+ * where the check is against another dataset rather than a constant value).
+ */
+interface CheckDataRef {
+    /** The key for the reference; can be undefined if inputs or datasets failed to match. */
+    key?: CheckDataRefKey;
+    /** The scenario used to generate the referenced dataset. */
+    scenario: CheckScenario;
+    /** The referenced dataset. */
+    dataset: CheckDataset;
+}
+
+declare type CheckKey = number;
+
+declare type CheckStatus = 'passed' | 'failed' | 'error';
+interface CheckPredicateOpConstantRef {
+    kind: 'constant';
+    value: number;
+}
+interface CheckPredicateOpDataRef {
+    kind: 'data';
+    dataRef: CheckDataRef;
+}
+declare type CheckPredicateOpRef = CheckPredicateOpConstantRef | CheckPredicateOpDataRef;
+interface CheckPredicateReport {
+    checkKey: CheckKey;
+    result: CheckResult;
+    opRefs: Map<CheckPredicateOp, CheckPredicateOpRef>;
+    opValues: string[];
+    time?: CheckPredicateTimeSpec;
+    tolerance?: number;
+}
+interface CheckDatasetReport {
+    checkDataset: CheckDataset;
+    status: CheckStatus;
+    predicates: CheckPredicateReport[];
+}
+interface CheckScenarioReport {
+    checkScenario: CheckScenario;
+    status: CheckStatus;
+    datasets: CheckDatasetReport[];
+}
+interface CheckTestReport {
+    name: string;
+    status: CheckStatus;
+    scenarios: CheckScenarioReport[];
+}
+interface CheckGroupReport {
+    name: string;
+    tests: CheckTestReport[];
+}
+interface CheckReport {
+    groups: CheckGroupReport[];
+}
+declare type StyleFunc = (s: string) => string;
+/**
+ * Return a string representation of the given scenario.
+ *
+ * @param scenario The scenario report.
+ * @param bold A function that applies bold styling to a string.
+ */
+declare function scenarioMessage(scenario: CheckScenarioReport, bold: StyleFunc): string;
+/**
+ * Return a string representation of the given dataset.
+ *
+ * @param dataset The dataset report.
+ * @param bold A function that applies bold styling to a string.
+ */
+declare function datasetMessage(dataset: CheckDatasetReport, bold: StyleFunc): string;
+/**
+ * Return a string representation of the given predicate.
+ *
+ * @param predicate The predicate report.
+ * @param bold A function that applies bold styling to a string.
+ */
+declare function predicateMessage(predicate: CheckPredicateReport, bold: StyleFunc): string;
+
+interface CheckOptions {
+    /** The strings containing check tests in YAML format. */
+    tests: string[];
+}
+interface CheckConfig {
+    /** The loaded bundle being checked. */
+    bundle: LoadedBundle;
+    /** The strings containing check tests in YAML format. */
+    tests: string[];
+}
+
+/**
+ * A simplified/terse version of `CheckPredicateReport` that matches the
+ * format of the JSON objects emitted by the CLI in terse mode.
+ */
+interface CheckPredicateSummary {
+    checkKey: CheckKey;
+    result: CheckResult;
+}
+/**
+ * A simplified/terse version of `CheckReport` that matches the
+ * format of the JSON objects emitted by the CLI in terse mode.
+ * This only contains predicate summaries for checks that have a status
+ * of 'failed' or 'error'.
+ */
+interface CheckSummary {
+    predicateSummaries: CheckPredicateSummary[];
+}
+/**
+ * Convert a full `CheckReport` to a simplified `CheckSummary` that only includes
+ * failed/errored checks.
+ *
+ * @param checkReport The full check report.
+ * @return The converted check summary.
+ */
+declare function checkSummaryFromReport(checkReport: CheckReport): CheckSummary;
+/**
+ * Convert a simplified `CheckSummary` to a full `CheckReport` that restores the
+ * structure of the tests from the given configuration.
+ *
+ * @param checkConfig The config used to reconstruct the check test structure.
+ * @param checkSummary The simplified check summary.
+ * @param simplifyScenarios If true, reduce the number of scenarios generated for a `matrix`.
+ * @return The converted check report.
+ */
+declare function checkReportFromSummary(checkConfig: CheckConfig, checkSummary: CheckSummary, simplifyScenarios: boolean): CheckReport | undefined;
+
+/**
+ * Describes a scenario/dataset comparison.
+ */
+interface CompareItem {
+    /** The item title. */
+    title: string;
+    /** The item subtitle. */
+    subtitle?: string;
+    /** The scenario used for comparison. */
+    scenario: Scenario;
+    /** The key for the datasets being compared. */
+    datasetKey: DatasetKey;
+}
+/**
+ * The title and subtitle info for a group of comparisons.
+ */
+interface CompareGroupInfo {
+    /** The group title. */
+    title: string;
+    /** The group subtitle. */
+    subtitle?: string;
+    /** The related items (e.g. graphs or sliders) for the group. */
+    relatedItems: RelatedItem[];
+}
+/**
+ * Describes a group of comparisons.  The results can be grouped either
+ * by dataset or by scenario.
+ */
+interface CompareGroup {
+    /** The group title/subtitle info. */
+    info: CompareGroupInfo;
+    /** The items in the group. */
+    items: CompareItem[];
+}
+
+/**
+ * The variable/source name info associated with a dataset.
+ */
+interface DatasetInfo {
+    /** The variable name. */
+    varName: string;
+    /** The new variable name, if it was renamed. */
+    newVarName?: string;
+    /** The source name. */
+    sourceName?: string;
+    /** The new source name, if it was renamed. */
+    newSourceName?: string;
+    /** The related items (e.g. graphs) for the dataset. */
+    relatedItems: RelatedItem[];
+}
+/**
+ * The human-readable title and subtitle for a scenario.
+ */
+interface ScenarioInfo {
+    /** The scenario title. */
+    title: string;
+    /** The scenario subtitle. */
+    subtitle?: string;
+    /**
+     * The position of the scenario when displayed in a row.  Typically, 0 means
+     * "left", 1 means "middle", and so on.
+     */
+    position: number;
+}
+
+/**
+ * Provides access to the set of scenarios that are used when comparing the two models.
+ */
+interface CompareScenarios {
+    /**
+     * Return an array containing all configured scenarios.
+     */
+    getScenarios(): Scenario[];
+    /**
+     * Return the scenario for the given key.
+     *
+     * @param scenarioKey The key for the scenario.
+     */
+    getScenario(scenarioKey: ScenarioKey): Scenario | undefined;
+    /**
+     * Return the group info for the given group key.
+     *
+     * @param groupKey The scenario group key.
+     */
+    getScenarioGroupInfo(groupKey: ScenarioGroupKey): CompareGroupInfo | undefined;
+    /**
+     * Return the title/subtitle info for the given scenario.
+     *
+     * Note that the given `groupKey` could be different than `scenario.groupKey`.  This
+     * will be the case for the "all inputs at default" item that is included in each
+     * row in the detail view for reference purposes.  The provided `groupKey` will be
+     * used to customize the title and subtitle for that item (for example, it will show
+     * the default value of the input associated with the row).
+     *
+     * @param scenario The scenario to be displayed.
+     * @param groupKey The key for the group in which the scenario will be displayed.
+     */
+    getScenarioInfo(scenario: Scenario, groupKey: ScenarioGroupKey): ScenarioInfo | undefined;
+}
+/**
+ * Provides access to the set of datasets that are configured for comparison.
+ */
+interface CompareDatasets {
+    /** The mapping of renamed dataset keys. */
+    renamedDatasetKeys?: Map<DatasetKey, DatasetKey>;
+    /**
+     * Return the keys for the datasets that should be compared for the given scenario.
+     *
+     * @param scenario The scenario.
+     */
+    getDatasetKeysForScenario(scenario: Scenario): DatasetKey[];
+    /**
+     * Return the dataset info for the given key.
+     */
+    getDatasetInfo(datasetKey: DatasetKey): DatasetInfo | undefined;
+}
+interface CompareOptions {
+    baseline: NamedBundle;
+    thresholds: number[];
+    scenarios: CompareScenarios;
+    datasets: CompareDatasets;
+}
+interface CompareConfig {
+    bundleL: LoadedBundle;
+    bundleR: LoadedBundle;
+    thresholds: number[];
+    scenarios: CompareScenarios;
+    datasets: CompareDatasets;
+}
+
+declare type CompareDataRequestKey = string;
+/**
+ * Coordinates loading of data in parallel from two models.
+ */
+declare class CompareDataCoordinator {
+    readonly bundleModelL: BundleModel;
+    readonly bundleModelR: BundleModel;
+    private readonly taskQueue;
+    constructor(bundleModelL: BundleModel, bundleModelR: BundleModel);
+    requestDatasetMaps(requestKey: CompareDataRequestKey, scenario: Scenario, datasetKeys: DatasetKey[], onResponse: (datasetMapL: DatasetMap, datasetMapR: DatasetMap) => void): void;
+    requestGraphData(requestKey: CompareDataRequestKey, bundle: 'left' | 'right', scenario: Scenario, graphId: BundleGraphId, onResponse: (graphData: BundleGraphData) => void): void;
+    cancelRequest(key: CompareDataRequestKey): void;
+}
+
+interface PerfReport {
+    readonly minTime: number;
+    readonly maxTime: number;
+    readonly avgTime: number;
+    readonly allTimes: number[];
+}
+declare class PerfStats {
+    private readonly times;
+    addRun(timeInMillis: number): void;
+    toReport(): PerfReport;
+}
+
+interface CompareDatasetReport {
+    scenarioKey: ScenarioKey;
+    datasetKey: DatasetKey;
+    diffReport: DiffReport;
+}
+interface CompareReport {
+    datasetReports: CompareDatasetReport[];
+    perfReportL: PerfReport;
+    perfReportR: PerfReport;
+}
+
+interface DiffPoint {
+    time: number;
+    valueL: number;
+    valueR: number;
+}
+declare type DiffValidity = 'neither' | 'left-only' | 'right-only' | 'both';
+interface DiffReport {
+    validity: DiffValidity;
+    minValue: number;
+    maxValue: number;
+    avgDiff: number;
+    minDiff: number;
+    maxDiff: number;
+    maxDiffPoint: DiffPoint;
+}
+declare function diffDatasets(datasetL: Dataset | undefined, datasetR: Dataset | undefined): DiffReport;
+declare function compareDatasets(scenarioKey: ScenarioKey, datasetKey: DatasetKey, datasetMapL: DatasetMap, datasetMapR: DatasetMap): CompareDatasetReport;
+
+/**
+ * A simplified/terse version of `CompareDatasetReport` that matches the
+ * format of the JSON objects emitted by the CLI in terse mode.
+ * The object keys are terse and it only includes the minimum set of fields
+ * to keep the file smaller when there are many reported differences.
+ */
+interface CompareDatasetSummary {
+    /** Short for `scenarioKey`. */
+    s: ScenarioKey;
+    /** Short for `datasetKey`. */
+    d: DatasetKey;
+    /** Short for `maxDiff`. */
+    md: number;
+}
+/**
+ * A simplified/terse version of `CompareReport` that matches the
+ * format of the JSON objects emitted by the CLI in terse mode.
+ */
+interface CompareSummary {
+    datasetSummaries: CompareDatasetSummary[];
+    perfReportL: PerfReport;
+    perfReportR: PerfReport;
+}
+/**
+ * Convert a full `CompareReport` to a simplified `CompareSummary` that includes
+ * the minimum set of fields needed to keep the file smaller when there are many
+ * reported differences.
+ *
+ * @param compareReport The full compare report.
+ * @return The converted compare summary.
+ */
+declare function compareSummaryFromReport(compareReport: CompareReport): CompareSummary;
+
+declare type GraphInclusion = 'neither' | 'left-only' | 'right-only' | 'both';
+interface GraphMetadataReport {
+    /** The key for the metadata field. */
+    key: string;
+    /** The value of the metadata field in the left bundle. */
+    valueL?: string;
+    /** The value of the metadata field in the right bundle. */
+    valueR?: string;
+}
+interface GraphDatasetReport {
+    /** The dataset key. */
+    datasetKey: DatasetKey;
+    /** The max diff for this dataset. */
+    maxDiff?: number;
+}
+interface GraphReport {
+    /** Indicates which bundles the graph is defined in. */
+    inclusion: GraphInclusion;
+    /** The metadata fields with differences. */
+    metadataReports: GraphMetadataReport[];
+    /** The datasets with differences. */
+    datasetReports: GraphDatasetReport[];
+}
+/**
+ * Compare the metadata and datasets for the given graphs.
+ *
+ * @param graphL The graph defined in the left bundle.
+ * @param graphR The graph defined in the right bundle.
+ * @param scenarioKey The scenario used for comparing datasets.
+ * @param datasetSummaries The set of summaries from a previous comparison run.
+ */
+declare function diffGraphs(graphL: BundleGraphSpec | undefined, graphR: BundleGraphSpec | undefined, scenarioKey: ScenarioKey, datasetSummaries: CompareDatasetSummary[]): GraphReport;
+
+interface ConfigOptions {
+    /**
+     * The bundle being checked.  This bundle will also be compared against the
+     * "baseline" bundle, if `compare` is defined.
+     */
+    current: NamedBundle;
+    /**
+     * The model check options.
+     */
+    check: CheckOptions;
+    /**
+     * The model comparison options.
+     */
+    compare?: CompareOptions;
+}
+interface Config {
+    check: CheckConfig;
+    compare?: CompareConfig;
+}
+
+declare function createConfig(options: ConfigOptions): Promise<Config>;
+
+/**
+ * Manages a set of dataset keys (corresponding to the available model outputs
+ * in the given bundles) that can be used to compare two versions of the model.
+ *
+ * This class computes the union of the available dataset keys and handles
+ * renames so that if any variables were renamed in the "right" bundle, the
+ * old key will be used so that the variable can still be compared.
+ *
+ * This is intended to be a simple, general purpose way to create a set of
+ * dataset keys, but every model is different, so you can replace this with
+ * a different set of dataset keys that is better suited for the model you
+ * are testing.
+ */
+declare class DatasetManager implements CompareDatasets {
+    private readonly bundleL;
+    private readonly bundleR;
+    readonly renamedDatasetKeys?: Map<DatasetKey, DatasetKey>;
+    readonly allOutputVarKeys: DatasetKey[];
+    readonly modelOutputVarKeys: DatasetKey[];
+    /**
+     * @param bundleL The "left" bundle being compared.
+     * @param bundleR The "right" bundle being compared.
+     * @param renamedDatasetKeys The mapping of renamed dataset keys.
+     */
+    constructor(bundleL: Bundle, bundleR: Bundle, renamedDatasetKeys?: Map<DatasetKey, DatasetKey>);
+    getDatasetKeysForScenario(scenario: Scenario): DatasetKey[];
+    getDatasetInfo(datasetKey: DatasetKey): DatasetInfo | undefined;
+}
+
+/**
+ * Manages a set of scenarios (corresponding to the available model inputs
+ * in the given bundles) that can be used to compare two versions of the model.
+ */
+declare class ScenarioManager implements CompareScenarios {
+    private readonly bundleL;
+    private readonly bundleR;
+    private readonly scenarios;
+    private readonly scenarioInfo;
+    private readonly defaultInfoForGroup;
+    private readonly groupInfo;
+    /**
+     * @param bundleL The "left" bundle being compared.
+     * @param bundleR The "right" bundle being compared.
+     */
+    constructor(bundleL: Bundle, bundleR: Bundle);
+    getScenarios(): Scenario[];
+    getScenario(scenarioKey: ScenarioKey): Scenario | undefined;
+    getScenarioGroupInfo(groupKey: ScenarioGroupKey): CompareGroupInfo | undefined;
+    getScenarioInfo(scenario: Scenario, groupKey: ScenarioGroupKey): ScenarioInfo | undefined;
+    /**
+     * Override the title and subtitle that are displayed when the "all inputs at default"
+     * scenario is included for a particular group.  This can be used to customize the
+     * text instead of showing the default message ("...at default").
+     *
+     * @param groupKey The scenario group key.
+     * @param scenarioInfo The custom info to be displayed.
+     */
+    setDefaultScenarioInfoForGroup(groupKey: ScenarioGroupKey, scenarioInfo: ScenarioInfo): void;
+    /**
+     * Add a scenario to the set.
+     *
+     * @param scenario The scenario to be added.
+     * @param scenarioInfo The custom title/subtitle for the scenario.  If left undefined, the
+     * default (possibly generic) info will be used.
+     * @param groupInfo The custom title/subtitle for the group.  If left undefined, the
+     * default (possibly generic) info will be used.
+     */
+    addScenario(scenario: Scenario, scenarioInfo?: ScenarioInfo, groupInfo?: CompareGroupInfo): void;
+    /**
+     * Adds a set of scenarios that can be used to compare the two versions of
+     * the given model.
+     *
+     * This function computes a matrix of input scenarios using the input variables
+     * advertised by the given bundles.  It will generate scenarios such that for
+     * any output variable, the model will be run:
+     *   - once with all inputs at their default
+     *   - once with all inputs at their minimum
+     *   - once with all inputs at their maximum
+     *   - twice for each input
+     *       - once with single input at its minimum
+     *       - once with single input at its maximum
+     *
+     * This is intended to be a simple, general purpose way to create a set of
+     * scenarios, but every model is different, so you can replace this with a
+     * function to generate a different set of scenarios that is better suited
+     * for the model you are testing.
+     */
+    addScenarioMatrix(): void;
+    private getGroupInfoForScenario;
+    private getInfoForScenario;
+    private getInfoForPositionSetting;
+    private getRelatedItemsForSettings;
+    private getInputVarForSetting;
+}
+
+declare class PerfRunner {
+    readonly bundleModelL: BundleModel;
+    readonly bundleModelR: BundleModel;
+    private readonly mode;
+    private readonly taskQueue;
+    onComplete?: (reportL: PerfReport, reportR: PerfReport) => void;
+    onError?: (error: Error) => void;
+    constructor(bundleModelL: BundleModel, bundleModelR: BundleModel, mode?: 'serial' | 'parallel');
+    start(): void;
+}
+
+interface SuiteReport {
+    checkReport: CheckReport;
+    compareReport?: CompareReport;
+}
+
+declare type CancelRunSuite = () => void;
+interface RunSuiteCallbacks {
+    onProgress?: (pct: number) => void;
+    onComplete?: (suiteReport: SuiteReport) => void;
+    onError?: (error: Error) => void;
+}
+interface RunSuiteOptions {
+    /** Set to true to reduce the number of scenarios generated for a `matrix`. */
+    simplifyScenarios?: boolean;
+}
+/**
+ * Run the full suite of checks and comparisons defined in the given configuration.
+ *
+ * @param config The test suite configuration.
+ * @param callbacks The callbacks that will be notified.
+ * @param options Options to control how the tests are run.
+ * @return A function that will cancel the process when invoked.
+ */
+declare function runSuite(config: Config, callbacks: RunSuiteCallbacks, options?: RunSuiteOptions): CancelRunSuite;
+
+/**
+ * A simplified/terse version of `SuiteReport` that matches the
+ * format of the JSON objects emitted by the CLI in terse mode.
+ */
+interface SuiteSummary {
+    checkSummary: CheckSummary;
+    compareSummary?: CompareSummary;
+}
+/**
+ * Convert a full `SuiteReport` to a simplified `SuiteSummary` that only includes
+ * failed/errored checks or comparisons with differences.
+ *
+ * @param suiteReport The full suite report.
+ * @return The converted suite summary.
+ */
+declare function suiteSummaryFromReport(suiteReport: SuiteReport): SuiteSummary;
+
+export { AllInputsScenario, Bundle, BundleGraphData, BundleGraphDatasetSpec, BundleGraphId, BundleGraphSpec, BundleGraphView, BundleModel, CheckDataCoordinator, CheckDataRequestKey, CheckDatasetReport, CheckGroupReport, CheckKey, CheckPredicateOp, CheckPredicateOpConstantRef, CheckPredicateOpDataRef, CheckPredicateOpRef, CheckPredicateReport, CheckPredicateSummary, CheckPredicateTimeOptions, CheckPredicateTimeRange, CheckPredicateTimeSingle, CheckPredicateTimeSpec, CheckReport, CheckResult, CheckResultErrorInfo, CheckScenarioReport, CheckStatus, CheckSummary, CheckTestReport, CompareConfig, CompareDataCoordinator, CompareDataRequestKey, CompareDatasetReport, CompareDatasetSummary, CompareDatasets, CompareGroup, CompareGroupInfo, CompareItem, CompareOptions, CompareReport, CompareScenarios, CompareSummary, Config, ConfigOptions, DataSource, Dataset, DatasetInfo, DatasetKey, DatasetManager, DatasetMap, DatasetsResult, DiffPoint, DiffReport, DiffValidity, Dimension, GraphDatasetReport, GraphInclusion, GraphMetadataReport, GraphReport, ImplVar, InputPosition, InputSetting, InputVar, LegendItem, LinkItem, LoadedBundle, ModelSpec, NamedBundle, OutputVar, PerfReport, PerfRunner, PerfStats, PositionSetting, RelatedItem, RunSuiteCallbacks, RunSuiteOptions, Scenario, ScenarioGroupKey, ScenarioInfo, ScenarioKey, ScenarioManager, SettingsScenario, SourceName, Subscript, SuiteReport, SuiteSummary, ValueSetting, VarId, allInputsAtPositionScenario, checkReportFromSummary, checkSummaryFromReport, compareDatasets, compareSummaryFromReport, createConfig, datasetMessage, diffDatasets, diffGraphs, inputAtPositionScenario, inputAtValueScenario, matrixScenarios, positionSetting, predicateMessage, runSuite, scenarioMessage, settingsScenario, suiteSummaryFromReport, valueSetting };