@openmbee/opensysml 0.9.2 → 0.10.0

package/dist/core/engines.d.ts

@@ -0,0 +1,64 @@
+import type { Bound as PbBound, EngineInfo as PbEngineInfo } from "../generated/sysml_pb.js";
+import { type VerdictBound, type VerdictStanding } from "./values.js";
+/** Strengths, weakest first, as the service spells them. */
+export declare const STRENGTH_NOT_COVERED = "not covered";
+export declare const STRENGTH_OBSERVED = "observed";
+export declare const STRENGTH_WITNESSED = "witnessed";
+export declare const STRENGTH_BOUNDED = "bounded";
+export declare const STRENGTH_PROVED = "proved";
+/** Engine selections that name no single engine. */
+export declare const ENGINE_AUTO = "auto";
+export declare const ENGINE_ALL = "all";
+/** How far an answer can be trusted: who answered, how strongly, within what. */
+export type Standing = VerdictStanding;
+/** The standing a service that reported none carries. */
+export declare function emptyStanding(): Standing;
+/** One limit an engine ran under, and whether the run stopped at it. */
+export type EngineBound = VerdictBound;
+/** Reads the standing fields a response or verdict carries. */
+export declare function standingOf(pb: {
+    engine: string;
+    strength: string;
+    bounds: PbBound[];
+}): Standing;
+/** Whether the service reported a standing at all. */
+export declare function standingReported(standing: Standing): boolean;
+/** The bounds the engine stopped at. */
+export declare function standingReached(standing: Standing): EngineBound[];
+/** One phrase: `observed by run`, `bounded by explore (runs 64 reached)`. */
+export declare function explainStanding(standing: Standing): string;
+/** One engine the service registers, as `listEngines` reports it. */
+export interface EngineInfo {
+    /** The engine's name, the spelling `engine` selects it by. */
+    name: string;
+    /** The strongest evidence it may claim, one of `STRENGTH_*`. */
+    authority: string;
+    /** The question kinds it answers. */
+    answers: readonly string[];
+    /** The bounds it runs under. */
+    bounds: readonly string[];
+    /** The external process it needs; empty for an in-process engine. */
+    process: string;
+    /** Where that process was found; empty when it was not. */
+    processFound: string;
+    /** Whether it can run here. */
+    ready: boolean;
+    /** Why it cannot, when it cannot. */
+    unavailable: string;
+    /** `built-in`, `tool` or `engine` (one registered from a manifest). */
+    kind: string;
+    /** How it is spoken to. */
+    protocol: string;
+    /** The manifest file an external engine was read from; empty for a built-in one. */
+    source: string;
+    /** The resolved command of an external engine; empty for a built-in one. */
+    command: string;
+    /** The version its manifest declares; empty for a built-in one. */
+    version: string;
+    /** Whether this service runs it; an external engine is listed unserved until `-serve-external-engines`. */
+    served: boolean;
+}
+/** An engine as the wire describes it. */
+export declare function engineInfoOf(pb: PbEngineInfo): EngineInfo;
+/** One line naming the engine, its kind, its authority, its questions and its status. */
+export declare function explainEngine(engine: EngineInfo): string;

package/dist/core/engines.js

