simcapture-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,694 @@
+/**
+ * SimCapture responses are largely opaque — the OpenAPI contract marks most as
+ * `additionalProperties: true` because the old code only read a handful of
+ * fields. `Passthrough<T>` types the fields we rely on while preserving the
+ * rest, so callers keep access to everything the API returns.
+ */
+type Passthrough<T = Record<string, unknown>> = T & Record<string, unknown>;
+/** Fully opaque object response (no fields documented). */
+type Unknown = Record<string, unknown>;
+
+/** `GET /organizations` — one organization (tenant program/cohort). */
+type Organization = Passthrough<{
+    organizationId: string;
+    clientId: string;
+    name: string;
+    active: boolean;
+    inUse: boolean;
+    locked: boolean;
+    sort: number;
+}>;
+
+interface ScenarioLearningObjective {
+    description: string;
+    sort: number;
+}
+interface ScenarioAsset {
+    assetId: string;
+    clientId: string;
+    assetMimeTypeId: string;
+    name: string;
+    uri: string;
+    displayName: string;
+    description: string;
+    createdTs: string;
+    updatedTs: string;
+}
+/**
+ * `GET /scenarios/{id}` — one scenario. Many `canHave*` / `has*` boolean flags
+ * are returned; the listed fields cover the scalars callers read, and the
+ * `Passthrough` index signature preserves the rest.
+ */
+type Scenario = Passthrough<{
+    scenarioId: string;
+    clientId: string;
+    organizationId: string;
+    originatingScenarioId: string | null;
+    passingCutoffId: string | null;
+    active: boolean;
+    inUse: boolean;
+    privateTitle: string;
+    publicTitle: string | null;
+    overview: string | null;
+    setupInstructions: string;
+    /** Decimal string, e.g. `"0.000000"`. */
+    setupTimeMinutes: string;
+    takedownTimeMinutes: string;
+    recordingDeletionDays: number;
+    createdTs: string;
+    updatedTs: string;
+    acl: unknown[];
+    organization?: Organization;
+    simulators?: unknown[];
+    scenarioAnnotations?: unknown[];
+    learningObjectives?: ScenarioLearningObjective[];
+    courseItems?: Unknown[];
+    inventoryManagementItems?: unknown[];
+    assets?: ScenarioAsset[];
+    roles?: Unknown[];
+}>;
+interface ScenarioSetupUpdate {
+    setupInstructions?: string;
+    setupTimeMinutes?: number;
+    takedownTimeMinutes?: number;
+    inventoryManagementItems?: Unknown[];
+}
+interface ScenarioDetailsUpdate {
+    privateTitle?: string;
+    overview?: string;
+    learningObjectives?: (string | null)[];
+    canHaveSimulator?: boolean;
+    simulatorIds?: string[];
+    canHaveExamFlow?: boolean;
+    isParticipantDriven?: boolean;
+    isSelfRecorded?: boolean;
+}
+interface ScenarioAttachmentParams {
+    /** Tenant client id sent as `client-id` query param. */
+    clientId: string;
+}
+
+interface FindCoursesQuery {
+    count: boolean;
+    page: number;
+    active: boolean;
+    filters: {
+        organization?: string[];
+        [key: string]: unknown;
+    };
+}
+interface CourseOwner {
+    userId: string;
+    userName: string;
+    firstName: string;
+    middleName: string | null;
+    lastName: string;
+}
+/** One course row in the `POST /courses` page. */
+type CourseRow = Passthrough<{
+    courseId: string;
+    clientId: string;
+    privateTitle: string;
+    publicTitle: string | null;
+    overview: string | null;
+    active: boolean;
+    inUse: boolean;
+    createdTs: string;
+    updatedTs: string;
+    releaseStartTs: string | null;
+    releaseEndTs: string | null;
+    courseStatusId?: string;
+    organizationId?: string;
+    owner: CourseOwner;
+    organization: {
+        organizationId: string;
+        name: string;
+    };
+    courseStatus: {
+        courseStatusId: string;
+        courseStatusRef: string;
+        active: boolean;
+    };
+    acl: unknown[];
+}>;
+interface CoursesPage {
+    rows: CourseRow[];
+    count?: number;
+    [key: string]: unknown;
+}
+interface CourseItemsParams {
+    includeScenarios?: boolean;
+    includeEvaluationTemplates?: boolean;
+    hasScenarioReflections?: boolean;
+    hasScenarioEvaluations?: boolean;
+}
+/** One entry of `GET /courses/{id}/items`. */
+type CourseItem = Passthrough<{
+    clientId: string;
+    courseId: string;
+    courseItemId: string;
+    evaluationTemplateId: string | null;
+    scenarioId: string | null;
+    sortPosition: number;
+    evaluationTemplate: unknown | null;
+    scenario: Scenario | null;
+}>;
+/** `GET /courses/{id}/items` returns an array of course items. */
+type CourseItems = CourseItem[];
+
+/** Which SimCapture server a request targets. */
+type SimCaptureServer = "api" | "inventory";
+interface HttpRequest {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    /** Path relative to the target server's base URL, e.g. `/reservations`. */
+    path: string;
+    server?: SimCaptureServer;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    /** Extra headers merged on top of the auth token header. */
+    headers?: Record<string, string>;
+    /** When true the auth token header is NOT attached (used for `/auth`). */
+    skipAuth?: boolean;
+    /** Response payload type; `blob` is used for attachment downloads. */
+    responseType?: "json" | "blob";
+}
+interface HttpResponse<T> {
+    status: number;
+    data: T;
+}
+/**
+ * Transport port. The domain/application layers depend on this interface, not
+ * axios — which keeps them framework-free and trivially testable with fakes.
+ */
+interface HttpClient {
+    request<T>(req: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+/**
+ * Immutable login credentials. `clientSubdomain` defaults to the UPCH tenant
+ * (`simulacion-upch`), matching what the old services hard-coded.
+ */
+declare class AuthCredentials {
+    static readonly DEFAULT_SUBDOMAIN = "simulacion-upch";
+    readonly username: string;
+    readonly password: string;
+    readonly clientSubdomain: string;
+    constructor(params: {
+        username: string;
+        password: string;
+        clientSubdomain?: string;
+    });
+    toAuthRequest(): {
+        username: string;
+        password: string;
+        clientSubdomain: string;
+    };
+}
+
+/**
+ * SimCapture session token.
+ *
+ * `POST /auth` returns only `{ token }` with no expiry, so we apply a *soft* TTL
+ * to proactively refresh before the server would reject it. The authoritative
+ * invalidation remains the 401 path (see Authenticator). `ttlMs <= 0` disables
+ * the soft expiry and the token is reused until a 401.
+ */
+declare class Token {
+    readonly value: string;
+    /** Epoch ms after which the token is considered stale, or null when no TTL. */
+    readonly expiresAt: number | null;
+    constructor(value: string, expiresAt?: number | null);
+    static issue(value: string, ttlMs: number, now?: number): Token;
+    isExpired(now?: number): boolean;
+}
+
+/**
+ * Caches the active session token. Default impl is in-memory; the port lets a
+ * consumer swap in a shared store (e.g. Redis) if several instances must reuse
+ * one SimCapture session.
+ */
+interface TokenStore {
+    get(): Token | null;
+    set(token: Token): void;
+    clear(): void;
+}
+
+interface AuthenticatorOptions {
+    http: HttpClient;
+    store: TokenStore;
+    credentials: AuthCredentials;
+    tokenTtlMs: number;
+    now?: () => number;
+}
+/**
+ * Owns the SimCapture session. Fixes the old "login on every call" anti-pattern:
+ *
+ *  - tokens are cached and reused until the soft TTL elapses or a 401 occurs;
+ *  - concurrent callers share a single in-flight `/auth` request;
+ *  - on 401 the token is cleared, re-issued **once**, and the request retried once.
+ */
+declare class Authenticator {
+    private readonly http;
+    private readonly store;
+    private readonly credentials;
+    private readonly tokenTtlMs;
+    private readonly now;
+    private inFlightLogin;
+    constructor(options: AuthenticatorOptions);
+    /** Returns a valid token, logging in only when none is cached or it is stale. */
+    getToken(): Promise<Token>;
+    /** Forces a fresh login, deduping concurrent calls into one `/auth` request. */
+    login(): Promise<Token>;
+    /**
+     * Sends `req` with the cached token attached. On a 401 it refreshes the token
+     * once and retries the request a single time; a second 401 propagates.
+     */
+    authorizedRequest<T>(req: HttpRequest): Promise<HttpResponse<T>>;
+    private requestToken;
+}
+
+/** Shared base: every resource sends authorized requests through the Authenticator. */
+declare abstract class BaseResource {
+    protected readonly auth: Authenticator;
+    protected constructor(auth: Authenticator);
+    protected exec<T>(req: HttpRequest): Promise<T>;
+}
+
+declare class CoursesResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `POST /courses` — one page of results. */
+    find(query: FindCoursesQuery): Promise<CoursesPage>;
+    /** `GET /courses/{courseId}/items` — scenarios / evaluation templates. */
+    getItems(courseId: string, params?: CourseItemsParams): Promise<CourseItems>;
+}
+
+/** `GET /items` and `GET /item/{id}` (inventory server) — one inventory item. */
+type InventoryItem = Passthrough<{
+    itemId: string;
+    name: string;
+    clientId: string;
+    isConsumable: boolean;
+    isArchived: boolean;
+    quantity: number;
+    lowStockQuantity: number;
+    /** Decimal string, e.g. `"80.51"`. */
+    cost: string | null;
+    locationId: string | null;
+    manufacturer: string | null;
+    modelNumber: string | null;
+    supplier: string | null;
+    purchaseDate: string | null;
+    notes: string | null;
+    imageId: string | null;
+    createdTs: string;
+    updatedTs: string;
+    inUse: boolean;
+}>;
+interface InventoryItemEdit {
+    name?: string;
+    isConsumable?: boolean;
+    quantity?: number;
+    lowStockQuantity?: number;
+    locationId?: string;
+    manufacturer?: string;
+    modelNumber?: string;
+    supplier?: string;
+    purchaseDate?: string;
+    cost?: number;
+    notes?: string;
+    imageId?: string;
+}
+
+/** Inventory subsystem — every call targets server B (`inventoryUrl`). */
+declare class InventoryResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `GET /items` (server B) */
+    findAll(): Promise<InventoryItem[]>;
+    /** `GET /item/{itemId}` (server B) */
+    findOne(itemId: string): Promise<InventoryItem>;
+    /** `POST /item/{itemId}/edit` (server B) — stock adjustment. */
+    edit(itemId: string, body: InventoryItemEdit): Promise<InventoryItem>;
+}
+
+/** `GET /locations` — one physical location/room. */
+type Location = Passthrough<{
+    locationId: string;
+    clientId: string;
+    name: string;
+    active: boolean;
+    inUse: boolean;
+    sort: number;
+    parentLocationId: string | null;
+    captureHostId: string | null;
+}>;
+interface ListLocationsParams {
+    /** e.g. `sort` — matches the existing `?order=sort` call. */
+    order?: string;
+}
+
+declare class LocationsResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `GET /locations?order=...` */
+    findAll(params?: ListLocationsParams): Promise<Location[]>;
+}
+
+interface NotificationRequest {
+    recipients: string[];
+    notification: {
+        subject?: string;
+        body?: string;
+    };
+}
+
+declare class NotificationsResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `POST /notifications` — send an email / notification. */
+    send(body: NotificationRequest): Promise<void>;
+}
+
+declare class OrganizationsResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `GET /organizations` */
+    findAll(): Promise<Organization[]>;
+}
+
+interface ReservationLocation {
+    locationId: string;
+    clientId: string;
+    name: string;
+    parentLocationId: string | null;
+    sort: number;
+    active: boolean;
+    captureHostId: string | null;
+}
+interface ReservationCourseRef {
+    courseId: string;
+    publicTitle: string | null;
+    privateTitle: string;
+    active: boolean;
+    acl?: unknown[];
+}
+interface ReservationScenarioRef {
+    scenarioId: string;
+    publicTitle: string | null;
+    privateTitle: string;
+    active: boolean;
+    acl?: unknown[];
+}
+/** `GET /reservations` and `GET /reservation/{id}` — one reservation. */
+type Reservation = Passthrough<{
+    reservationId: string;
+    clientId: string;
+    organizationId: string;
+    ownerUserId: string;
+    title: string;
+    publicNotes: string;
+    /** May embed JSON inside `<{...}>`. */
+    privateNotes: string;
+    startTs: string;
+    endTs: string;
+    /** Decimal string, e.g. `"0.000000"`. */
+    setupTimeMinutes: string;
+    takedownTimeMinutes: string;
+    setupInstructions: string;
+    color: string;
+    reservationRequestId: string | null;
+    isSelfEnroll: boolean;
+    expectedNumberOfParticipants: number;
+    shouldConsumeInvByRes: boolean;
+    seriesId: string | null;
+    locations: ReservationLocation[];
+    simulators: Passthrough[];
+    courses: ReservationCourseRef[];
+    scenarios: ReservationScenarioRef[];
+    organization: Passthrough<{
+        organizationId: string;
+        clientId: string;
+    }>;
+    supportStaff: unknown[];
+    users: unknown[];
+    selfEnrollments: unknown[] | null;
+    /** Present only in the list response. */
+    inventoryManagementItems?: unknown[];
+}>;
+interface ListReservationsParams {
+    /** ISO-8601 timestamp; only reservations ending after this are returned. */
+    endAfterTs: string;
+    /** ISO-8601 timestamp; only reservations starting before this are returned. */
+    startBeforeTs: string;
+    /** `false` fetches the full reservation detail. Defaults to `false`. */
+    limitFetchedReservationDetails?: boolean;
+}
+interface ReservationOverviewUpdate {
+    reservationColor?: string;
+    reservationTitle?: string;
+    locationIds?: string[];
+    reservationStartTs?: string;
+    reservationEndTs?: string;
+    [key: string]: unknown;
+}
+interface ReservationSetupUpdate {
+    reservationSetupInstructions?: string;
+    reservationSetupTimeMinutes?: number;
+    reservationTakedownTimeMinutes?: number;
+    inventoryManagementItems?: Unknown[];
+    shouldConsumeInvByRes?: boolean;
+    reservationPrivateNotes?: string;
+    simulatorIds?: string[];
+}
+/** Body for `PUT /reservation/{id}` — either an overview or a setup update. */
+type ReservationUpdate = ReservationOverviewUpdate | ReservationSetupUpdate;
+/** Body for `PUT /reservation/{id}/details` (ENGINEERING-MS flow). */
+interface ReservationDetailsUpdate {
+    organizationId?: string;
+    simulators?: Unknown[];
+    expectedNumberOfParticipants?: number;
+    privateNotes?: string;
+}
+
+declare class ReservationsResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `GET /reservations?endAfterTs=&startBeforeTs=&limitFetchedReservationDetails=` */
+    findAll(params: ListReservationsParams): Promise<Reservation[]>;
+    /** `GET /reservation/{id}` */
+    findOne(reservationId: string): Promise<Reservation>;
+    /** `PUT /reservation/{id}` — overview or setup update. */
+    update(reservationId: string, body: ReservationUpdate): Promise<Reservation>;
+    /** `PUT /reservation/{id}/details` (ENGINEERING-MS flow). */
+    updateDetails(reservationId: string, body: ReservationDetailsUpdate): Promise<Reservation>;
+    /** `DELETE /reservation/{id}` */
+    delete(reservationId: string): Promise<void>;
+}
+
+declare class ScenariosResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `GET /scenarios/{id}` */
+    findOne(scenarioId: string): Promise<Scenario>;
+    /** `PUT /scenarios/{id}` — setup update. */
+    updateSetup(scenarioId: string, body: ScenarioSetupUpdate): Promise<Scenario>;
+    /** `PUT /scenarios/{id}/details` — detail update. */
+    updateDetails(scenarioId: string, body: ScenarioDetailsUpdate): Promise<Scenario>;
+    /**
+     * `GET /scenarios/{id}/attachments/{assetName}` — returns the raw PDF bytes.
+     * The token is sent both as a query param and the header (matching the API).
+     */
+    getAttachment(scenarioId: string, assetName: string, params: ScenarioAttachmentParams): Promise<ArrayBuffer>;
+}
+
+/** `GET /simulators` and `GET /simulators/{id}` — one simulator/equipment unit. */
+type Simulator = Passthrough<{
+    simulatorId: string;
+    simulatorExternalId: string;
+    clientId: string;
+    name: string;
+    active: boolean;
+    inUse: boolean;
+    applicationId: string | null;
+    /** Stringified JSON, e.g. `{"estado":"OPERATIVO","qr":true}`. */
+    notes: string;
+}>;
+interface SimulatorModel {
+    simulatorModelId: string;
+    name: string;
+    configOptions: SimulatorConfigOption[];
+    simulatorCompany: {
+        simulatorCompanyId: string;
+        name: string;
+    };
+}
+/** `GET /simulator-configs/{id}` — simulator plus its model/config metadata. */
+type SimulatorConfig = Passthrough<{
+    simulatorId: string;
+    simulatorExternalId: string;
+    clientId: string;
+    name: string;
+    active: boolean;
+    notes: string;
+    simulatorModel: SimulatorModel;
+    configOptions: SimulatorConfigOption[];
+}>;
+interface SimulatorConfigOption {
+    key: string;
+    value: string;
+}
+interface SimulatorUpdate {
+    name?: string;
+    notes?: string;
+    simulatorModelId?: string;
+    configOptions?: SimulatorConfigOption[];
+}
+
+declare class SimulatorsResource extends BaseResource {
+    constructor(auth: Authenticator);
+    /** `GET /simulators` */
+    findAll(): Promise<Simulator[]>;
+    /** `GET /simulators/{id}` */
+    findOne(simulatorId: string): Promise<Simulator>;
+    /** `PUT /simulators/{id}` */
+    update(simulatorId: string, body: SimulatorUpdate): Promise<Simulator>;
+    /** `GET /simulator-configs/{id}` */
+    getConfig(simulatorId: string): Promise<SimulatorConfig>;
+}
+
+interface SimCaptureConfig {
+    /** Main API base URL, e.g. `https://api.simcapture.com`. */
+    apiUrl: string;
+    /** Inventory subsystem base URL (server B). */
+    inventoryUrl: string;
+    credentials: {
+        username: string;
+        password: string;
+        /** Defaults to `simulacion-upch`. */
+        clientSubdomain?: string;
+    };
+    /**
+     * Soft token TTL in ms. The token is proactively refreshed once stale; a 401
+     * still forces a refresh regardless. `0` disables the soft TTL.
+     * Default: 30 minutes.
+     */
+    tokenTtlMs?: number;
+    /** Per-request timeout in ms. Default: 30s. */
+    timeoutMs?: number;
+}
+declare const SIMCAPTURE_DEFAULTS: {
+    readonly apiUrl: "https://api.simcapture.com";
+    readonly inventoryUrl: "https://inventory-management-production.us-east-1.simcapture.com";
+    readonly tokenTtlMs: number;
+    readonly timeoutMs: number;
+};
+interface ResolvedSimCaptureConfig {
+    apiUrl: string;
+    inventoryUrl: string;
+    credentials: {
+        username: string;
+        password: string;
+        clientSubdomain?: string;
+    };
+    tokenTtlMs: number;
+    timeoutMs: number;
+}
+/** Fills defaults and fails fast on missing required values. */
+declare function resolveConfig(config: SimCaptureConfig): ResolvedSimCaptureConfig;
+
+interface SimCaptureClientDeps {
+    /** Override the transport (e.g. for tests). Defaults to AxiosHttpClient. */
+    httpClient?: HttpClient;
+    /** Override the token cache. Defaults to InMemoryTokenStore. */
+    tokenStore?: TokenStore;
+    /** Override the clock (tests). */
+    now?: () => number;
+}
+/**
+ * Single entrypoint to SimCapture. Wires the infrastructure adapters into the
+ * application use-cases (composition root) and exposes one resource per domain.
+ *
+ * ```ts
+ * const sc = new SimCaptureClient({
+ *   apiUrl: process.env.SIMCAPTURE_API!,
+ *   inventoryUrl: process.env.SIMCAPTURE_INVENTORY_API!,
+ *   credentials: { username: process.env.SIMCAPTURE_USER!, password: process.env.SIMCAPTURE_PASSWORD! },
+ * });
+ * const orgs = await sc.organizations.findAll();
+ * ```
+ */
+declare class SimCaptureClient {
+    readonly organizations: OrganizationsResource;
+    readonly locations: LocationsResource;
+    readonly reservations: ReservationsResource;
+    readonly courses: CoursesResource;
+    readonly scenarios: ScenariosResource;
+    readonly simulators: SimulatorsResource;
+    readonly notifications: NotificationsResource;
+    readonly inventory: InventoryResource;
+    private readonly authenticator;
+    constructor(config: SimCaptureConfig, deps?: SimCaptureClientDeps);
+    /** Force a fresh login. Rarely needed — auth is handled lazily per request. */
+    login(): Promise<void>;
+    /** Returns a valid session token, logging in only if none is cached. */
+    getToken(): Promise<{
+        token: string;
+    }>;
+}
+
+/**
+ * Error raised when a SimCapture request fails. Unlike the old per-service
+ * `RpcException({ status: 400 })`, this preserves the real upstream HTTP status
+ * and response body so callers can translate it faithfully.
+ */
+declare class SimCaptureError extends Error {
+    /** HTTP status returned by SimCapture, or 0 when the request never completed. */
+    readonly status: number;
+    /** Stable machine-readable code for branching (e.g. `AUTH_FAILED`). */
+    readonly code: SimCaptureErrorCode;
+    /** Raw upstream response body, when available. */
+    readonly body: unknown;
+    constructor(params: {
+        message: string;
+        status: number;
+        code: SimCaptureErrorCode;
+        body?: unknown;
+        cause?: unknown;
+    });
+}
+type SimCaptureErrorCode = "AUTH_FAILED" | "UNAUTHORIZED" | "NETWORK" | "UPSTREAM_ERROR" | "CONFIG_INVALID";
+
+interface AxiosHttpClientOptions {
+    apiUrl: string;
+    inventoryUrl: string;
+    timeoutMs: number;
+}
+/**
+ * Transport adapter. Pure request/response over two axios instances (main API +
+ * inventory server). It is auth-agnostic: the caller decides whether a token
+ * header is attached. Upstream failures are normalised into `SimCaptureError`
+ * preserving the real status and body.
+ */
+declare class AxiosHttpClient implements HttpClient {
+    private readonly instances;
+    constructor(options: AxiosHttpClientOptions);
+    request<T>(req: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+/** Default token store: keeps the active token in process memory. */
+declare class InMemoryTokenStore implements TokenStore {
+    private token;
+    get(): Token | null;
+    set(token: Token): void;
+    clear(): void;
+}
+
+interface AuthRequest {
+    username: string;
+    password: string;
+    clientSubdomain: string;
+}
+/** `POST /auth` response. Only `token` is consumed by the authenticator. */
+interface AuthResponse {
+    token: string;
+    clientId?: string;
+    userId?: string;
+    name?: string;
+    institutionName?: string;
+}
+
+export { AuthCredentials, type AuthRequest, type AuthResponse, Authenticator, AxiosHttpClient, type CourseItem, type CourseItems, type CourseItemsParams, type CourseOwner, type CourseRow, type CoursesPage, CoursesResource, type FindCoursesQuery, type HttpClient, type HttpRequest, type HttpResponse, InMemoryTokenStore, type InventoryItem, type InventoryItemEdit, InventoryResource, type ListLocationsParams, type ListReservationsParams, type Location, LocationsResource, type NotificationRequest, NotificationsResource, type Organization, OrganizationsResource, type Passthrough, type Reservation, type ReservationCourseRef, type ReservationDetailsUpdate, type ReservationLocation, type ReservationOverviewUpdate, type ReservationScenarioRef, type ReservationSetupUpdate, type ReservationUpdate, ReservationsResource, type ResolvedSimCaptureConfig, SIMCAPTURE_DEFAULTS, type Scenario, type ScenarioAsset, type ScenarioAttachmentParams, type ScenarioDetailsUpdate, type ScenarioLearningObjective, type ScenarioSetupUpdate, ScenariosResource, SimCaptureClient, type SimCaptureClientDeps, type SimCaptureConfig, SimCaptureError, type SimCaptureErrorCode, type SimCaptureServer, type Simulator, type SimulatorConfig, type SimulatorConfigOption, type SimulatorModel, type SimulatorUpdate, SimulatorsResource, Token, type TokenStore, type Unknown, resolveConfig };