@playcademy/sdk 0.20.1-beta.1 → 0.20.1-beta.3

package/dist/index.d.ts

@@ -1,9 +1,3 @@
-import * as _playcademy_types from '@playcademy/types';
-import { LocalDayContext } from '@playcademy/types';
-import { TimebackGrade, TimebackSubject, ELevel, ChildEndActivityScoreData, EndActivityRequest, HeartbeatRequest, EndActivityScoreData, EndActivityResponse } from '@playcademy/types/timeback';
-import { TimebackUserRole, UserEnrollment, UserOrganization, UserInfo } from '@playcademy/types/user';
-import { AUTH_PROVIDER_IDS } from '@playcademy/constants';
-
 /**
  * Base error class for Cademy SDK specific errors.
  */
@@ -174,6 +168,1188 @@ interface RetryPolicy {
     retryDelaysMs?: readonly number[];
 }
 
+/**
+ * Authentication Constants
+ *
+ * Constants related to authentication providers.
+ */
+/**
+ * Auth Provider Constants
+ */
+declare const AUTH_PROVIDER_IDS: {
+    readonly TIMEBACK: 'timeback';
+    readonly TIMEBACK_LTI: 'timeback-lti';
+    readonly PLAYCADEMY: 'playcademy';
+};
+/**
+ * Platform user roles.
+ */
+declare const USER_ROLES: {
+    readonly ADMIN: 'admin';
+    readonly PLAYER: 'player';
+    readonly DEVELOPER: 'developer';
+    readonly TEACHER: 'teacher';
+};
+type UserRole = (typeof USER_ROLES)[keyof typeof USER_ROLES];
+
+/**
+ * Valid grade levels per AE OneRoster GradeEnum.
+ * -1 = Pre-K, 0 = Kindergarten, 1-12 = Grades 1-12, 13 = AP
+ */
+declare const TIMEBACK_GRADES: readonly [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
+/**
+ * The TimeBack subject vocabulary, carried on courses, activity data, and
+ * Caliper events alike. 'None' is canonical: TimeBack accepts it as a course
+ * subject and uses it as the fallback for unknown or missing subjects.
+ */
+declare const TIMEBACK_SUBJECTS: readonly ['Reading', 'Language', 'Vocabulary', 'Social Studies', 'Writing', 'Science', 'FastMath', 'Math', 'None'];
+/**
+ * Playcademy's course-specific meaning for reusable QTI test content.
+ * Result writers translate this to OneRoster assessment-result
+ * `metadata.testType`; it intentionally does not become metadata on the QTI
+ * test itself.
+ */
+declare const ASSESSMENT_PURPOSES: readonly ['end_of_course', 'diagnostic', 'review', 'mastery'];
+/**
+ * Schema version of the playable assessment payload handed to a game.
+ *
+ * Distinct from an assessment's content revision: this identifies the shape of
+ * the contract, not the content inside it. Bumped when the payload gains a
+ * field or changes the meaning of one — never for content edits.
+ *
+ * Intended for diagnostics and for telling "this host does not support the
+ * field" apart from "this item does not use it". Games should branch on whether
+ * a field is present, not on this number: the content vocabularies are open by
+ * design, so feature detection keeps working across versions where a comparison
+ * does not.
+ */
+declare const PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION: 2;
+
+/**
+ * User Types
+ *
+ * Enums, DTOs and API response types. Database row types are in @playcademy/data/types.
+ *
+ * @module types/user
+ */
+
+type UserRoleEnumType = UserRole;
+type DeveloperStatusEnumType = 'none' | 'pending' | 'approved';
+type TimebackUserRole = 'administrator' | 'aide' | 'guardian' | 'parent' | 'proctor' | 'relative' | 'student' | 'teacher';
+type TimebackOrgType = 'department' | 'school' | 'district' | 'local' | 'state' | 'national';
+interface UserEnrollment {
+    gameId?: string;
+    courseId: string;
+    id?: string;
+    grade: number;
+    subject: string;
+    orgId?: string;
+}
+interface UserOrganization {
+    id: string;
+    name: string | null;
+    type: TimebackOrgType | string;
+    isPrimary: boolean;
+}
+interface TimebackStudentProfile {
+    role: TimebackUserRole;
+    organizations: UserOrganization[];
+}
+interface UserTimebackData extends TimebackStudentProfile {
+    id: string;
+    enrollments: UserEnrollment[];
+}
+type LocalDaySource = 'browser_last_seen' | 'platform_default';
+interface LocalDayContext {
+    timeZone: string;
+    source: LocalDaySource;
+    /** ISO 8601 timestamp for the last persisted timezone observation. */
+    observedAt: string | null;
+}
+/**
+ * OpenID Connect UserInfo claims (NOT a database row).
+ */
+interface UserInfo {
+    sub: string;
+    email: string;
+    name: string | null;
+    email_verified?: boolean;
+    given_name?: string;
+    family_name?: string;
+    issuer?: string;
+    lti_roles?: unknown;
+    lti_context?: unknown;
+    lti_resource_link?: unknown;
+    timeback_id?: string;
+}
+interface DemoProfile {
+    displayName: string;
+    isDefault: boolean;
+}
+/**
+ * Update shape for `client.demo.profile.update(...)`.
+ *
+ * Kept as a named type so callers typed against it pick up new fields
+ * automatically, but `displayName` is the only updatable field today and
+ * the server's `DemoProfileSchema` requires it — a no-field payload would
+ * 400 at runtime, so we model that at the type level too. When additional
+ * fields land, make them required/optional individually based on server
+ * validation, rather than blanket-optional.
+ */
+interface DemoProfileUpdate {
+    displayName: string;
+}
+/**
+ * Authenticated user for API responses.
+ * Differs from UserRow: omits timebackId, adds hasTimebackAccount and timeback.
+ */
+interface AuthenticatedUser {
+    id: string;
+    email: string;
+    emailVerified: boolean;
+    name: string | null;
+    image: string | null;
+    username: string | null;
+    role: UserRoleEnumType;
+    developerStatus: DeveloperStatusEnumType;
+    createdAt: Date;
+    updatedAt: Date;
+    hasTimebackAccount: boolean;
+    localDay: LocalDayContext;
+    timeback?: UserTimebackData;
+}
+
+/**
+ * Leaderboard Types
+ *
+ * @module types/leaderboard
+ */
+type LeaderboardTimeframe = 'all_time' | 'monthly' | 'weekly' | 'daily';
+interface LeaderboardOptions {
+    timeframe?: LeaderboardTimeframe;
+    limit?: number;
+    offset?: number;
+    gameId?: string;
+}
+/**
+ * Leaderboard entry with required game context.
+ * Used when fetching leaderboards for a specific game.
+ */
+interface GameLeaderboardEntry {
+    rank: number;
+    userId: string;
+    username: string;
+    userImage?: string | null;
+    score: number;
+    achievedAt: Date;
+    metadata?: Record<string, unknown>;
+    gameId: string;
+    gameTitle: string;
+    gameSlug: string;
+}
+
+/**
+ * TimeBack Enums & Literal Types
+ *
+ * Basic type definitions used throughout the TimeBack integration. Unions
+ * derive from the canonical value lists in @playcademy/constants (type-only
+ * imports, so this package ships no runtime code).
+ *
+ * @module types/timeback/types
+ */
+
+/**
+ * The TimeBack subject vocabulary. 'None' is canonical: TimeBack accepts it
+ * on courses and uses it as the fallback for unknown or missing subjects.
+ */
+type TimebackSubject = (typeof TIMEBACK_SUBJECTS)[number];
+/**
+ * Grade levels per AE OneRoster GradeEnum.
+ * -1 = Pre-K, 0 = Kindergarten, 1-12 = Grades 1-12, 13 = AP
+ */
+type TimebackGrade = (typeof TIMEBACK_GRADES)[number];
+/**
+ * Platform pedagogy levels for a single lesson of instruction.
+ * E1 teaches, E2/E3 practice and remediate, E4 is the mastery check.
+ */
+type ELevel = 'E1' | 'E2' | 'E3' | 'E4';
+/**
+ * Valid Caliper subject values. The same vocabulary as OneRoster subjects.
+ */
+type CaliperSubject = (typeof TIMEBACK_SUBJECTS)[number];
+
+/**
+ * TimeBack Client SDK DTOs
+ *
+ * Data transfer objects for the TimeBack client SDK including
+ * progress tracking, session management, and activity completion.
+ *
+ * Note: TimebackClientConfig lives in @playcademy/timeback as it's
+ * SDK configuration, not a DTO.
+ *
+ * @module types/timeback/client
+ */
+
+/**
+ * Known extensions for TimeBack Activity Metrics Collection
+ */
+interface TimebackActivityExtensions {
+    /** Percentage complete (0-100) for the app course */
+    pctCompleteApp?: number;
+    /** Allow other arbitrary extensions */
+    [key: string]: unknown;
+}
+interface MasteryWriteWarning {
+    code: 'MASTERY_WRITE_CAPPED';
+    message: string;
+    currentMasteredUnits: number;
+    attemptedMasteredUnits: number;
+    appliedMasteredUnits: number;
+    storedMasteredUnits: number;
+    masterableUnits: number;
+}
+/**
+ * Activity data for ending an activity
+ */
+interface ActivityData {
+    /** Unique activity identifier (required) */
+    activityId: string;
+    /** Grade level for this activity (required for multi-grade course routing) */
+    grade: number;
+    /** Subject area (required for multi-grade course routing) */
+    subject: CaliperSubject;
+    /** Activity display name (optional) */
+    activityName?: string;
+    /** Course identifier (auto-filled from config if not provided) */
+    courseId?: string;
+    /** Course display name (auto-filled from config if not provided) */
+    courseName?: string;
+    /** Student email address (optional) */
+    studentEmail?: string;
+    /** Application name for Caliper events (defaults to 'Game') */
+    appName?: string;
+    /** Sensor URL for Caliper events (defaults to baseUrl) */
+    sensorUrl?: string;
+}
+/**
+ * Score data for ending an activity from a child-launched game: the same
+ * shape as `EndActivityScoreData` with `xpAwarded` optional. The parent
+ * game decides the actual award; a provided value is only a suggestion.
+ * The SDK's `isChildLaunched()` narrows `client.timeback.endActivity()`
+ * to accept this shape.
+ */
+type ChildEndActivityScoreData = Omit<EndActivityScoreData, 'xpAwarded'> & {
+    /** Optional XP suggestion for the parent. */
+    xpAwarded?: number;
+};
+/**
+ * Score data for ending an activity
+ */
+interface EndActivityScoreData {
+    /** Number of questions answered correctly */
+    correctQuestions: number;
+    /** Total number of questions */
+    totalQuestions: number;
+    /**
+     * XP earned for this activity.
+     *
+     * Required when the game reports directly (platform, demo, standalone).
+     * A child-launched game may omit it: narrow the client with the SDK's
+     * `isChildLaunched()` for the relaxed signature. The parent game
+     * decides the award, and a value provided here travels only as the
+     * `childXpSuggested` audit suggestion.
+     */
+    xpAwarded: number;
+    /**
+     * Incremental learning units mastered this session.
+     *
+     * Cannot be used with masteredUnitsAbsolute. When a course has mastery
+     * tracking configured, the platform bounds submissions that would move
+     * the student below 0 or above the configured masterableUnits maximum and
+     * returns warning metadata.
+     */
+    masteredUnits?: number;
+    /**
+     * Absolute total of mastered units.
+     *
+     * The platform computes the delta from the current value. Cannot be used
+     * with masteredUnits. When a course has mastery tracking configured, the
+     * platform bounds values outside 0..masterableUnits and returns warning
+     * metadata.
+     */
+    masteredUnitsAbsolute?: number;
+    /** Optional arbitrary extensions to include in the Caliper event */
+    extensions?: TimebackActivityExtensions;
+}
+
+/**
+ * TimeBack API Request/Response Types
+ *
+ * Types for TimeBack API endpoints including XP tracking,
+ * setup, verification, and activity completion.
+ *
+ * @module types/timeback/api
+ */
+
+interface HeartbeatRequestBase {
+    gameId: string;
+    studentId: string;
+    runId: string;
+    /**
+     * Per-session identifier.
+     *
+     * LEGACY SDK COMPATIBILITY (PR #711): optional because games deployed
+     * against the pre-resumable-sessions SDK do not send one. The
+     * platform falls back to `runId` when absent. Make this required
+     * once legacy SDK support is dropped.
+     */
+    resumeId?: string;
+    activityData: {
+        activityId: string;
+        activityName?: string;
+        grade: TimebackGrade;
+        subject: TimebackSubject;
+        appName?: string;
+        sensorUrl?: string;
+        courseId?: string;
+        courseName?: string;
+        studentEmail?: string;
+    };
+    timingData: {
+        activeMs: number;
+        pausedMs: number;
+    };
+    isFinal?: boolean;
+}
+type HeartbeatWindowKey = {
+    /**
+     * Absolute start-of-window timestamp (epoch ms). Preferred dedupe key
+     * for the post-#711 SDK.
+     *
+     * LEGACY SDK COMPATIBILITY (PR #711): callers must provide exactly
+     * one of this field or `windowSequence`. Make this the only allowed
+     * field once legacy SDK support is dropped.
+     */
+    windowStartedAtMs: number;
+    windowSequence?: never;
+} | {
+    windowStartedAtMs?: never;
+    /**
+     * LEGACY SDK COMPATIBILITY (PR #711).
+     *
+     * Monotonic window counter emitted by the pre-resumable-sessions
+     * SDK. Remove this field once every deployed game has redeployed
+     * against the post-#711 SDK + edge-play runtime.
+     */
+    windowSequence: number;
+};
+type HeartbeatRequest = HeartbeatRequestBase & HeartbeatWindowKey;
+interface EndActivityRequest {
+    gameId: string;
+    studentId: string;
+    runId?: string;
+    /**
+     * Per-session identifier.
+     *
+     * LEGACY SDK COMPATIBILITY (PR #711): optional because games deployed
+     * against the pre-resumable-sessions SDK do not send one. The
+     * platform falls back to `runId`, or mints a server-side UUID, when
+     * absent. Make this required once legacy SDK support is dropped.
+     */
+    resumeId?: string;
+    activityData: {
+        activityId: string;
+        activityName?: string;
+        grade: TimebackGrade;
+        subject: TimebackSubject;
+        appName?: string;
+        sensorUrl?: string;
+        courseId?: string;
+        courseName?: string;
+        studentEmail?: string;
+    };
+    scoreData: {
+        correctQuestions: number;
+        totalQuestions: number;
+    };
+    timingData: {
+        durationSeconds: number;
+    };
+    sessionTimingData?: {
+        activeSeconds: number;
+        inactiveSeconds?: number;
+    };
+    xpEarned: number;
+    masteredUnits?: number;
+    masteredUnitsAbsolute?: number;
+    extensions?: TimebackActivityExtensions;
+}
+type TimebackPromotionStatus = 'promoted' | 'no-next-course' | 'already-promoted' | 'not-enrolled' | 'not-mastered';
+interface TimebackPromotionResult {
+    status: TimebackPromotionStatus;
+    currentCourseId: string;
+    nextCourseId?: string;
+    masteredUnits?: number;
+    masterableUnits?: number;
+}
+interface EndActivityResponse {
+    status: 'ok';
+    courseId: string;
+    xpAwarded: number;
+    masteredUnits?: number;
+    pctCompleteApp?: number;
+    warnings?: MasteryWriteWarning[];
+    /**
+     * Set when this submission was stopped because a completion for the same
+     * run (`runId`) and activity had already been recorded — the platform's
+     * idempotency guard blocked a duplicate emit (PLA-142). This call awarded
+     * nothing new, but the award may well have happened: if the original
+     * response was lost in transit (e.g. a gateway timeout followed by an SDK
+     * retry), this is the only response the caller ever sees for a run that
+     * fully succeeded. The response therefore echoes what the run earned —
+     * `xpAwarded`, `masteredUnits`, and `pctCompleteApp` are the values
+     * recorded when the completion was confirmed (zeros, with no
+     * `pctCompleteApp`, only for runs recorded before award echoing existed).
+     * Treat it as "already recorded — here's what it earned", and do not
+     * count the run again.
+     */
+    blockedByDedupeGuard?: boolean;
+}
+interface AdvanceCourseResponse {
+    status: 'ok';
+    promotion: TimebackPromotionResult;
+}
+type TimebackUnenrollmentStatus = 'unenrolled' | 'not-mastered';
+interface TimebackUnenrollmentResult {
+    status: TimebackUnenrollmentStatus;
+    currentCourseId: string;
+    masteredUnits?: number;
+    masterableUnits?: number;
+    forced?: boolean;
+}
+interface UnenrollCourseResponse {
+    status: 'ok';
+    unenrollment: TimebackUnenrollmentResult;
+}
+
+declare const DIAGNOSTIC_TRACK_OUTCOMES: readonly ['provisional', 'unresolved', 'route-to-instruction', 'not-assessed'];
+type DiagnosticTrackOutcome = (typeof DIAGNOSTIC_TRACK_OUTCOMES)[number];
+type DiagnosticRoutingTrackStatus = 'pending' | 'active' | 'completed' | 'skipped';
+type DiagnosticRoutingStatus = 'in-progress' | 'ready-to-complete';
+interface DiagnosticRoutingNextItem {
+    stageKey: string;
+    trackKey: string;
+    nodeKey: string;
+    itemIdentifier: string;
+}
+/** Deliberately small semantic result exposed to normal game completion handlers. */
+interface DiagnosticTrackResult {
+    trackKey: string;
+    groupKey?: string;
+    outcome: DiagnosticTrackOutcome;
+    resultKey: string;
+}
+
+/** Stable curriculum-standard identity used to align and select assessment content. */
+interface AssessmentStandardRef {
+    framework: string;
+    identifier: string;
+}
+/**
+ * Playcademy's course-specific meaning for reusable QTI test content.
+ * Result writers translate this to OneRoster assessment-result `metadata.testType`;
+ * it intentionally does not become metadata on the QTI test itself.
+ */
+type AssessmentPurpose = (typeof ASSESSMENT_PURPOSES)[number];
+
+/** One answer value accepted by the supported QTI runtime interactions. */
+type AssessmentResponseValue = string | string[];
+/** Canonical response state persisted on an assessment attempt. */
+type AssessmentResponses = Record<string, Record<string, AssessmentResponseValue>>;
+/**
+ * One node of the rich-content vocabulary, which is OPEN: kinds are added as
+ * content that plain text would misrepresent appears, so a consumer must not
+ * treat this union as exhaustive.
+ *
+ * Structured content is projected from sanitized QTI on the host — never raw
+ * XML/HTML — and always travels alongside a flattened plain-text equivalent, so
+ * simple clients can ignore it entirely.
+ *
+ * A node carries no field common to every kind, so there is nothing to
+ * introspect on an unrecognized one. The supported fallback is one level up:
+ * abandon the whole subtree and render the enclosing `prompt` / `content`
+ * string, which is always present.
+ *
+ * Say so on screen when that happens. A question whose diagram or expression
+ * carried what was being asked still reads as complete prose once the structure
+ * is gone, so a silent fallback can leave a student an unanswerable question
+ * with nothing to indicate why.
+ */
+type PlayableContentNode = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'math';
+    /** Sanitized MathML source for clients that can render it. */
+    mathMl: string;
+    /** Plain-text approximation for clients that cannot. */
+    fallbackText: string;
+} | {
+    kind: 'image';
+    src: string;
+    width?: number;
+    height?: number;
+    description?: string;
+} | {
+    kind: 'paragraph';
+    children: PlayableContentNode[];
+} | {
+    kind: 'emphasis';
+    children: PlayableContentNode[];
+} | {
+    kind: 'strong';
+    children: PlayableContentNode[];
+} | {
+    kind: 'table';
+    rows: {
+        header: boolean;
+        cells: PlayableContentNode[][];
+    }[];
+}
+/**
+ * A bulleted or numbered list. Modelled because flattening one to plain text
+ * genuinely changes its meaning — "one two" is not a list — unlike inline
+ * emphasis, which reads correctly either way and so is not carried.
+ */
+ | {
+    kind: 'list';
+    /** Numbered (`ol`) rather than bulleted (`ul`). */
+    ordered: boolean;
+    items: PlayableContentNode[][];
+}
+/**
+ * Where one inline interaction belongs in the prose, naming the interaction
+ * it stands for rather than relying on its position among sibling blanks.
+ *
+ * The identifier is what makes this robust: matching blanks to interactions
+ * by order silently mispairs them when either sequence shifts, and a
+ * mispaired dropdown produces a wrong answer rather than a visible error.
+ */
+ | {
+    kind: 'blank';
+    responseIdentifier: string;
+}
+/** One named target inside a gap-match passage. */
+ | {
+    kind: 'gap';
+    identifier: string;
+};
+interface PlayableAssessmentChoice {
+    identifier: string;
+    content: string;
+    /** Keep this choice in its authored slot when the interaction is shuffled. */
+    fixed?: boolean;
+    /** Rich content when the choice carries more than plain text. */
+    contentNodes?: PlayableContentNode[];
+}
+/** A Match choice, which unlike an ordinary choice carries an association capacity. */
+interface PlayableMatchChoice extends PlayableAssessmentChoice {
+    /** Associations this choice accepts (0 means unlimited). */
+    matchMax: number;
+}
+interface PlayableAssessmentInteractionBase {
+    responseIdentifier: string;
+    /** Prompt declared inside the interaction (QTI qti-prompt), when present. */
+    prompt?: string;
+}
+interface PlayableChoiceInteraction extends PlayableAssessmentInteractionBase {
+    type: 'choice';
+    choices: PlayableAssessmentChoice[];
+    /** The host has already applied attempt-stable ordering; render the received array. */
+    shuffle: boolean;
+    minChoices: number;
+    maxChoices: number;
+}
+interface PlayableInlineChoiceInteraction extends PlayableAssessmentInteractionBase {
+    type: 'inline-choice';
+    choices: PlayableAssessmentChoice[];
+    /** The host has already applied attempt-stable ordering; render the received array. */
+    shuffle: boolean;
+}
+interface PlayableTextEntryInteraction extends PlayableAssessmentInteractionBase {
+    type: 'text-entry';
+    expectedLength?: number;
+    placeholder?: string;
+}
+interface PlayableOrderInteraction extends PlayableAssessmentInteractionBase {
+    type: 'order';
+    choices: PlayableAssessmentChoice[];
+    /** Whether the host applies attempt-stable presentation ordering. */
+    shuffle: boolean;
+}
+interface PlayableMatchInteraction extends PlayableAssessmentInteractionBase {
+    type: 'match';
+    sourceChoices: PlayableMatchChoice[];
+    targetChoices: PlayableMatchChoice[];
+    maxAssociations: number;
+    /** Whether the host applies independent attempt-stable ordering to both choice sets. */
+    shuffle: boolean;
+}
+interface PlayableHottextSegment {
+    identifier?: string;
+    content: string;
+    selectable: boolean;
+}
+interface PlayableHottextInteraction extends PlayableAssessmentInteractionBase {
+    type: 'hottext';
+    segments: PlayableHottextSegment[];
+    maxChoices: number;
+}
+/** A sanitized graphic reference rendered by graphic interactions. */
+interface PlayableAssessmentGraphic {
+    src: string;
+    width?: number;
+    height?: number;
+    /** Accessible description carried from the source QTI. */
+    description?: string;
+}
+/** The QTI region shape vocabulary shared by hotspots and scored areas. */
+declare const PLAYABLE_ASSESSMENT_SHAPES: readonly ['circle', 'ellipse', 'rect', 'poly', 'default'];
+type PlayableAssessmentShape = (typeof PLAYABLE_ASSESSMENT_SHAPES)[number];
+/** A clickable or associable region positioned on a graphic. */
+interface PlayableAssessmentHotspot {
+    identifier: string;
+    shape: PlayableAssessmentShape;
+    coords: number[];
+    /** Maximum associations this region accepts (0 or absent means unlimited). */
+    matchMax?: number;
+    description?: string;
+}
+interface PlayableHotspotInteraction extends PlayableAssessmentInteractionBase {
+    type: 'hotspot';
+    image: PlayableAssessmentGraphic;
+    hotspots: PlayableAssessmentHotspot[];
+    minChoices: number;
+    /** Always a concrete cap: an authored 0 (QTI: unlimited) resolves to the region count. */
+    maxChoices: number;
+}
+interface PlayableGapMatchChoice {
+    identifier: string;
+    content: string;
+    /** Keep this token in its authored bank slot, not a passage gap. */
+    fixed?: boolean;
+    /** Times this token may be placed (0 means unlimited). */
+    matchMax: number;
+}
+interface PlayableGapMatchInteraction extends PlayableAssessmentInteractionBase {
+    type: 'gap-match';
+    /** Shuffle the token bank without moving passage gaps. */
+    shuffle: boolean;
+    /** Passage containing each gap as a `___` blank, in `gaps` order. */
+    content: string;
+    /** Structured passage retaining each named gap at its authored inline position. */
+    contentNodes: PlayableContentNode[];
+    gapTexts: PlayableGapMatchChoice[];
+    /** Ordered gap identifiers matching the passage blanks. */
+    gaps: string[];
+    /** Overall pair limit (0 means unlimited). */
+    maxAssociations: number;
+}
+interface PlayableGapImageChoice {
+    identifier: string;
+    image?: PlayableAssessmentGraphic;
+    /** Times this token may be placed (0 means unlimited). */
+    matchMax: number;
+    description?: string;
+}
+interface PlayableGraphicGapMatchInteraction extends PlayableAssessmentInteractionBase {
+    type: 'graphic-gap-match';
+    image: PlayableAssessmentGraphic;
+    gapImages: PlayableGapImageChoice[];
+    hotspots: PlayableAssessmentHotspot[];
+    /** Overall pair limit (0 means unlimited). */
+    maxAssociations: number;
+}
+interface PlayableSelectPointInteraction extends PlayableAssessmentInteractionBase {
+    type: 'select-point';
+    image: PlayableAssessmentGraphic;
+    minChoices: number;
+    maxChoices: number;
+}
+interface PlayableGraphicAssociateInteraction extends PlayableAssessmentInteractionBase {
+    type: 'graphic-associate';
+    image: PlayableAssessmentGraphic;
+    hotspots: PlayableAssessmentHotspot[];
+    maxAssociations: number;
+}
+interface PlayablePositionObjectInteraction extends PlayableAssessmentInteractionBase {
+    type: 'position-object';
+    /** Background stage the object is placed onto. */
+    stage: PlayableAssessmentGraphic;
+    /** The movable object image. */
+    object: PlayableAssessmentGraphic;
+    /** Maximum number of placements. */
+    maxPlacements: number;
+}
+type PlayableAssessmentInteraction = PlayableChoiceInteraction | PlayableInlineChoiceInteraction | PlayableTextEntryInteraction | PlayableOrderInteraction | PlayableMatchInteraction | PlayableHottextInteraction | PlayableHotspotInteraction | PlayableGapMatchInteraction | PlayableGraphicGapMatchInteraction | PlayableSelectPointInteraction | PlayableGraphicAssociateInteraction | PlayablePositionObjectInteraction;
+interface PlayableAssessmentItem {
+    identifier: string;
+    title: string;
+    /**
+     * Shared item stem, flattened to plain text. Inline interactions appear as
+     * `___`, and block interactions belong after the prompt in `interactions`
+     * order.
+     *
+     * The `___` marks that a blank is there, not which interaction fills it or
+     * exactly where it sits: word offsets into this string are not part of the
+     * contract. Prose is translated, re-wrapped, and tokenized differently by
+     * language — a position counted in words does not survive any of that, and
+     * languages that do not separate words with spaces have no such position to
+     * count. Read `promptContent` to place blanks precisely; a client that
+     * ignores it should render inline interactions after the prompt.
+     */
+    prompt: string;
+    /**
+     * Structured prompt content, present whenever the stem holds an inline
+     * interaction or anything plain text would misrepresent — images, tables,
+     * lists, MathML. Absent means `prompt` says everything.
+     *
+     * Inline interactions appear as `blank` nodes carrying the response
+     * identifier they belong to.
+     */
+    promptContent?: PlayableContentNode[];
+    /** Maximum points awarded by the item's declared outcome (1 when undeclared). */
+    maxScore: number;
+    /** Document-ordered interactions with item-unique response identifiers. */
+    interactions: PlayableAssessmentInteraction[];
+}
+/** Sanitized assessment content safe to return to a sandboxed game. */
+interface PlayableAssessment {
+    identifier: string;
+    /**
+     * Schema version of this payload's shape, never of its content.
+     *
+     * Present so a game can tell a field the host does not send from one this
+     * item does not use, and so a mismatch is legible in a bug report. Branch on
+     * whether a field is present rather than on this number — the content
+     * vocabularies are deliberately open, so feature detection survives
+     * versions that a comparison against a fixed number does not.
+     */
+    contractVersion: typeof PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION;
+    /**
+     * Opaque revision of this assessment's content, used to ensure a resumed
+     * attempt loads what it started with. Changes when an author edits the
+     * assessment; unrelated to `contractVersion`.
+     */
+    contentRevision: string;
+    title: string;
+    items: PlayableAssessmentItem[];
+}
+interface AssessmentScore {
+    earned: number;
+    possible: number;
+    /** Aggregate score normalized to the inclusive 0..1 range. */
+    normalized: number;
+}
+type FixedAssessmentPurpose = Exclude<AssessmentPurpose, 'review'>;
+/** Fixed-test purposes that do not select their catalog by curriculum standard. */
+type UnscopedFixedAssessmentPurpose = Exclude<FixedAssessmentPurpose, 'mastery'>;
+/** One requested standard slot and the playable bank item selected for it. */
+interface AssessmentReviewItemSelection {
+    standard: AssessmentStandardRef;
+    itemIdentifier: string;
+}
+/** Why one requested standard could not be fully served by the current bank. */
+interface AssessmentReviewShortage {
+    standard: AssessmentStandardRef;
+    requested: number;
+    selected: number;
+    eligible: number;
+}
+/**
+ * Explicit review-request fulfillment. A partial result still starts a normal
+ * assessment attempt with every selectable item; no missing standard is
+ * silently omitted.
+ */
+type AssessmentReviewFulfillment = {
+    status: 'complete';
+    requestedItemCount: number;
+    selectedItemCount: number;
+    shortages: [];
+} | {
+    status: 'partial';
+    requestedItemCount: number;
+    selectedItemCount: number;
+    shortages: AssessmentReviewShortage[];
+};
+interface FixedAssessmentSelectionContext {
+    kind: 'fixed-test';
+    purpose: UnscopedFixedAssessmentPurpose;
+}
+/** A complete fixed quiz selected from the catalog for one canonical standard. */
+interface StandardQuizSelectionContext {
+    kind: 'standard-quiz';
+    purpose: 'mastery';
+    standard: AssessmentStandardRef;
+}
+/** Administration policy for one requested review skill, separate from its identity. */
+interface AssessmentReviewStandard extends AssessmentStandardRef {
+    /** Require this skill's second selected question, subject to the player's cap. */
+    requireBothQuestions?: boolean;
+}
+interface StandardsReviewSelectionContext {
+    kind: 'standards-review';
+    purpose: 'review';
+    standards: AssessmentReviewStandard[];
+    candidateItemsPerStandard: number;
+    selections: AssessmentReviewItemSelection[];
+    fulfillment: AssessmentReviewFulfillment;
+}
+/** Immutable identity pinned when the host starts a platform-routed diagnostic. */
+interface PlatformRoutedDiagnosticSelectionContext {
+    kind: 'platform-routed-diagnostic';
+    purpose: 'diagnostic';
+    definitionId: string;
+    diagnosticKey: string;
+    routingRevision: string;
+}
+/** How the host assembled the playable assessment returned for this attempt. */
+type AssessmentSelectionContext = FixedAssessmentSelectionContext | StandardQuizSelectionContext | StandardsReviewSelectionContext | PlatformRoutedDiagnosticSelectionContext;
+/** Server-derived assessment interaction model; callers select it only through purpose. */
+type AssessmentFlow = 'attempt-submit' | 'item-submit' | 'platform-routed-item-submit';
+/** Safe feedback persisted when one item is committed in an item-submit flow. */
+type AssessmentItemGrading = {
+    source: 'timeback-qti';
+    graderVersion: string;
+} | {
+    source: 'platform-qti-adapter';
+    graderVersion: string;
+    qtiGraderVersion: string;
+} | {
+    source: 'platform-artifact';
+    artifactVersion: string;
+    graderVersion: string;
+};
+interface AssessmentItemSubmission {
+    /** Stable caller-generated key used to replay a lost success response. */
+    submissionId: string;
+    itemIdentifier: string;
+    /** Stable administration timestamp used for exposure ordering and resume reconciliation. */
+    submittedAt: string;
+    /** One-based position in the validated administration sequence. */
+    responseVersion: number;
+    answered: boolean;
+    score: AssessmentScore;
+    isCorrect: boolean | null;
+    /**
+     * Trusted grading provenance pinned at grading time so child-result repair
+     * reproduces the corresponding child projection. Absent only on attempts
+     * committed before provenance was introduced.
+     */
+    grading?: AssessmentItemGrading;
+}
+/** Raw answers only. Array order is the administration sequence; no grades are trusted. */
+interface AssessmentTranscript {
+    version: 1;
+    attemptId: string;
+    /** The selected source revision, not a review subset's presentation revision. */
+    contentRevision: string;
+    administrations: {
+        submissionId: string;
+        itemIdentifier: string;
+        routingNodeKey?: string;
+        /** An empty response is still an administered question. */
+        responses: Record<string, AssessmentResponseValue>;
+    }[];
+}
+interface ResumeAssessmentInput {
+    /** Omit to recover the parent checkpoint, or best-effort child progress if none exists. */
+    transcript?: AssessmentTranscript;
+}
+/**
+ * Canonical activity context the SDK uses to track time for this attempt. A
+ * narrowed `ActivityData`, so it can be handed straight to the shared clock:
+ * the course routing fields are resolved rather than optional.
+ */
+type AssessmentActivityData = Pick<ActivityData, 'activityId' | 'courseId'> & {
+    activityName: string;
+    grade: TimebackGrade;
+    subject: TimebackSubject;
+};
+interface AssessmentAttemptSnapshotBase {
+    attemptId: string;
+    responseVersion: number;
+    status: 'in_progress';
+    /** Resolved server context for the shared activity-session clock, when valid. */
+    activityData?: AssessmentActivityData;
+    assessment: PlayableAssessment;
+    /** Opaque, attempt-scoped authorization. Renew through start/resume, not per answer. */
+    assessmentToken: string;
+    transcript: AssessmentTranscript;
+}
+/** Existing fixed, mastery, and review attempt shape. */
+interface ConventionalAssessmentAttemptSnapshot extends AssessmentAttemptSnapshotBase {
+    /** Historical fixed diagnostics remain attempt-submit and are never reinterpreted. */
+    flow: Exclude<AssessmentFlow, 'platform-routed-item-submit'>;
+    responses: AssessmentResponses;
+    /** Ordered committed-item ledger. Empty for attempt-submit flows. */
+    itemSubmissions: AssessmentItemSubmission[];
+    score: AssessmentScore | null;
+    selection: Exclude<AssessmentSelectionContext, PlatformRoutedDiagnosticSelectionContext>;
+}
+/** Safe public track progress; authored terminal semantics stay host-only until completion. */
+interface DiagnosticRoutingTrackSnapshot {
+    trackKey: string;
+    groupKey?: string;
+    status: DiagnosticRoutingTrackStatus;
+    administeredCount: number;
+}
+/** Safe canonical routing projection returned while a diagnostic is in progress. */
+interface DiagnosticRoutingSnapshot {
+    kind: 'platform-routed-diagnostic';
+    revision: string;
+    status: DiagnosticRoutingStatus;
+    next: DiagnosticRoutingNextItem | null;
+    tracks: DiagnosticRoutingTrackSnapshot[];
+}
+/** Small semantic diagnostic result consumed by the game after finalization. */
+interface DiagnosticAssessmentSubmitResult {
+    purpose: 'diagnostic';
+    attemptId: string;
+    submissionId: string;
+    diagnosticKey: string;
+    responseVersion: number;
+    status: 'awaiting_award';
+    tracks: DiagnosticTrackResult[];
+}
+/** Platform-routed diagnostics never expose grading, feedback, or their committed ledger. */
+interface PlatformRoutedDiagnosticAttemptSnapshot extends AssessmentAttemptSnapshotBase {
+    flow: 'platform-routed-item-submit';
+    selection: PlatformRoutedDiagnosticSelectionContext;
+    routing: DiagnosticRoutingSnapshot;
+    completion: null;
+}
+interface AssessmentSaveResult {
+    attemptId: string;
+    responseVersion: number;
+    status: 'in_progress';
+    responses: AssessmentResponses;
+    transcript: AssessmentTranscript;
+}
+interface AssessmentSubmitResultBase {
+    attemptId: string;
+    submissionId: string;
+    responseVersion: number;
+    status: 'awaiting_award';
+    responses: AssessmentResponses;
+    score: AssessmentScore;
+}
+interface FixedAssessmentSubmitResult extends AssessmentSubmitResultBase {
+    purpose: UnscopedFixedAssessmentPurpose;
+}
+/** Safe final item grade, exposed only after the assessment is submitted. */
+interface AssessmentItemOutcome {
+    itemIdentifier: string;
+    standard: AssessmentStandardRef;
+    answered: boolean;
+    score: AssessmentScore;
+    isCorrect: boolean | null;
+}
+interface ReviewAssessmentSubmitResult extends AssessmentSubmitResultBase {
+    purpose: 'review';
+    /** Final outcomes in committed transcript order, excluding unused candidates. */
+    itemOutcomes: AssessmentItemOutcome[];
+}
+interface MasteryAssessmentSubmitResult extends AssessmentSubmitResultBase {
+    purpose: 'mastery';
+    /** One final outcome per question in test order, including unanswered questions. */
+    itemOutcomes: AssessmentItemOutcome[];
+}
+type ConventionalAssessmentSubmitResult = FixedAssessmentSubmitResult | ReviewAssessmentSubmitResult | MasteryAssessmentSubmitResult;
+type AssessmentSubmitResult = ConventionalAssessmentSubmitResult | DiagnosticAssessmentSubmitResult;
+type CompletedAssessmentResult<TResult extends AssessmentSubmitResult> = Omit<TResult, 'status'> & {
+    status: 'completed';
+    /** XP durably recorded on the authoritative OneRoster AssessmentResult. */
+    xpAwarded: number;
+    /**
+     * The mastery delta durably recorded on the authoritative result after
+     * platform bounding. Zero when the game awarded no mastery.
+     */
+    masteredUnitsApplied: number;
+    /** Course completion percentage after this award, when mastery tracking is configured. */
+    pctCompleteApp?: number;
+    /** Non-fatal bounding warnings raised while applying the award. */
+    warnings?: MasteryWriteWarning[];
+};
+/** Terminal result returned only after the game's award has been recorded. */
+type AssessmentFinalizeResult = CompletedAssessmentResult<FixedAssessmentSubmitResult> | CompletedAssessmentResult<ReviewAssessmentSubmitResult> | CompletedAssessmentResult<MasteryAssessmentSubmitResult> | CompletedAssessmentResult<DiagnosticAssessmentSubmitResult>;
+/** Minimal recovery snapshot; no QTI content load is required after answers are locked. */
+type SettledAssessmentAttemptSnapshot = {
+    attemptId: string;
+    responseVersion: number;
+    status: 'awaiting_award';
+    result: AssessmentSubmitResult;
+} | {
+    attemptId: string;
+    responseVersion: number;
+    status: 'completed';
+    result: AssessmentFinalizeResult;
+};
+/** Snapshot states that are still open for responses. */
+type PlayableAssessmentAttemptSnapshot = ConventionalAssessmentAttemptSnapshot | PlatformRoutedDiagnosticAttemptSnapshot;
+type AssessmentAttemptSnapshot = PlayableAssessmentAttemptSnapshot | SettledAssessmentAttemptSnapshot;
+interface GetLatestAssessmentOptionsBase {
+    subject?: TimebackSubject;
+    grade?: TimebackGrade;
+}
+/** Filters for finding the authenticated student's latest completed assessment. */
+type GetLatestAssessmentOptions = (GetLatestAssessmentOptionsBase & {
+    purpose: Exclude<AssessmentPurpose, 'mastery'>;
+    standard?: never;
+}) | (GetLatestAssessmentOptionsBase & {
+    purpose: 'mastery';
+    standard: AssessmentStandardRef;
+});
+/** Compact result returned by the latest-completed-assessment lookup. */
+interface LatestAssessmentResult {
+    attemptId: string;
+    purpose: AssessmentPurpose;
+    activityId: string;
+    subject: TimebackSubject;
+    grade: TimebackGrade;
+    testIdentifier: string;
+    /** Canonical request identity for mastery results; null for other purposes. */
+    standard: AssessmentStandardRef | null;
+    completedAt: string;
+    /** Persisted aggregate score normalized to the inclusive 0..1 range. */
+    score: Pick<AssessmentScore, 'normalized'>;
+}
+interface StartAssessmentInputBase {
+    activityId: string;
+    subject?: TimebackSubject;
+    grade?: TimebackGrade;
+}
+interface StartFixedAssessmentInput extends StartAssessmentInputBase {
+    purpose: Exclude<UnscopedFixedAssessmentPurpose, 'diagnostic'>;
+}
+interface StartDiagnosticAssessmentInput extends StartAssessmentInputBase {
+    purpose: 'diagnostic';
+    /** Stable authored diagnostic identity, independent of the selected QTI test identifier. */
+    diagnosticKey: string;
+}
+interface StartMasteryAssessmentInput extends StartAssessmentInputBase {
+    purpose: 'mastery';
+    standard: AssessmentStandardRef;
+}
+interface StartReviewAssessmentInput extends StartAssessmentInputBase {
+    purpose: 'review';
+    /** Serving order; duplicate canonical skills keep their first position. Pinned on start. */
+    standards: AssessmentReviewStandard[];
+    /** Candidate capacity per standard; preloaded candidates are not administered automatically. */
+    candidateItemsPerStandard?: number;
+}
+type StartAssessmentInput = StartFixedAssessmentInput | StartDiagnosticAssessmentInput | StartMasteryAssessmentInput | StartReviewAssessmentInput;
+/** Transport metadata for attempting a prepared new-assessment start. */
+interface StartAssessmentOptions {
+    preparationReceipt?: string;
+}
+/** Result of preparing the immediate next assessment request. */
+type AssessmentPreparationResult = {
+    status: 'prepared';
+    receipt: string;
+    /** Receipt expiry as an ISO-8601 timestamp. */
+    expiresAt: string;
+} | {
+    status: 'unprepared';
+    reason: 'artifact_unavailable' | 'prerequisite_unavailable' | 'local_runtime';
+};
+interface SaveAssessmentInput {
+    expectedResponseVersion: number;
+    /** Complete active draft; success acknowledges its durable parent checkpoint. */
+    transcript: AssessmentTranscript;
+}
+/** Best-effort mastery progress, not an answer commitment or an explicit checkpoint. */
+interface RecordAssessmentProgressInput {
+    assessmentToken: string;
+    expectedResponseVersion: number;
+    /** Current raw draft, including the editable administration being projected. */
+    transcript: AssessmentTranscript;
+    itemIdentifier: string;
+}
+interface SubmitAssessmentItemInputBase {
+    assessmentToken: string;
+    /** The raw prefix preceding this administration (or including it for an exact retry). */
+    transcript: AssessmentTranscript;
+    expectedResponseVersion: number;
+    /** Stable across every retry of this exact item submission. */
+    submissionId: string;
+    itemIdentifier: string;
+    responses: Record<string, AssessmentResponseValue | null>;
+}
+interface SubmitReviewAssessmentItemInput extends SubmitAssessmentItemInputBase {
+    routingNodeKey?: never;
+}
+interface SubmitDiagnosticAssessmentItemInput extends SubmitAssessmentItemInputBase {
+    /** Canonical routing-context identity returned in routing.next. */
+    routingNodeKey: string;
+}
+type SubmitAssessmentItemInput = SubmitReviewAssessmentItemInput | SubmitDiagnosticAssessmentItemInput;
+interface SubmitReviewAssessmentItemResult {
+    attemptId: string;
+    responseVersion: number;
+    status: 'in_progress';
+    responses: AssessmentResponses;
+    /** Canonical ledger after commit or replay; replace local state with it. */
+    itemSubmissions: AssessmentItemSubmission[];
+    submission: AssessmentItemSubmission;
+    transcript: AssessmentTranscript;
+}
+/** Safe acknowledgement for one immutable diagnostic item commitment. */
+interface DiagnosticAssessmentItemReceipt {
+    submissionId: string;
+    routingNodeKey: string;
+    itemIdentifier: string;
+    submittedAt: string;
+    responseVersion: number;
+    answered: boolean;
+    score: AssessmentScore;
+    isCorrect: boolean;
+}
+/** Canonical post-commit routing state plus trusted feedback for this administration. */
+interface SubmitDiagnosticAssessmentItemResult {
+    attemptId: string;
+    responseVersion: number;
+    status: 'in_progress';
+    routing: DiagnosticRoutingSnapshot;
+    submission: DiagnosticAssessmentItemReceipt;
+    transcript: AssessmentTranscript;
+}
+type SubmitAssessmentItemResult = SubmitReviewAssessmentItemResult | SubmitDiagnosticAssessmentItemResult;
+interface SubmitAssessmentInput {
+    expectedResponseVersion: number;
+    submissionId: string;
+    transcript: AssessmentTranscript;
+}
+/** The optional mastery portion of a finalize award; at most one field is set. */
+interface AssessmentMasteryAward {
+    /**
+     * Incremental learning units mastered by this attempt. Cannot be combined
+     * with masteredUnitsAbsolute. The platform bounds the delta against the
+     * course's configured masterableUnits and returns any warning.
+     */
+    masteredUnits?: number;
+    /**
+     * Absolute mastered-unit total after this attempt; the platform computes
+     * the delta. Cannot be combined with masteredUnits.
+     */
+    masteredUnitsAbsolute?: number;
+}
+interface FinalizeAssessmentInput extends AssessmentMasteryAward {
+    submissionId: string;
+    /** Explicit zero is an award; omission is never interpreted as zero. */
+    xpAwarded: number;
+}
+
 /**
  * Cache configuration types for runtime customization
  */