@@ -0,0 +1,74 @@
+// The analysis engines the service answers with, and the standing of an answer.
+// The standing a verdict or response carries is the `VerdictStanding` of
+// values.ts; the helpers here read it.
+import { decodeStanding } from "./values.js";
+/** Strengths, weakest first, as the service spells them. */
+export const STRENGTH_NOT_COVERED = "not covered";
+export const STRENGTH_OBSERVED = "observed";
+export const STRENGTH_WITNESSED = "witnessed";
+export const STRENGTH_BOUNDED = "bounded";
+export const STRENGTH_PROVED = "proved";
+/** Engine selections that name no single engine. */
+export const ENGINE_AUTO = "auto";
+export const ENGINE_ALL = "all";
+/** The standing a service that reported none carries. */
+export function emptyStanding() {
+    return { engine: "", strength: "", bounds: [], reported: false, reached: [] };
+}
+/** Reads the standing fields a response or verdict carries. */
+export function standingOf(pb) {
+    return decodeStanding(pb);
+}
+/** Whether the service reported a standing at all. */
+export function standingReported(standing) {
+    return standing.strength !== "";
+}
+/** The bounds the engine stopped at. */
+export function standingReached(standing) {
+    return standing.bounds.filter((bound) => bound.reached);
+}
+/** One phrase: `observed by run`, `bounded by explore (runs 64 reached)`. */
+export function explainStanding(standing) {
+    if (!standingReported(standing)) {
+        return "";
+    }
+    let line = standing.strength;
+    if (standing.engine !== "") {
+        line += ` by ${standing.engine}`;
+    }
+    const reached = standingReached(standing).map((b) => `${b.name} ${b.limit.toString()} reached`);
+    if (reached.length > 0) {
+        line += ` (${reached.join(", ")})`;
+    }
+    return line;
+}
+/** An engine as the wire describes it. */
+export function engineInfoOf(pb) {
+    return {
+        name: pb.name,
+        authority: pb.authority,
+        answers: [...pb.answers],
+        bounds: [...pb.bounds],
+        process: pb.process,
+        processFound: pb.processFound,
+        ready: pb.ready,
+        unavailable: pb.unavailable,
+        kind: pb.kind,
+        protocol: pb.protocol,
+        source: pb.source,
+        command: pb.command,
+        version: pb.version,
+        served: pb.served,
+    };
+}
+/** One line naming the engine, its kind, its authority, its questions and its status. */
+export function explainEngine(engine) {
+    let status = engine.ready ? "ready" : `unavailable: ${engine.unavailable}`;
+    if (engine.kind === "engine" && !engine.served) {
+        status += "; not served by this service";
+    }
+    const kind = engine.kind === "engine" || engine.kind === "tool"
+        ? ` (${engine.kind}, ${engine.protocol})`
+        : "";
+    return `${engine.name}${kind}: ${engine.authority}, answers ${engine.answers.join(", ")}; ${status}`;
+}

package/dist/core/errors.d.ts

