@timeback/powerpath 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,24 +1,919 @@
+import * as _timeback_internal_client_infra from '@timeback/internal-client-infra';
+import { PowerPathPaths, RequestOptions, PaginatedResponse, ClientConfig, TransportOnlyConfig, ProviderClientConfig, BaseTransportConfig, Paginator as Paginator$1, ListParams, ProviderRegistry, TimebackProvider, AuthCheckResult, BaseTransport } from '@timeback/internal-client-infra';
+export { AuthCheckResult, EnvAuth, Environment, ExplicitAuth, ListParams, PageResult } from '@timeback/internal-client-infra';
+
 /**
- * PowerPath API client SDK for Timeback.
+ * PowerPath Base Types
  *
- * @example Environment mode (Timeback APIs)
- * ```typescript
- * import { PowerPathClient } from '@timeback/powerpath'
+ * Common types and enums for PowerPath API responses.
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENUMS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Test assignment status values.
+ */
+type TestAssignmentStatus =
+	| 'assigned'
+	| 'in_progress'
+	| 'completed'
+	| 'failed'
+	| 'expired'
+	| 'cancelled'
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PAGINATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Pagination metadata from PowerPath list responses.
+ */
+interface PaginationMeta {
+	/** Total items across all pages */
+	totalCount: number
+	/** Total number of pages */
+	pageCount: number
+	/** Current page number (1-indexed) */
+	pageNumber: number
+	/**
+	 * Offset for the next page of results.
+	 *
+	 * This API uses offset pagination: request `offset` is the number of items to skip.
+	 * List responses also include an `offset` field; treat it as the server-provided
+	 * next offset (and fall back to `currentOffset + limit` when implementing iterators).
+	 */
+	offset: number
+	/** Items per page (default 100, max 3000) */
+	limit: number
+}
+
+/**
+ * PowerPath Response Types
+ *
+ * Entity types returned by PowerPath API endpoints.
+ */
+
+
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST ASSIGNMENTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * A single test assignment entity.
+ */
+interface TestAssignment {
+	sourcedId: string
+	studentSourcedId: string
+	studentEmail: string
+	assignedByUserSourcedId?: string
+	subject: string
+	grade: string
+	assignmentStatus: TestAssignmentStatus
+	testName?: string
+	assignedAt?: string
+	expiresAt?: string
+	completedAt?: string
+	resourceSourcedId?: string
+	componentResourceSourcedId?: string
+}
+
+/**
+ * List response for test assignments.
+ */
+interface TestAssignmentsListResponse extends PaginationMeta {
+	testAssignments: TestAssignment[]
+}
+
+/**
+ * Result from creating a test assignment.
+ */
+interface AssignmentResult {
+	assignmentId: string
+	lessonId: string
+	resourceId: string
+}
+
+/**
+ * Result from bulk operations.
+ */
+interface BulkResult {
+	success: boolean
+	results: AssignmentResult[]
+	errors: Array<{ row: number; message: string }>
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ASSESSMENTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Result from creating an external test (test-out, placement, or internal).
+ */
+interface ExternalTestCreateResponse {
+	lessonId: string
+	resourceId: string
+}
+
+/**
+ * A single attempt record.
+ */
+interface Attempt {
+	attempt?: number
+	score: number
+	scoreStatus: string
+}
+
+/**
+ * Result from creating a new attempt.
+ */
+interface CreateAttemptResponse {
+	attempt: Attempt
+}
+
+/**
+ * Result from getting attempts for a lesson.
+ */
+interface GetAttemptsResponse {
+	attempts: Attempt[]
+}
+
+/**
+ * Result from getting assessment progress.
+ * Shape varies by context; stable fields are typed.
+ */
+interface GetAssessmentProgressResponse {
+	lessonType?: string
+	[key: string]: unknown
+}
+
+/**
+ * Result from resetting an attempt.
+ */
+interface ResetAttemptResponse {
+	success: boolean
+	score: number
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PLACEMENT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Result from getting all placement tests.
+ */
+interface GetAllPlacementTestsResponse {
+	placementTests: unknown[]
+}
+
+/**
+ * Result from getting current placement level.
+ */
+interface GetCurrentLevelResponse {
+	gradeLevel?: unknown
+	onboarded?: boolean
+	availableTests: number
+}
+
+/**
+ * Result from getting the next placement test.
+ */
+interface GetNextPlacementTestResponse {
+	availableTests: number
+	lesson: string
+}
+
+/**
+ * Result from getting subject progress.
+ */
+interface GetSubjectProgressResponse {
+	progress: unknown[]
+}
+
+/**
+ * Result from resetting placement.
+ */
+interface ResetPlacementResponse {
+	success: boolean
+	placementResultsDeleted: number
+	onboardingReset: boolean
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SCREENING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Result from screening getResults.
+ * Response shape depends on MAP integration configuration.
+ */
+interface ScreeningResultsResponse {
+	[key: string]: unknown
+}
+
+/**
+ * Result from screening getSession.
+ * Response shape depends on MAP integration configuration.
+ */
+interface ScreeningSessionResponse {
+	[key: string]: unknown
+}
+
+/**
+ * Result from resetting a screening session.
+ */
+interface ScreeningResetSessionResponse {
+	success?: boolean
+	[key: string]: unknown
+}
+
+/**
+ * Result from assigning a screening test.
+ */
+interface ScreeningAssignTestResponse {
+	success?: boolean
+	[key: string]: unknown
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// LESSON PLANS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Result from creating a lesson plan.
+ */
+interface LessonPlanCreateResponse {
+	lessonPlanId: string
+}
+
+/**
+ * A lesson plan operation record.
+ */
+interface LessonPlanOperation {
+	id: string
+	type: string
+	payload?: unknown
+	reason?: string
+	createdAt: string
+	sequenceNumber: number
+	createdBy?: string
+}
+
+/**
+ * Response containing lesson plan operations.
+ */
+interface LessonPlanOperationsResponse {
+	operations: LessonPlanOperation[]
+}
+
+/**
+ * Result from a single lesson plan operation.
+ */
+interface LessonPlanOperationResult {
+	success: boolean
+	message?: string
+	operationId?: string
+}
+
+/**
+ * Result from syncing lesson plan operations.
+ */
+interface LessonPlanSyncResult {
+	success: boolean
+	message?: string
+	operationCount: number
+	operationResults: Array<{ success: boolean; errors?: Array<{ message: string }> }>
+}
+
+/**
+ * Result from syncing a course.
+ */
+interface LessonPlanCourseSyncResult {
+	lessonPlansAffected: string[]
+}
+
+/**
+ * Response containing a lesson plan.
+ */
+interface LessonPlanResponse {
+	lessonPlan: Record<string, unknown>
+}
+
+/**
+ * Response containing course progress.
+ */
+interface CourseProgressResponse {
+	lineItems: Record<string, unknown>[]
+}
+
+/**
+ * Result from updating student item response.
+ */
+interface UpdateStudentItemResponseResult {
+	success?: boolean
+	[key: string]: unknown
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SYLLABUS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Response containing syllabus data.
+ */
+interface SyllabusResponse {
+	syllabus?: unknown
+}
+
+type input<T> = T extends {
+    _zod: {
+        input: any;
+    };
+} ? T["_zod"]["input"] : unknown;
+
+/**
+ * PowerPath Schemas
+ *
+ * Zod schemas for the PowerPath adaptive learning API.
+ */
+
+
+
+declare const ExternalTestOut = ExternalTestBase.extend({
+	lessonType: z.literal('test-out'),
+	xp: z.number(),
+})
+
+declare const ExternalPlacement = ExternalTestBase.extend({
+	lessonType: z.literal('placement'),
+	courseIdOnFail: NonEmptyString.optional(),
+	xp: z.number().optional(),
+})
+
+declare const PowerPathCreateExternalPlacementTestInput = ExternalPlacement
+
+declare const PowerPathCreateExternalTestOutInput = ExternalTestOut
+
+declare const PowerPathCreateInternalTestInput = z.union([
+	InternalTestBase.extend({
+		testType: z.literal('qti'),
+		qti: z.object({
+			url: z.url(),
+			title: NonEmptyString.optional(),
+			metadata: z.record(z.string(), z.unknown()).optional(),
+		}),
+	}),
+	InternalTestBase.extend({
+		testType: z.literal('assessment-bank'),
+		assessmentBank: z.object({
+			resources: z.array(
+				z.object({
+					url: z.url(),
+					title: NonEmptyString.optional(),
+					metadata: z.record(z.string(), z.unknown()).optional(),
+				}),
+			),
+		}),
+	}),
+])
+
+declare const PowerPathCreateNewAttemptInput = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+})
+
+declare const PowerPathFinalStudentAssessmentResponseInput = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+})
+
+declare const PowerPathLessonPlansCreateInput = z.object({
+	courseId: NonEmptyString,
+	userId: NonEmptyString,
+	classId: NonEmptyString.optional(),
+})
+
+declare const PowerPathLessonPlanOperationInput = z.union([
+	z.object({
+		type: z.literal('set-skipped'),
+		payload: z.object({
+			target: LessonPlanTarget,
+			value: z.boolean(),
+		}),
+	}),
+	z.object({
+		type: z.literal('add-custom-resource'),
+		payload: z.object({
+			resource_id: NonEmptyString,
+			parent_component_id: NonEmptyString,
+			skipped: z.boolean().optional(),
+		}),
+	}),
+	z.object({
+		type: z.literal('move-item-before'),
+		payload: z.object({
+			target: LessonPlanTarget,
+			reference_id: NonEmptyString,
+		}),
+	}),
+	z.object({
+		type: z.literal('move-item-after'),
+		payload: z.object({
+			target: LessonPlanTarget,
+			reference_id: NonEmptyString,
+		}),
+	}),
+	z.object({
+		type: z.literal('move-item-to-start'),
+		payload: z.object({
+			target: LessonPlanTarget,
+		}),
+	}),
+	z.object({
+		type: z.literal('move-item-to-end'),
+		payload: z.object({
+			target: LessonPlanTarget,
+		}),
+	}),
+	z.object({
+		type: z.literal('change-item-parent'),
+		payload: z.object({
+			target: LessonPlanTarget,
+			new_parent_id: NonEmptyString,
+			position: z.enum(['start', 'end']).optional(),
+		}),
+	}),
+])
+
+declare const PowerPathLessonPlanOperationsInput = z.object({
+	operation: z.array(PowerPathLessonPlanOperationInput),
+	reason: NonEmptyString.optional(),
+})
+
+declare const PowerPathLessonPlanUpdateStudentItemResponseInput = z.object({
+	studentId: NonEmptyString,
+	componentResourceId: NonEmptyString,
+	result: z.object({
+		status: z.enum(['active', 'tobedeleted']),
+		metadata: z.record(z.string(), z.unknown()).optional(),
+		score: z.number().optional(),
+		textScore: NonEmptyString.optional(),
+		scoreDate: NonEmptyString,
+		scorePercentile: z.number().optional(),
+		scoreStatus: ScoreStatus,
+		comment: NonEmptyString.optional(),
+		learningObjectiveSet: z
+			.array(
+				z.object({
+					source: NonEmptyString,
+					learningObjectiveResults: z.array(
+						z.object({
+							learningObjectiveId: NonEmptyString,
+							score: z.number().optional(),
+							textScore: NonEmptyString.optional(),
+						}),
+					),
+				}),
+			)
+			.optional(),
+		inProgress: NonEmptyString.optional(),
+		incomplete: NonEmptyString.optional(),
+		late: NonEmptyString.optional(),
+		missing: NonEmptyString.optional(),
+	}),
+})
+
+declare const PowerPathMakeExternalTestAssignmentInput = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+	applicationName: NonEmptyString.optional(),
+	testId: NonEmptyString.optional(),
+	skipCourseEnrollment: z.boolean().optional(),
+})
+
+declare const PowerPathPlacementResetUserPlacementInput = z.object({
+	student: NonEmptyString,
+	subject: TimebackSubject,
+})
+
+declare const PowerPathResetAttemptInput = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+})
+
+declare const PowerPathScreeningResetSessionInput = z.object({
+	userId: NonEmptyString,
+})
+
+declare const PowerPathScreeningAssignTestInput = z.object({
+	userId: NonEmptyString,
+	subject: z.enum(['Math', 'Reading', 'Language', 'Science']),
+})
+
+declare const PowerPathTestAssignmentsCreateInput = z.object({
+	student: NonEmptyString,
+	subject: TimebackSubject,
+	grade: TimebackGrade,
+	testName: NonEmptyString.optional(),
+})
+
+declare const PowerPathTestAssignmentsUpdateInput = z.object({
+	testName: NonEmptyString,
+})
+
+declare const PowerPathTestAssignmentsBulkInput = z.object({
+	items: z.array(PowerPathTestAssignmentItemInput),
+})
+
+declare const PowerPathTestAssignmentsImportInput = z.object({
+	spreadsheetUrl: z.url(),
+	sheet: NonEmptyString,
+})
+
+declare const PowerPathTestAssignmentsListParams = z.object({
+	student: NonEmptyString,
+	status: z
+		.enum(['assigned', 'in_progress', 'completed', 'failed', 'expired', 'cancelled'])
+		.optional(),
+	subject: NonEmptyString.optional(),
+	grade: TimebackGrade.optional(),
+	limit: z.number().int().positive().max(3000).optional(),
+	offset: z.number().int().nonnegative().optional(),
+})
+
+declare const PowerPathTestAssignmentsAdminParams = z.object({
+	student: NonEmptyString.optional(),
+	status: z
+		.enum(['assigned', 'in_progress', 'completed', 'failed', 'expired', 'cancelled'])
+		.optional(),
+	subject: NonEmptyString.optional(),
+	grade: TimebackGrade.optional(),
+	limit: z.number().int().positive().max(3000).optional(),
+	offset: z.number().int().nonnegative().optional(),
+})
+
+declare const PowerPathUpdateStudentQuestionResponseInput = z.object({
+	student: NonEmptyString,
+	question: NonEmptyString,
+	response: z.union([NonEmptyString, z.array(NonEmptyString)]).optional(),
+	responses: z.record(z.string(), z.union([NonEmptyString, z.array(NonEmptyString)])).optional(),
+	lesson: NonEmptyString,
+})
+
+declare const PowerPathGetAssessmentProgressParams = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+	attempt: z.number().int().positive().optional(),
+})
+
+declare const PowerPathGetNextQuestionParams = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+})
+
+declare const PowerPathGetAttemptsParams = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+})
+
+declare const PowerPathTestOutParams = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString.optional(),
+	finalized: z.boolean().optional(),
+	toolProvider: NonEmptyString.optional(),
+	attempt: z.number().int().positive().optional(),
+})
+
+declare const PowerPathImportExternalTestAssignmentResultsParams = z.object({
+	student: NonEmptyString,
+	lesson: NonEmptyString,
+	applicationName: NonEmptyString.optional(),
+})
+
+declare const PowerPathPlacementQueryParams = z.object({
+	student: NonEmptyString,
+	subject: TimebackSubject,
+})
+
+declare const PowerPathSyllabusQueryParams = z.object({
+	status: z.enum(['active', 'tobedeleted']).optional(),
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TYPE EXPORTS (REQUEST INPUTS)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+// Shorter type aliases (like OneRoster pattern: schema = OneRosterFoo, type = Foo)
+type CreateExternalPlacementTestInput = input<
+	typeof PowerPathCreateExternalPlacementTestInput
+>
+type CreateExternalTestOutInput = input<typeof PowerPathCreateExternalTestOutInput>
+type CreateInternalTestInput = input<typeof PowerPathCreateInternalTestInput>
+type CreateNewAttemptInput = input<typeof PowerPathCreateNewAttemptInput>
+type FinalStudentAssessmentResponseInput = input<
+	typeof PowerPathFinalStudentAssessmentResponseInput
+>
+type LessonPlansCreateInput = input<typeof PowerPathLessonPlansCreateInput>
+type LessonPlanOperationInput = input<typeof PowerPathLessonPlanOperationInput>
+type LessonPlanOperationsInput = input<typeof PowerPathLessonPlanOperationsInput>
+type LessonPlanUpdateStudentItemResponseInput = input<
+	typeof PowerPathLessonPlanUpdateStudentItemResponseInput
+>
+type MakeExternalTestAssignmentInput = input<
+	typeof PowerPathMakeExternalTestAssignmentInput
+>
+type PlacementResetUserPlacementInput = input<
+	typeof PowerPathPlacementResetUserPlacementInput
+>
+type ResetAttemptInput = input<typeof PowerPathResetAttemptInput>
+type ScreeningResetSessionInput = input<typeof PowerPathScreeningResetSessionInput>
+type ScreeningAssignTestInput = input<typeof PowerPathScreeningAssignTestInput>
+type TestAssignmentsCreateInput = input<typeof PowerPathTestAssignmentsCreateInput>
+type TestAssignmentsUpdateInput = input<typeof PowerPathTestAssignmentsUpdateInput>
+type TestAssignmentsBulkInput = input<typeof PowerPathTestAssignmentsBulkInput>
+type TestAssignmentsImportInput = input<typeof PowerPathTestAssignmentsImportInput>
+type TestAssignmentsListParams = input<typeof PowerPathTestAssignmentsListParams>
+type TestAssignmentsAdminParams = input<typeof PowerPathTestAssignmentsAdminParams>
+type UpdateStudentQuestionResponseInput = input<
+	typeof PowerPathUpdateStudentQuestionResponseInput
+>
+type GetAssessmentProgressParams = input<typeof PowerPathGetAssessmentProgressParams>
+type GetNextQuestionParams = input<typeof PowerPathGetNextQuestionParams>
+type GetAttemptsParams = input<typeof PowerPathGetAttemptsParams>
+type TestOutParams = input<typeof PowerPathTestOutParams>
+type ImportExternalTestAssignmentResultsParams = input<
+	typeof PowerPathImportExternalTestAssignmentResultsParams
+>
+type PlacementQueryParams = input<typeof PowerPathPlacementQueryParams>
+type SyllabusQueryParams = input<typeof PowerPathSyllabusQueryParams>
+
+/**
+ * Transport interface for PowerPath client.
+ *
+ * Extends base transport requirements with PowerPath-specific paths.
+ * Required when using transport mode with PowerPathClient.
+ */
+interface PowerPathTransportLike {
+    /** Base URL of the API */
+    baseUrl: string;
+    /** API path profiles for PowerPath operations */
+    paths: PowerPathPaths;
+    /** Make an authenticated request */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** Make a paginated request (PowerPath returns pagination metadata in body) */
+    requestPaginated<T>(path: string, options?: RequestOptions): Promise<PaginatedResponse<T>>;
+}
+/**
+ * All supported PowerPath client configuration types.
+ *
+ * Supports four modes:
+ * - **Provider mode**: `{ provider: TimebackProvider }` — pre-built provider with token sharing
+ * - **Environment mode**: `{ platform?, env, auth }` — Timeback hosted APIs
+ * - **Explicit mode**: `{ baseUrl, auth: { authUrl } }` — custom API URLs
+ * - **Transport mode**: `{ transport }` — custom transport with paths
+ *
+ * The `platform` field (in env mode) selects which Timeback implementation to use:
+ * - `'BEYOND_AI'` (default): BeyondAI's Timeback platform
+ * - `'LEARNWITH_AI'`: Samy's LearnWith.AI platform
+ */
+type PowerPathClientConfig = ClientConfig | TransportOnlyConfig<PowerPathTransportLike> | ProviderClientConfig;
+/**
+ * Configuration for PowerPath transport.
+ */
+type PowerPathTransportConfig = BaseTransportConfig & {
+    /** API path profiles for PowerPath operations */
+    paths: PowerPathPaths;
+};
+/**
+ * Instance type of PowerPathClient.
+ */
+type PowerPathClientInstance = InstanceType<typeof PowerPathClient>;
+
+/**
+ * Assessment Resource
+ *
+ * PowerPath assessment operations: tests, attempts, and responses.
+ */
+
+/**
+ * Assessment resource for PowerPath operations.
+ */
+declare class AssessmentResource {
+    private readonly transport;
+    constructor(transport: PowerPathTransportLike);
+    createExternalPlacementTest(input: CreateExternalPlacementTestInput): Promise<ExternalTestCreateResponse>;
+    createExternalTestOut(input: CreateExternalTestOutInput): Promise<ExternalTestCreateResponse>;
+    createInternalTest(input: CreateInternalTestInput): Promise<ExternalTestCreateResponse>;
+    createNewAttempt(input: CreateNewAttemptInput): Promise<CreateAttemptResponse>;
+    finalStudentAssessmentResponse(input: FinalStudentAssessmentResponseInput): Promise<Record<string, unknown>>;
+    getAssessmentProgress(params: GetAssessmentProgressParams): Promise<GetAssessmentProgressResponse>;
+    getAttempts(params: GetAttemptsParams): Promise<GetAttemptsResponse>;
+    getNextQuestion(params: GetNextQuestionParams): Promise<Record<string, unknown>>;
+    importExternalTestAssignmentResults(params: ImportExternalTestAssignmentResultsParams): Promise<Record<string, unknown>>;
+    makeExternalTestAssignment(input: MakeExternalTestAssignmentInput): Promise<ExternalTestCreateResponse>;
+    resetAttempt(input: ResetAttemptInput): Promise<ResetAttemptResponse>;
+    testOut(params: TestOutParams): Promise<Record<string, unknown>>;
+    updateStudentQuestionResponse(input: UpdateStudentQuestionResponseInput): Promise<Record<string, unknown>>;
+}
+
+/**
+ * Lesson Plans Resource
+ *
+ * PowerPath lesson plan operations and progress tracking.
+ */
+
+/**
+ * Lesson plans resource for managing course lesson plans and progress.
+ */
+declare class LessonPlansResource {
+    private readonly transport;
+    constructor(transport: PowerPathTransportLike);
+    create(input: LessonPlansCreateInput): Promise<LessonPlanCreateResponse>;
+    get(courseId: string, userId: string): Promise<LessonPlanResponse>;
+    deleteAll(courseId: string): Promise<void>;
+    listOperations(lessonPlanId: string): Promise<LessonPlanOperationsResponse>;
+    createOperations(lessonPlanId: string, input: LessonPlanOperationsInput): Promise<LessonPlanOperationResult>;
+    sync(lessonPlanId: string): Promise<LessonPlanSyncResult>;
+    syncCourse(courseId: string): Promise<LessonPlanCourseSyncResult>;
+    recreate(lessonPlanId: string): Promise<LessonPlanSyncResult>;
+    getCourseProgress(courseId: string, studentId: string): Promise<CourseProgressResponse>;
+    getTree(lessonPlanId: string): Promise<LessonPlanResponse>;
+    getStructure(lessonPlanId: string): Promise<LessonPlanResponse>;
+    updateStudentItemResponse(input: LessonPlanUpdateStudentItemResponseInput): Promise<UpdateStudentItemResponseResult>;
+}
+
+/**
+ * Placement Resource
+ *
+ * PowerPath placement testing operations.
+ */
+
+/**
+ * Placement resource for PowerPath placement APIs.
+ */
+declare class PlacementResource {
+    private readonly transport;
+    constructor(transport: PowerPathTransportLike);
+    getPlacement(studentId: string): Promise<Record<string, unknown>>;
+    getAllPlacementTests(params: PlacementQueryParams): Promise<GetAllPlacementTestsResponse>;
+    getCurrentLevel(params: PlacementQueryParams): Promise<GetCurrentLevelResponse>;
+    getNextPlacementTest(params: PlacementQueryParams): Promise<GetNextPlacementTestResponse>;
+    getSubjectProgress(params: PlacementQueryParams): Promise<GetSubjectProgressResponse>;
+    resetUserPlacement(input: PlacementResetUserPlacementInput): Promise<ResetPlacementResponse>;
+}
+
+/**
+ * Screening Resource
+ *
+ * PowerPath screening session operations.
+ */
+
+/**
+ * Screening resource for PowerPath screening APIs.
+ */
+declare class ScreeningResource {
+    private readonly transport;
+    constructor(transport: PowerPathTransportLike);
+    getResults(userId: string): Promise<ScreeningResultsResponse>;
+    getSession(userId: string): Promise<ScreeningSessionResponse>;
+    resetSession(input: ScreeningResetSessionInput): Promise<ScreeningResetSessionResponse>;
+    assignTest(input: ScreeningAssignTestInput): Promise<ScreeningAssignTestResponse>;
+}
+
+/**
+ * Syllabus Resource
+ *
+ * PowerPath syllabus operations.
+ */
+
+/**
+ * Syllabus resource for PowerPath APIs.
+ */
+declare class SyllabusResource {
+    private readonly transport;
+    constructor(transport: PowerPathTransportLike);
+    get(courseSourcedId: string, params?: SyllabusQueryParams): Promise<SyllabusResponse>;
+}
+
+/**
+ * Pagination Utilities
+ *
+ * Re-exports the common Paginator with PowerPath-specific configuration.
+ */
+
+/**
+ * PowerPath-specific Paginator that uses the PowerPath transport.
  *
+ * Accepts params with `max` included for consumer convenience,
+ * then extracts and forwards it to the base Paginator.
+ *
+ * Validates list parameters before making any network requests.
+ */
+declare class Paginator<T> extends Paginator$1<T, unknown> {
+    constructor(transport: PowerPathTransportLike, path: string, params?: ListParams, unwrapKey?: string, transform?: (item: T) => T);
+}
+
+/**
+ * Test Assignments Resource
+ *
+ * PowerPath test assignment operations.
+ */
+
+type TestAssignmentsStreamParams = TestAssignmentsListParams & {
+    max?: number;
+};
+type TestAssignmentsAdminStreamParams = TestAssignmentsAdminParams & {
+    max?: number;
+};
+/**
+ * Test assignments resource for PowerPath APIs.
+ */
+declare class TestAssignmentsResource {
+    private readonly transport;
+    constructor(transport: PowerPathTransportLike);
+    /**
+     * Stream test assignments for a student with lazy pagination.
+     *
+     * Matches the OneRoster client pattern: returns a Paginator (AsyncIterable)
+     * with `toArray()` and `firstPage()` helpers.
+     *
+     * @param params - Query params (student required; supports limit/offset)
+     * @returns Paginator that yields `TestAssignment` items
+     */
+    stream(params: TestAssignmentsStreamParams): Paginator<TestAssignment>;
+    /**
+     * Convenience helper to fetch all test assignments for a student.
+     *
+     * @param params - List params (supports filters + limit/offset)
+     * @returns All matching test assignments
+     */
+    listAll(params: TestAssignmentsStreamParams): Promise<TestAssignment[]>;
+    list(params: TestAssignmentsListParams): Promise<TestAssignmentsListResponse>;
+    create(input: TestAssignmentsCreateInput): Promise<AssignmentResult>;
+    get(id: string): Promise<TestAssignment>;
+    update(id: string, input: TestAssignmentsUpdateInput): Promise<TestAssignment>;
+    delete(id: string): Promise<void>;
+    admin(params?: TestAssignmentsAdminParams): Promise<TestAssignmentsListResponse>;
+    /**
+     * Stream all test assignments (admin) with lazy pagination.
+     *
+     * @param params - Optional admin filters (supports student/status/subject/grade + limit/offset)
+     * @returns Paginator that yields `TestAssignment` items
+     */
+    adminStream(params?: TestAssignmentsAdminStreamParams): Paginator<TestAssignment>;
+    /**
+     * Convenience helper to fetch all test assignments (admin).
+     *
+     * @param params - Optional admin filters
+     * @returns All matching test assignments
+     */
+    adminListAll(params?: TestAssignmentsAdminStreamParams): Promise<TestAssignment[]>;
+    bulk(input: TestAssignmentsBulkInput): Promise<BulkResult>;
+    import(input: TestAssignmentsImportInput): Promise<BulkResult>;
+}
+
+/**
+ * PowerPath Client
+ *
+ * Main entry point for the PowerPath SDK.
+ */
+/**
+ * PowerPath API client for adaptive learning workflows.
+ *
+ * Provides access to PowerPath endpoints including placement testing,
+ * lesson plans, assessment flow, screening sessions, and test assignments.
+ *
+ * @example
+ * ```typescript
+ * // Environment mode (Timeback APIs)
  * const client = new PowerPathClient({
- *   env: 'staging',
+ *   env: 'staging', // or 'production'
  *   auth: {
  *     clientId: 'your-client-id',
  *     clientSecret: 'your-client-secret',
  *   },
  * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Provider mode (shared tokens)
+ * import { TimebackProvider } from '@timeback/internal-client-infra'
+ *
+ * const provider = new TimebackProvider({
+ *   platform: 'BEYOND_AI',
+ *   env: 'staging',
+ *   auth: { clientId: '...', clientSecret: '...' },
+ * })
  *
- * // Create an internal test
- * await client.assessments.createInternalTest({ ... })
+ * const client = new PowerPathClient({ provider })
  * ```
  *
- * @example Explicit mode (custom API)
+ * @example
  * ```typescript
+ * // Explicit mode (custom API)
  * const client = new PowerPathClient({
  *   baseUrl: 'https://api.example.com',
  *   auth: {
@@ -28,13 +923,107 @@
  *   },
  * })
  * ```
+ *
+ * @example
+ * ```typescript
+ * // Environment variables fallback
+ * // Set POWERPATH_BASE_URL, POWERPATH_TOKEN_URL,
+ * // POWERPATH_CLIENT_ID, POWERPATH_CLIENT_SECRET
+ * const client = new PowerPathClient()
+ * ```
+ */
+declare const PowerPathClient: {
+    new (config?: PowerPathClientConfig): {
+        readonly transport: PowerPathTransportLike;
+        readonly _provider?: _timeback_internal_client_infra.TimebackProvider | undefined;
+        readonly assessments: AssessmentResource;
+        readonly lessonPlans: LessonPlansResource;
+        readonly placement: PlacementResource;
+        readonly screening: ScreeningResource;
+        readonly syllabus: SyllabusResource;
+        readonly testAssignments: TestAssignmentsResource;
+        getTransport(): PowerPathTransportLike;
+        checkAuth(): Promise<_timeback_internal_client_infra.AuthCheckResult>;
+    };
+};
+
+/**
+ * PowerPath Client Factory
+ *
+ * Creates PowerPathClient classes bound to specific provider registries.
+ */
+
+/**
+ * Create a PowerPathClient class bound to a specific provider registry.
+ *
+ * @param registry - Provider registry to use (defaults to all Timeback platforms)
+ * @returns PowerPathClient class bound to the registry
+ */
+declare function createPowerPathClient(registry?: ProviderRegistry): {
+    new (config?: PowerPathClientConfig): {
+        /** @internal */
+        readonly transport: PowerPathTransportLike;
+        /** @internal */
+        readonly _provider?: TimebackProvider | undefined;
+        /** Create tests, attempts, and assessment responses */
+        readonly assessments: AssessmentResource;
+        /** Manage lesson plans and course progress */
+        readonly lessonPlans: LessonPlansResource;
+        /** Placement testing and progress */
+        readonly placement: PlacementResource;
+        /** Screening sessions and results */
+        readonly screening: ScreeningResource;
+        /** Course syllabus retrieval */
+        readonly syllabus: SyllabusResource;
+        /** Test assignment CRUD and bulk operations */
+        readonly testAssignments: TestAssignmentsResource;
+        /**
+         * Get the underlying transport for advanced use cases.
+         * @returns The transport instance used by this client
+         */
+        getTransport(): PowerPathTransportLike;
+        /**
+         * Verify that OAuth authentication is working.
+         * @returns Auth check result
+         * @throws {Error} If client was initialized with custom transport (no provider)
+         */
+        checkAuth(): Promise<AuthCheckResult>;
+    };
+};
+
+/**
+ * Transport Layer
+ *
+ * HTTP transport for PowerPath API communication.
+ */
+
+/**
+ * HTTP transport layer for PowerPath API communication.
+ *
+ * Uses body-based pagination (totalCount, pageNumber, pageCount in response body).
  */
-export { PowerPathClient, type PowerPathClientInstance } from './client';
-export { createPowerPathClient } from './factory';
-export type { PowerPathClientConfig } from './types/client';
-export type { Environment, EnvAuth, ExplicitAuth } from './types/client';
-export type { AuthCheckResult, ListParams, PageResult } from '@timeback/internal-client-infra';
-export type { AssignmentResult, BulkResult, TestAssignment, TestAssignmentStatus, TestAssignmentsListResponse, Attempt, CreateAttemptResponse, ExternalTestCreateResponse, GetAssessmentProgressResponse, GetAttemptsResponse, ResetAttemptResponse, GetAllPlacementTestsResponse, GetCurrentLevelResponse, GetNextPlacementTestResponse, GetSubjectProgressResponse, ResetPlacementResponse, ScreeningAssignTestResponse, ScreeningResetSessionResponse, ScreeningResultsResponse, ScreeningSessionResponse, CourseProgressResponse, LessonPlanCourseSyncResult, LessonPlanCreateResponse, LessonPlanOperation, LessonPlanOperationResult, LessonPlanOperationsResponse, LessonPlanResponse, LessonPlanSyncResult, UpdateStudentItemResponseResult, SyllabusResponse, PaginationMeta, } from '@timeback/types/protocols/powerpath';
-export type { CreateExternalPlacementTestInput, CreateExternalTestOutInput, CreateInternalTestInput, CreateNewAttemptInput, FinalStudentAssessmentResponseInput, GetAssessmentProgressParams, GetAttemptsParams, GetNextQuestionParams, ImportExternalTestAssignmentResultsParams, LessonPlanOperationInput, LessonPlanOperationsInput, LessonPlansCreateInput, LessonPlanUpdateStudentItemResponseInput, MakeExternalTestAssignmentInput, PlacementQueryParams, PlacementResetUserPlacementInput, ResetAttemptInput, ScreeningAssignTestInput, ScreeningResetSessionInput, SyllabusQueryParams, TestAssignmentsAdminParams, TestAssignmentsBulkInput, TestAssignmentsCreateInput, TestAssignmentsImportInput, TestAssignmentsListParams, TestAssignmentsUpdateInput, TestOutParams, UpdateStudentQuestionResponseInput, } from '@timeback/types/zod';
-export { Paginator, Transport } from './lib';
-//# sourceMappingURL=index.d.ts.map
+declare class Transport extends BaseTransport {
+    /** API path profiles for PowerPath operations */
+    readonly paths: PowerPathPaths;
+    constructor(config: PowerPathTransportConfig);
+    /**
+     * Make a paginated request using body-based pagination.
+     *
+     * PowerPath APIs return pagination metadata in the response body:
+     * - `totalCount`: Total items across all pages
+     * - `pageCount`: Total number of pages
+     * - `pageNumber`: Current page (1-indexed)
+     *
+     * The returned `data` is the full response body. Use Paginator's `unwrapKey`
+     * to extract the actual items (e.g., "testAssignments").
+     *
+     * @template T - Expected item type in the response
+     * @param path - API endpoint path
+     * @param options - Request options
+     * @returns Normalized paginated response with body as data
+     */
+    requestPaginated<T>(path: string, options?: RequestOptions): Promise<PaginatedResponse<T>>;
+}
+
+export { Paginator, PowerPathClient, Transport, createPowerPathClient };
+export type { AssignmentResult, Attempt, BulkResult, CourseProgressResponse, CreateAttemptResponse, CreateExternalPlacementTestInput, CreateExternalTestOutInput, CreateInternalTestInput, CreateNewAttemptInput, ExternalTestCreateResponse, FinalStudentAssessmentResponseInput, GetAllPlacementTestsResponse, GetAssessmentProgressParams, GetAssessmentProgressResponse, GetAttemptsParams, GetAttemptsResponse, GetCurrentLevelResponse, GetNextPlacementTestResponse, GetNextQuestionParams, GetSubjectProgressResponse, ImportExternalTestAssignmentResultsParams, LessonPlanCourseSyncResult, LessonPlanCreateResponse, LessonPlanOperation, LessonPlanOperationInput, LessonPlanOperationResult, LessonPlanOperationsInput, LessonPlanOperationsResponse, LessonPlanResponse, LessonPlanSyncResult, LessonPlanUpdateStudentItemResponseInput, LessonPlansCreateInput, MakeExternalTestAssignmentInput, PaginationMeta, PlacementQueryParams, PlacementResetUserPlacementInput, PowerPathClientConfig, PowerPathClientInstance, ResetAttemptInput, ResetAttemptResponse, ResetPlacementResponse, ScreeningAssignTestInput, ScreeningAssignTestResponse, ScreeningResetSessionInput, ScreeningResetSessionResponse, ScreeningResultsResponse, ScreeningSessionResponse, SyllabusQueryParams, SyllabusResponse, TestAssignment, TestAssignmentStatus, TestAssignmentsAdminParams, TestAssignmentsBulkInput, TestAssignmentsCreateInput, TestAssignmentsImportInput, TestAssignmentsListParams, TestAssignmentsListResponse, TestAssignmentsUpdateInput, TestOutParams, UpdateStudentItemResponseResult, UpdateStudentQuestionResponseInput };