@@ -334,7 +1510,7 @@ declare abstract class PlaycademyBaseClient {
      * - `me()` - Get authenticated user profile
      */
     users: {
-        me: () => Promise<_playcademy_types.AuthenticatedUser>;
+        me: () => Promise<AuthenticatedUser>;
     };
 }
 
@@ -1555,36 +2731,36 @@ declare class PlaycademyClient extends PlaycademyBaseClient {
      */
     timeback: {
         assessments: {
-            prepare: (input: _playcademy_types.StartAssessmentInput) => Promise<_playcademy_types.AssessmentPreparationResult>;
-            start: (input: _playcademy_types.StartAssessmentInput, options?: _playcademy_types.StartAssessmentOptions) => Promise<_playcademy_types.AssessmentAttemptSnapshot>;
-            latest: (options: _playcademy_types.GetLatestAssessmentOptions) => Promise<_playcademy_types.LatestAssessmentResult | null>;
-            get: (attemptId: string) => Promise<_playcademy_types.AssessmentAttemptSnapshot>;
+            prepare: (input: StartAssessmentInput) => Promise<AssessmentPreparationResult>;
+            start: (input: StartAssessmentInput, options?: StartAssessmentOptions) => Promise<AssessmentAttemptSnapshot>;
+            latest: (options: GetLatestAssessmentOptions) => Promise<LatestAssessmentResult | null>;
+            get: (attemptId: string) => Promise<AssessmentAttemptSnapshot>;
             stop: (attemptId: string) => Promise<{
                 attemptId: string;
             }>;
-            resume: (attemptId: string, input?: _playcademy_types.ResumeAssessmentInput) => Promise<_playcademy_types.AssessmentAttemptSnapshot>;
-            save: (attemptId: string, input: _playcademy_types.SaveAssessmentInput) => Promise<_playcademy_types.AssessmentSaveResult>;
-            recordProgress: (attemptId: string, input: _playcademy_types.RecordAssessmentProgressInput) => Promise<{
+            resume: (attemptId: string, input?: ResumeAssessmentInput) => Promise<AssessmentAttemptSnapshot>;
+            save: (attemptId: string, input: SaveAssessmentInput) => Promise<AssessmentSaveResult>;
+            recordProgress: (attemptId: string, input: RecordAssessmentProgressInput) => Promise<{
                 attemptId: string;
             }>;
-            submitItem: (attemptId: string, input: _playcademy_types.SubmitAssessmentItemInput) => Promise<_playcademy_types.SubmitAssessmentItemResult>;
-            submit: (attemptId: string, input: _playcademy_types.SubmitAssessmentInput) => Promise<_playcademy_types.AssessmentSubmitResult>;
-            finalize: (attemptId: string, input: _playcademy_types.FinalizeAssessmentInput) => Promise<_playcademy_types.AssessmentFinalizeResult>;
+            submitItem: (attemptId: string, input: SubmitAssessmentItemInput) => Promise<SubmitAssessmentItemResult>;
+            submit: (attemptId: string, input: SubmitAssessmentInput) => Promise<AssessmentSubmitResult>;
+            finalize: (attemptId: string, input: FinalizeAssessmentInput) => Promise<AssessmentFinalizeResult>;
         };
         readonly user: TimebackUser;
         readonly currentRunId: string | undefined;
-        startActivity: (metadata: _playcademy_types.ActivityData, options?: StartActivityOptions) => StartActivityResult;
+        startActivity: (metadata: ActivityData, options?: StartActivityOptions) => StartActivityResult;
         pauseActivity: () => void;
         resumeActivity: () => void;
-        endActivity: (data: _playcademy_types.EndActivityScoreData) => Promise<_playcademy_types.EndActivityResponse | RelayedEndActivityResult>;
+        endActivity: (data: EndActivityScoreData) => Promise<EndActivityResponse | RelayedEndActivityResult>;
         course: {
             advance: (options?: {
-                subject?: _playcademy_types.TimebackSubject;
-            }) => Promise<_playcademy_types.AdvanceCourseResponse>;
+                subject?: TimebackSubject;
+            }) => Promise<AdvanceCourseResponse>;
             unenroll: (options?: {
-                subject?: _playcademy_types.TimebackSubject;
+                subject?: TimebackSubject;
                 force?: boolean;
-            }) => Promise<_playcademy_types.UnenrollCourseResponse>;
+            }) => Promise<UnenrollCourseResponse>;
         };
     };
     /**
@@ -1599,7 +2775,7 @@ declare class PlaycademyClient extends PlaycademyBaseClient {
      * - `fetch(options?)` - Fetch leaderboard entries
      */
     leaderboard: {
-        fetch: (options?: _playcademy_types.LeaderboardOptions) => Promise<_playcademy_types.GameLeaderboardEntry[]>;
+        fetch: (options?: LeaderboardOptions) => Promise<GameLeaderboardEntry[]>;
     };
     /**
      * Demo-mode helpers. Methods throw when called outside `client.mode === 'demo'`,
@@ -1610,8 +2786,8 @@ declare class PlaycademyClient extends PlaycademyBaseClient {
      */
     demo: {
         profile: {
-            get: () => Promise<_playcademy_types.DemoProfile>;
-            update: (updates: _playcademy_types.DemoProfileUpdate) => Promise<_playcademy_types.DemoProfile>;
+            get: () => Promise<DemoProfile>;
+            update: (updates: DemoProfileUpdate) => Promise<DemoProfile>;
         };
         end: (score: number, options?: DemoEndOptions) => void;
     };