@@ -1,3 +1,6 @@
+import type { ServerInfo } from "./capabilities.js";
+import type { DocumentEvent } from "./document.js";
+import type { AnalysisResult } from "./verdict.js";
 /** Base class of every error this client raises. */
 export declare class OpenSysMLError extends Error {
     constructor(message: string, options?: {
@@ -20,6 +23,21 @@ export declare class ServiceError extends OpenSysMLError {
 /** A private child service failed to start, or died while it was needed. */
 export declare class ServiceStartError extends ServiceError {
 }
+/** The service already listening is not the one asked for, reported rather than stopped. */
+export declare class StaleServiceError extends ServiceError {
+    /** Address the mismatched service is listening on. */
+    readonly address: string;
+    /** How it differs from the service that was asked for. */
+    readonly reason: string;
+    /** What to do about it. */
+    readonly remedy: string;
+    /** What it reported about itself, when it could be asked. */
+    readonly info: ServerInfo | undefined;
+    constructor(address: string, reason: string, remedy: string, options?: {
+        info?: ServerInfo;
+        cause?: unknown;
+    });
+}
 /** The connection was closed and cannot be used again. */
 export declare class ClosedConnectionError extends OpenSysMLError {
     constructor();
@@ -36,6 +54,9 @@ export declare class InvalidRequestError extends ServiceError {
 /** A call exceeded its deadline, or was cancelled. */
 export declare class ServiceTimeoutError extends ServiceError {
 }
+/** The service was unreachable, refused the stream, or died before answering. */
+export declare class ServiceUnavailableError extends ServiceError {
+}
 /** The connected service does not implement the call at all. */
 export declare class UnsupportedOperationError extends ServiceError {
 }
@@ -64,7 +85,16 @@ export declare class ManifestSignatureError extends ChecksumMismatchError {
 export declare class ParseError extends OpenSysMLError {
     /** Diagnostics the service reported, in the order it reported them. */
     readonly diagnostics: readonly ModelDiagnostic[];
-    constructor(message: string, diagnostics?: readonly ModelDiagnostic[]);
+    /** The model the errors belong to, when one was loaded, so it stays inspectable. */
+    readonly model: ModelLike | undefined;
+    constructor(message: string, diagnostics?: readonly ModelDiagnostic[], options?: {
+        model?: ModelLike;
+    });
+}
+/** The surface of a model a ParseError carries, kept structural so model.ts stays a client of this file. */
+export interface ModelLike {
+    readonly hash: string;
+    readonly diagnostics: readonly ModelDiagnostic[];
 }
 /** One diagnostic about a model, at a source position when the service gave one. */
 export interface ModelDiagnostic {
@@ -85,7 +115,9 @@ export declare class SymbolNotFoundError extends OpenSysMLError {
     readonly symbolName: string;
     /** Names the model declares that are close enough to be typos of it. */
     readonly suggestions: readonly string[];
-    constructor(name: string, near?: readonly string[]);
+    constructor(name: string, near?: readonly string[], options?: {
+        cause?: unknown;
+    });
 }
 /** An expression could not be evaluated, or a symbol could not be instantiated. */
 export declare class EvaluationError extends OpenSysMLError {
@@ -94,5 +126,135 @@ export declare class EvaluationError extends OpenSysMLError {
     readonly diagnostics: readonly ModelDiagnostic[];
     constructor(message: string, reason?: FailureCause, diagnostics?: readonly ModelDiagnostic[]);
 }
+/** A run — an execution, verification, calculation, analysis or sweep — failed. */
+export declare class ExecutionError extends EvaluationError {
+    /** Partial ExecuteState trace, when a traced run failed. */
+    readonly trace: readonly DocumentEvent[];
+    /** Oldest ExecuteState trace records the service discarded. */
+    readonly traceDropped: number;
+    constructor(message: string, reason?: FailureCause, diagnostics?: readonly ModelDiagnostic[], trace?: readonly DocumentEvent[], traceDropped?: number);
+}
+/** The element a verification named is of another kind, a wrong request rather than a verdict. */
+export declare class WrongKindError extends ExecutionError {
+}
+/** An analysis case could not run to its end but left something to inspect, carried as `result`. */
+export declare class AnalysisRunError extends ExecutionError {
+    /** The partial result the failed run left: the evaluations made, the verdicts left undecided. */
+    readonly result: AnalysisResult;
+    constructor(message: string, result: AnalysisResult, options?: {
+        diagnostics?: readonly ModelDiagnostic[];
+        reason?: FailureCause;
+    });
+}
+/** A model could not be written in the format asked for. */
+export declare class ConversionError extends OpenSysMLError {
+    readonly diagnostics: readonly ModelDiagnostic[];
+    constructor(message: string, diagnostics?: readonly ModelDiagnostic[]);
+}
+/** A SysML v1 model could not be read, so nothing of it was migrated. */
+export declare class MigrationError extends OpenSysMLError {
+}
+/** The service sent a value the wire format cannot represent, or a caller sent one it cannot carry. */
+export declare class UnsupportedValueError extends OpenSysMLError {
+}
+/** A feature value could not be evaluated or was never materialized. */
+export declare class FeatureValueError extends OpenSysMLError {
+    /** Name of the feature. */
+    readonly featureName: string;
+    /** Error description the service reported. */
+    readonly message: string;
+    constructor(featureName: string, message: string);
+}
+/** A feature holds a value of another type than its generated view declares. */
+export declare class TypeMismatchError extends OpenSysMLError {
+    /** Name of the feature. */
+    readonly featureName: string;
+    /** Type the generated class declares. */
+    readonly expected: string;
+    /** The value actually decoded. */
+    readonly value: unknown;
+    constructor(featureName: string, expected: string, value: unknown);
+}
+/** A generated typed view was asked to wrap an instance of another type. */
+export declare class InstanceTypeError extends OpenSysMLError {
+    /** FQN of the definition the generated class views. */
+    readonly expected: string;
+    /** FQN the instance reports as its type. */
+    readonly actual: string;
+    constructor(expected: string, actual: string);
+}
+/** A query payload is not one the SysML v2 API & Services query model describes. */
+export declare class QueryError extends OpenSysMLError {
+}
+/** A document query binding cannot be written before anything is sent. */
+export declare class DocumentQueryError extends OpenSysMLError {
+}
+/** One declaration referring to the target of a refused rename, delete or move. */
+export declare class Referrer {
+    /** The referring declaration, as the notation names it. */
+    readonly name: string;
+    /** The document declaring it, as the parse named it. */
+    readonly document: string;
+    constructor(name: string, document: string);
+}
+/** An edit to a model was refused, and nothing was changed. */
+export declare class EditError extends OpenSysMLError {
+    /** Refusal kind, as the wire enum names it, e.g. `EDIT_FAILURE_UNKNOWN_TARGET`. */
+    readonly failure: string;
+    /** Diagnostics behind the refusal. */
+    readonly diagnostics: readonly ModelDiagnostic[];
+    /** Where references a refused rename, delete or move would have broken are made. */
+    readonly referringElements: readonly string[];
+    /** The same referrers, each with the document declaring it. */
+    readonly referrers: readonly Referrer[];
+    constructor(message: string, options?: {
+        failure?: string;
+        diagnostics?: readonly ModelDiagnostic[];
+        referringElements?: readonly string[];
+        referrers?: readonly Referrer[];
+    });
+}
+/** An editor with no operations was applied. */
+export declare class NoEditsError extends EditError {
+}
+/** The element an edit names cannot carry that edit. */
+export declare class EditTargetError extends EditError {
+}
+/** The new value or name itself cannot be read. */
+export declare class InvalidEditError extends EditError {
+}
+/** A rename would break references to the renamed element. */
+export declare class RenameReferencedError extends EditError {
+}
+/** Two operations would edit the same bytes of the source. */
+export declare class OverlappingEditsError extends EditError {
+}
+/** The edited notation could not be read back. */
+export declare class EditResultError extends EditError {
+}
+/** An add-member owner is not declared in the model. */
+export declare class OwnerNotFoundError extends EditError {
+}
+/** An add-member owner cannot contain members. */
+export declare class OwnerNotNamespaceError extends EditError {
+}
+/** A declaration kind is invalid for the source language. */
+export declare class IllegalMemberKindError extends InvalidEditError {
+}
+/** An owner already declares the requested member name. */
+export declare class MemberNameTakenError extends EditError {
+}
+/** A referenced declaration is deleted without cascade. */
+export declare class DeleteReferencedError extends EditError {
+}
+/** A move's new owner is the moved declaration or inside it. */
+export declare class OwnerInsideTargetError extends EditError {
+}
+/** A move would leave a reference no spelling can restore. */
+export declare class MoveReferencedError extends EditError {
+}
+/** A rename, delete or move is referred to from a document the edit cannot rewrite. */
+export declare class ReferencedElsewhereError extends EditError {
+}
 /** The service's classification of a failure it reported in a successful answer. */
 export type FailureCause = "unspecified" | "evaluation" | "wrong_kind" | "ambiguous_subject" | "undecided";

package/dist/core/errors.js

@@ -23,6 +23,25 @@ export class ServiceError extends OpenSysMLError {
 /** A private child service failed to start, or died while it was needed. */
 export class ServiceStartError extends ServiceError {
 }
+/** The service already listening is not the one asked for, reported rather than stopped. */
+export class StaleServiceError extends ServiceError {
+    /** Address the mismatched service is listening on. */
+    address;
+    /** How it differs from the service that was asked for. */
+    reason;
+    /** What to do about it. */
+    remedy;
+    /** What it reported about itself, when it could be asked. */
+    info;
+    constructor(address, reason, remedy, options = {}) {
+        super(`the sysml-grpc service already listening on ${address} is not the one this client ` +
+            `asked for: ${reason}.\n  service: ${options.info?.describe() ?? address}\n  fix:     ${remedy}`, options.cause === undefined ? {} : { cause: options.cause });
+        this.address = address;
+        this.reason = reason;
+        this.remedy = remedy;
+        this.info = options.info;
+    }
+}
 /** The connection was closed and cannot be used again. */
 export class ClosedConnectionError extends OpenSysMLError {
     constructor() {
@@ -41,6 +60,9 @@ export class InvalidRequestError extends ServiceError {
 /** A call exceeded its deadline, or was cancelled. */
 export class ServiceTimeoutError extends ServiceError {
 }
+/** The service was unreachable, refused the stream, or died before answering. */
+export class ServiceUnavailableError extends ServiceError {
+}
 /** The connected service does not implement the call at all. */
 export class UnsupportedOperationError extends ServiceError {
 }
@@ -69,9 +91,12 @@ export class ManifestSignatureError extends ChecksumMismatchError {
 export class ParseError extends OpenSysMLError {
     /** Diagnostics the service reported, in the order it reported them. */
     diagnostics;
-    constructor(message, diagnostics = []) {
+    /** The model the errors belong to, when one was loaded, so it stays inspectable. */
+    model;
+    constructor(message, diagnostics = [], options = {}) {
         super(message);
         this.diagnostics = diagnostics;
+        this.model = options.model;
     }
 }
 /** No symbol of that name is declared in the model. */
@@ -80,9 +105,9 @@ export class SymbolNotFoundError extends OpenSysMLError {
     symbolName;
     /** Names the model declares that are close enough to be typos of it. */
     suggestions;
-    constructor(name, near = []) {
+    constructor(name, near = [], options = {}) {
         const hint = near.length > 0 ? `; did you mean ${near.join(", ")}?` : "";
-        super(`the model declares no symbol named ${JSON.stringify(name)}${hint}`);
+        super(`the model declares no symbol named ${JSON.stringify(name)}${hint}`, options.cause === undefined ? {} : { cause: options.cause });
         this.symbolName = name;
         this.suggestions = [...near];
     }
@@ -98,3 +123,184 @@ export class EvaluationError extends OpenSysMLError {
         this.diagnostics = diagnostics;
     }
 }
+/** A run — an execution, verification, calculation, analysis or sweep — failed. */
+export class ExecutionError extends EvaluationError {
+    /** Partial ExecuteState trace, when a traced run failed. */
+    trace;
+    /** Oldest ExecuteState trace records the service discarded. */
+    traceDropped;
+    constructor(message, reason = "unspecified", diagnostics = [], trace = [], traceDropped = 0) {
+        super(message, reason, diagnostics);
+        this.trace = trace;
+        this.traceDropped = traceDropped;
+    }
+}
+/** The element a verification named is of another kind, a wrong request rather than a verdict. */
+export class WrongKindError extends ExecutionError {
+}
+/** An analysis case could not run to its end but left something to inspect, carried as `result`. */
+export class AnalysisRunError extends ExecutionError {
+    /** The partial result the failed run left: the evaluations made, the verdicts left undecided. */
+    result;
+    constructor(message, result, options = {}) {
+        super(message, options.reason ?? "unspecified", options.diagnostics ?? []);
+        this.result = result;
+    }
+}
+/** A model could not be written in the format asked for. */
+export class ConversionError extends OpenSysMLError {
+    diagnostics;
+    constructor(message, diagnostics = []) {
+        super(message);
+        this.diagnostics = diagnostics;
+    }
+}
+/** A SysML v1 model could not be read, so nothing of it was migrated. */
+export class MigrationError extends OpenSysMLError {
+}
+/** The service sent a value the wire format cannot represent, or a caller sent one it cannot carry. */
+export class UnsupportedValueError extends OpenSysMLError {
+}
+/** A feature value could not be evaluated or was never materialized. */
+export class FeatureValueError extends OpenSysMLError {
+    /** Name of the feature. */
+    featureName;
+    /** Error description the service reported. */
+    message;
+    constructor(featureName, message) {
+        super(`feature value ${JSON.stringify(featureName)}: ${message}`);
+        this.featureName = featureName;
+        this.message = message;
+    }
+}
+/** A feature holds a value of another type than its generated view declares. */
+export class TypeMismatchError extends OpenSysMLError {
+    /** Name of the feature. */
+    featureName;
+    /** Type the generated class declares. */
+    expected;
+    /** The value actually decoded. */
+    value;
+    constructor(featureName, expected, value) {
+        super(`feature value ${JSON.stringify(featureName)}: expected ${expected}, got ${describeValue(value)}`);
+        this.featureName = featureName;
+        this.expected = expected;
+        this.value = value;
+    }
+}
+/** A generated typed view was asked to wrap an instance of another type. */
+export class InstanceTypeError extends OpenSysMLError {
+    /** FQN of the definition the generated class views. */
+    expected;
+    /** FQN the instance reports as its type. */
+    actual;
+    constructor(expected, actual) {
+        super(`instance of ${JSON.stringify(actual)} is not a ${JSON.stringify(expected)}; ` +
+            "call the generated class's unchecked(instance) to view it without this check");
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+function describeValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "object") {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return "[unprintable]";
+        }
+    }
+    switch (typeof value) {
+        case "string":
+            return JSON.stringify(value);
+        case "number":
+            return String(value);
+        case "bigint":
+            return `${value.toString()}n`;
+        case "boolean":
+        case "undefined":
+            return String(value);
+        default:
+            return "[unprintable]";
+    }
+}
+/** A query payload is not one the SysML v2 API & Services query model describes. */
+export class QueryError extends OpenSysMLError {
+}
+/** A document query binding cannot be written before anything is sent. */
+export class DocumentQueryError extends OpenSysMLError {
+}
+/** One declaration referring to the target of a refused rename, delete or move. */
+export class Referrer {
+    /** The referring declaration, as the notation names it. */
+    name;
+    /** The document declaring it, as the parse named it. */
+    document;
+    constructor(name, document) {
+        this.name = name;
+        this.document = document;
+    }
+}
+/** An edit to a model was refused, and nothing was changed. */
+export class EditError extends OpenSysMLError {
+    /** Refusal kind, as the wire enum names it, e.g. `EDIT_FAILURE_UNKNOWN_TARGET`. */
+    failure;
+    /** Diagnostics behind the refusal. */
+    diagnostics;
+    /** Where references a refused rename, delete or move would have broken are made. */
+    referringElements;
+    /** The same referrers, each with the document declaring it. */
+    referrers;
+    constructor(message, options = {}) {
+        super(message);
+        this.failure = options.failure ?? "";
+        this.diagnostics = options.diagnostics ?? [];
+        this.referringElements = [...(options.referringElements ?? [])];
+        this.referrers = [...(options.referrers ?? [])];
+    }
+}
+/** An editor with no operations was applied. */
+export class NoEditsError extends EditError {
+}
+/** The element an edit names cannot carry that edit. */
+export class EditTargetError extends EditError {
+}
+/** The new value or name itself cannot be read. */
+export class InvalidEditError extends EditError {
+}
+/** A rename would break references to the renamed element. */
+export class RenameReferencedError extends EditError {
+}
+/** Two operations would edit the same bytes of the source. */
+export class OverlappingEditsError extends EditError {
+}
+/** The edited notation could not be read back. */
+export class EditResultError extends EditError {
+}
+/** An add-member owner is not declared in the model. */
+export class OwnerNotFoundError extends EditError {
+}
+/** An add-member owner cannot contain members. */
+export class OwnerNotNamespaceError extends EditError {
+}
+/** A declaration kind is invalid for the source language. */
+export class IllegalMemberKindError extends InvalidEditError {
+}
+/** An owner already declares the requested member name. */
+export class MemberNameTakenError extends EditError {
+}
+/** A referenced declaration is deleted without cascade. */
+export class DeleteReferencedError extends EditError {
+}
+/** A move's new owner is the moved declaration or inside it. */
+export class OwnerInsideTargetError extends EditError {
+}
+/** A move would leave a reference no spelling can restore. */
+export class MoveReferencedError extends EditError {
+}
+/** A rename, delete or move is referred to from a document the edit cannot rewrite. */
+export class ReferencedElsewhereError extends EditError {
+}

package/dist/core/exploration.d.ts

@@ -0,0 +1,71 @@
+import { type ModelDiagnostic, type UnsupportedValueError } from "./errors.js";
+import type { SysMLValue } from "./values.js";
+/** A value map an outcome reports: an action's outputs, a machine's final context. */
+export type OutcomeValues = ReadonlyMap<string, SysMLValue | UnsupportedValueError>;
+/** One distinct outcome an exploration reached. */
+export declare class Outcome {
+    /** The values the behavior holds at the end, by name; empty for a failed run. */
+    readonly outputs: OutcomeValues;
+    /** The state a state machine rests in; empty for an action. */
+    readonly finalState: string;
+    /** The states a state machine entered, in order. */
+    readonly statesVisited: readonly string[];
+    /** Why the run failed; empty for a run that completed. */
+    readonly error: string;
+    /** How many of the explored orders reached this outcome. */
+    readonly linearizations: number;
+    /** Share of the explored orders' likelihood reaching this outcome; a lower bound while incomplete. */
+    readonly probability: number;
+    /** The choices one run reaching it made, in run order; empty with no choice point. */
+    readonly witness: readonly string[];
+    /** What the witness run reported, its choice points among them. */
+    readonly diagnostics: readonly ModelDiagnostic[];
+    constructor(init: {
+        outputs: OutcomeValues;
+        finalState: string;
+        statesVisited: readonly string[];
+        error: string;
+        linearizations: number;
+        probability: number;
+        witness: readonly string[];
+        diagnostics: readonly ModelDiagnostic[];
+    });
+    /** Whether the runs reaching this outcome failed rather than completed. */
+    get failed(): boolean;
+    /** Raise the run's failure as an {@link ExecutionError}, if it failed. */
+    raiseForError(): this;
+    toString(): string;
+}
+/** Every distinct outcome a behavior reached under `explore`, and how the exploration ended. */
+export declare class Exploration {
+    /** The distinct outcomes reached, in the service's canonical order. */
+    readonly outcomes: readonly Outcome[];
+    /** Whether every linearization within the budget was run. */
+    readonly complete: boolean;
+    /** How many runs were made. */
+    readonly runs: number;
+    /** The budgets the exploration ran into; empty when complete. */
+    readonly budgetsHit: readonly string[];
+    /** The most runs the exploration would make. */
+    readonly runsBudget: number;
+    /** The most choice points one run would resolve. */
+    readonly depthBudget: number;
+    /** Whether the outcomes' probabilities are lower bounds. */
+    readonly probabilitiesLowerBound: boolean;
+    constructor(init: {
+        outcomes: readonly Outcome[];
+        complete: boolean;
+        runs: number;
+        budgetsHit: readonly string[];
+        runsBudget: number;
+        depthBudget: number;
+        probabilitiesLowerBound?: boolean;
+    });
+    get length(): number;
+    [Symbol.iterator](): Iterator<Outcome>;
+    /** How the exploration ended, as `sysml -schedule explore` prints it. */
+    get status(): string;
+    /** Raise an {@link ExecutionError} unless every linearization was run. */
+    raiseForIncomplete(): this;
+    toString(): string;
+}