@timeback/qti 0.2.2-beta.20260331191116 → 0.2.2

package/dist/index.d.ts

@@ -1,548 +1,1520 @@
-import * as _timeback_internal_client_infra from '@timeback/internal-client-infra';
-import { RequestOptions, PaginatedResponse, ClientConfig, TransportOnlyConfig, ProviderClientConfig, Paginator as Paginator$1, ListParams, BaseTransport, BaseTransportConfig, ProviderRegistry, TimebackProvider, AuthCheckResult } from '@timeback/internal-client-infra';
-export { AuthCheckResult, EnvAuth, Environment, ExplicitAuth, ListParams, PageResult } from '@timeback/internal-client-infra';
+import { ListAssessmentItemsParams, CreateAssessmentItemRequest, UpdateAssessmentItemRequest, ProcessResponseRequest, CreateAssessmentItemXmlRequest, CreateAssessmentItemJsonRequest, ListAssessmentTestsParams, CreateAssessmentTestRequest, UpdateAssessmentTestRequest, UpdateTestMetadataRequest, ListTestPartsParams, CreateTestPartRequest, UpdateTestPartRequest, ListSectionsParams, CreateSectionRequest, UpdateSectionRequest, AddItemRequest, ReorderItemsRequest, SubmitLessonRequest, SubmitQuestionRequest, ListStimuliParams, CreateStimulusRequest, UpdateStimulusRequest, ValidateRequest, ValidateBatchRequest } from '@timeback/types/zod';
+import { ListResponse, AssessmentItem, DeleteResponse, ProcessResponseResult, AssessmentTest, QuestionsResponse, TestPart, AssessmentSection, LessonFeedback, Stimulus, ValidationResult, BatchValidationResult } from '@timeback/types/protocols/qti';
+export { AssessmentItem, AssessmentItemRef, AssessmentItemType, AssessmentSection, AssessmentTest, BaseType, BatchValidationResult, Cardinality, DeleteResponse, Difficulty, FeedbackBlock, FeedbackInline, FeedbackType, Grade, ItemMetadata, LessonFeedback, ListResponse, ModalFeedback, NavigationMode, OutcomeDeclaration, PaginationMeta, ProcessResponseResult, QuestionReference, QuestionWithItem, QuestionsResponse, ResponseDeclaration, ResponseProcessing, Stimulus, SubmissionMode, TestPart, ValidationResult } from '@timeback/types/protocols/qti';
 
 /**
- * API Response Types
+ * Interface for obtaining OAuth2 access tokens.
  *
- * Types for QTI API responses.
+ * Implementations handle token caching and refresh automatically.
  */
+interface TokenProvider {
+    /**
+     * Get a valid access token.
+     *
+     * Returns a cached token if still valid, otherwise fetches a new one.
+     *
+     * @returns A valid access token string
+     * @throws {Error} If token acquisition fails
+     */
+    getToken(): Promise<string>;
+    /**
+     * Invalidate the cached token.
+     *
+     * Forces the next getToken() call to fetch a fresh token.
+     * Should be called when a request fails with 401 Unauthorized.
+     *
+     * Optional - not all implementations may support invalidation.
+     */
+    invalidate?(): void;
+}
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// LIST RESPONSE
-// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * All supported platforms.
+ */
+declare const PLATFORMS: readonly ["BEYOND_AI", "LEARNWITH_AI"];
 
 /**
- * Paginated list response from QTI API.
- *
- * QTI returns pagination metadata directly in the response body alongside items.
- */
-interface ListResponse<T> {
-	/** Array of items in this page */
-	items: T[]
-	/** Total items across all pages */
-	total: number
-	/** Current page number (1-indexed) */
-	page: number
-	/** Total number of pages */
-	pages: number
-	/** Items per page */
-	limit: number
-	/** Sort field */
-	sort: string
-	/** Sort order */
-	order: 'asc' | 'desc'
+ * Type Definitions for `@timeback/internal-logger`
+ *
+ * Central type definitions used across all logger components.
+ * These types define the contract between the logger, formatters, and consumers.
+ */
+/**
+ * Log severity levels, ordered from least to most severe.
+ *
+ * - debug: Detailed diagnostic information for developers
+ * - info: General operational messages (app started, request received)
+ * - warn: Something unexpected but not breaking (deprecated API used)
+ * - error: Something failed (request failed, database connection lost)
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Runtime environments that determine how logs are formatted.
+ *
+ * - terminal: Local development with colors and icons
+ * - ci: CI/CD pipelines with plain text (no ANSI codes)
+ * - production: JSON lines for log aggregation (DataDog, CloudWatch, etc.)
+ * - browser: Browser console with CSS styling
+ * - test: Test environment with no output
+ */
+type Environment$2 = 'terminal' | 'ci' | 'production' | 'browser' | 'test';
+/**
+ * Arbitrary key-value data attached to log entries.
+ *
+ * Context is merged into log output - in production it becomes top-level
+ * JSON fields, in terminal it's displayed as key=value pairs.
+ *
+ * @example
+ * log.info('User created', { userId: 123, email: 'foo@bar.com' })
+ */
+type LogContext = Record<string, unknown>;
+/**
+ * Configuration options for creating a logger instance.
+ */
+interface LoggerOptions {
+    /**
+     * Logger scope/namespace for categorizing logs.
+     * Child loggers append to this with colons: "api" → "api:users"
+     */
+    scope?: string;
+    /**
+     * Minimum log level to output.
+     * Logs below this level are silently ignored.
+     * @default 'info' (or 'debug' if DEBUG env var is set)
+     */
+    minLevel?: LogLevel;
+    /**
+     * Override automatic environment detection.
+     * Useful for testing or forcing a specific format.
+     */
+    environment?: Environment$2;
+    /**
+     * Default context added to every log entry from this logger.
+     * Useful for request IDs, user IDs, etc.
+     */
+    defaultContext?: LogContext;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// DELETE RESPONSE
-// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Logger instance with environment-aware formatting.
+ *
+ * Instances are lightweight and can be created freely.
+ * Common pattern: one logger per module/component.
+ */
+declare class Logger {
+    /** Namespace for this logger (e.g., "api", "api:users") */
+    private scope?;
+    /** Minimum level to output (logs below this are ignored) */
+    private minLevel;
+    /** The detected or configured environment */
+    private environment;
+    /** Function that formats and outputs log entries */
+    private formatter;
+    /** Context added to every log entry from this logger */
+    private defaultContext;
+    /**
+     * Create a new Logger instance.
+     *
+     * Usually you'd use createLogger() instead of new Logger().
+     */
+    constructor(options?: LoggerOptions);
+    /**
+     * Create a child logger with an additional scope segment.
+     *
+     * Child loggers inherit minLevel and defaultContext from parent.
+     * Scope is appended with a colon separator.
+     *
+     * @param scope - Additional scope segment to append
+     * @returns New Logger instance with extended scope
+     *
+     * @example
+     * const api = createLogger({ scope: 'api' })
+     * const users = api.child('users')
+     * users.info('Created') // scope: "api:users"
+     */
+    child(scope: string): Logger;
+    /**
+     * Create a logger with additional default context.
+     *
+     * The new context is merged with existing default context.
+     * Useful for adding request IDs, user IDs, etc.
+     *
+     * @param context - Additional context to include in all logs
+     * @returns New Logger instance with extended context
+     *
+     * @example
+     * const requestLog = log.withContext({ requestId: 'abc123' })
+     * requestLog.info('Processing') // requestId included automatically
+     */
+    withContext(context: LogContext): Logger;
+    /**
+     * Log a debug message.
+     *
+     * Use for detailed diagnostic information useful during development.
+     * These are typically filtered out in production.
+     *
+     * @param message - The log message
+     * @param context - Optional key-value context to include with the log
+     */
+    debug(message: string, context?: LogContext): void;
+    /**
+     * Log an info message.
+     *
+     * Use for general operational information.
+     * Examples: server started, request received, job completed.
+     *
+     * @param message - The log message
+     * @param context - Optional key-value context to include with the log
+     */
+    info(message: string, context?: LogContext): void;
+    /**
+     * Log a warning message.
+     *
+     * Use for unexpected but non-breaking issues.
+     * Examples: deprecated API used, retrying operation, approaching limit.
+     *
+     * @param message - The log message
+     * @param context - Optional key-value context to include with the log
+     */
+    warn(message: string, context?: LogContext): void;
+    /**
+     * Log an error message.
+     *
+     * Use for failures that need attention.
+     * Examples: request failed, database error, unhandled exception.
+     *
+     * @param message - The log message
+     * @param context - Optional key-value context to include with the log
+     */
+    error(message: string, context?: LogContext): void;
+    /**
+     * Internal method that builds the log entry and passes it to the formatter.
+     *
+     * All public log methods (debug, info, warn, error) delegate here.
+     *
+     * @param level - The log level
+     * @param message - The log message
+     * @param context - Optional key-value context to include with the log
+     */
+    private log;
+}
 
 /**
- * Response from DELETE operations.
+ * Where Clause Types
+ *
+ * Type-safe object syntax for building filter expressions.
+ */
+/**
+ * Primitive value types that can be used in filters.
+ */
+type FilterValue = string | number | boolean | Date;
+/**
+ * Operators for a single field.
+ *
+ * @example
+ * ```typescript
+ * { status: { ne: 'deleted' } }
+ * { score: { gt: 90 } }
+ * { email: { contains: '@school.edu' } }
+ * { role: { in: ['teacher', 'aide'] } }
+ * ```
  */
-interface DeleteResponse {
-	message?: string
+interface FieldOperators<T> {
+    /** Not equal */
+    ne?: T;
+    /** Greater than */
+    gt?: T;
+    /** Greater than or equal */
+    gte?: T;
+    /** Less than */
+    lt?: T;
+    /** Less than or equal */
+    lte?: T;
+    /** Contains substring (strings only) */
+    contains?: T extends string ? string : never;
+    /** Match any of the values */
+    in?: T[];
+    /** Match none of the values */
+    notIn?: T[];
 }
-
 /**
- * Base Types
+ * A field condition can be:
+ * - A direct value (implies equality)
+ * - An object with operators
+ */
+type FieldCondition<T> = T | FieldOperators<T>;
+/**
+ * Map filter field types to field conditions.
+ *
+ * Each field in F becomes an optional filter condition.
  *
- * Common types shared across QTI resources.
+ * @typeParam F - Filter fields type (e.g., UserFilterFields)
  */
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// ENUMS
-// ═══════════════════════════════════════════════════════════════════════════════
-
+type FilterFields<F> = {
+    [K in keyof F]?: FieldCondition<F[K] & FilterValue>;
+};
 /**
- * Assessment item interaction types.
- */
-type AssessmentItemType =
-	| 'choice'
-	| 'text-entry'
-	| 'extended-text'
-	| 'inline-choice'
-	| 'match'
-	| 'order'
-	| 'associate'
-	| 'select-point'
-	| 'graphic-order'
-	| 'graphic-associate'
-	| 'graphic-gap-match'
-	| 'hotspot'
-	| 'hottext'
-	| 'slider'
-	| 'drawing'
-	| 'media'
-	| 'upload'
-
+ * OR condition for combining multiple field conditions.
+ */
+interface OrCondition<F> {
+    OR: WhereClause<F>[];
+}
 /**
- * Cardinality of a response or outcome variable.
+ * A where clause for filtering entities.
+ *
+ * The type parameter F should be a filter fields type that defines
+ * the available fields and their value types for filtering.
+ *
+ * Multiple fields at the same level are combined with AND.
+ * Use `OR` for explicit OR logic.
+ *
+ * @typeParam F - Filter fields type (e.g., UserFilterFields)
+ *
+ * @example
+     * ```typescript
+     * // Simple equality (implicit AND)
+     * { status: 'active', role: 'teacher' }
+ * // → status='active' AND role='teacher'
+ * ```
+ *
+ * @example
+     * ```typescript
+     * // With operators
+     * { status: { ne: 'deleted' }, score: { gte: 90 } }
+ * // → status!='deleted' AND score>=90
+ * ```
+ *
+ * @example
+     * ```typescript
+     * // OR condition
+     * { OR: [{ role: 'teacher' }, { role: 'aide' }] }
+ * // → role='teacher' OR role='aide'
+ * ```
+ *
+ * @example
+     * ```typescript
+     * // Match multiple values
+     * { role: { in: ['teacher', 'aide'] } }
+ * // → role='teacher' OR role='aide'
+ * ```
  */
-type Cardinality = 'single' | 'multiple' | 'ordered' | 'record'
+type WhereClause<F> = FilterFields<F> | OrCondition<F>;
 
 /**
- * Base type of a response or outcome variable.
- */
-type BaseType =
-	| 'identifier'
-	| 'boolean'
-	| 'integer'
-	| 'float'
-	| 'string'
-	| 'point'
-	| 'pair'
-	| 'directedPair'
-	| 'duration'
-	| 'file'
-	| 'uri'
+ * Shared Types
+ *
+ * Common types for API client infrastructure.
+ */
 
 /**
- * Difficulty level for assessment items.
+ * Fetch function signature for HTTP requests.
+ * Avoids Bun-specific extensions on `typeof fetch`.
  */
-type Difficulty = 'easy' | 'medium' | 'hard'
-
+type FetchFn$1 = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /**
- * Grade level (K-12 + pre-K as -1).
+ * Supported Timeback platform implementations.
  */
-type Grade = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13
-
+type Platform$1 = (typeof PLATFORMS)[number];
 /**
- * Navigation mode for test parts.
+ * Supported deployment environments.
  */
-type NavigationMode = 'linear' | 'nonlinear'
-
+type Environment$1 = 'staging' | 'production';
 /**
- * Submission mode for test parts.
+ * Auth credentials for environment mode.
+ * Token URL is derived automatically from environment.
  */
-type SubmissionMode = 'individual' | 'simultaneous'
-
+interface EnvAuth$1 {
+    clientId: string;
+    clientSecret: string;
+}
 /**
- * Show/hide indicator for feedback.
+ * Auth credentials for explicit mode.
+ * Includes authUrl for custom APIs.
+ * @deprecated Use separate authUrl and ProviderAuth fields instead
  */
-type ShowHide = 'show' | 'hide'
-
+interface ExplicitAuth$1 {
+    clientId: string;
+    clientSecret: string;
+    authUrl: string;
+}
 /**
- * Sort order for list responses.
+ * Base configuration options shared by all modes.
  */
-type SortOrder = 'asc' | 'desc'
-
+interface BaseConfig$1 {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom fetch implementation */
+    fetch?: FetchFn$1;
+}
+/**
+ * Environment-based configuration for Timeback APIs.
+ */
+interface EnvConfig extends BaseConfig$1 {
+    /** Timeback platform implementation (defaults to 'BEYOND_AI') */
+    platform?: Platform$1;
+    /** Target environment - determines base URL and token URL */
+    env: Environment$1;
+    /** OAuth2 client credentials */
+    auth: EnvAuth$1;
+}
+/**
+ * Environment-based configuration with shared token provider.
+ */
+interface TokenProviderEnvConfig extends BaseConfig$1 {
+    /** Timeback platform implementation (defaults to 'BEYOND_AI') */
+    platform?: Platform$1;
+    /** Target environment - determines base URL */
+    env: Environment$1;
+    /** Shared token provider (from @timeback/auth) */
+    tokenProvider: TokenProvider;
+}
+/**
+ * Explicit URL configuration for custom APIs.
+ * Supports both authenticated and public/no-auth services.
+ */
+interface ExplicitConfig extends BaseConfig$1 {
+    /** API base URL */
+    baseUrl: string;
+    /**
+     * OAuth2 token URL. Omit for public/no-auth services.
+     * Can also be provided via auth.authUrl (legacy format).
+     */
+    authUrl?: string;
+    /**
+     * OAuth2 credentials. Required if authUrl is provided.
+     * Supports both ExplicitAuth (with authUrl) and ProviderAuth (without).
+     */
+    auth?: ExplicitAuth$1 | ProviderAuth;
+    /**
+     * Use a built-in path profile by name.
+     * Defaults to 'BEYOND_AI' if neither pathProfile nor paths is specified.
+     */
+    pathProfile?: Platform$1;
+    /** Custom path overrides (takes precedence over pathProfile) */
+    paths?: Partial<PlatformPaths>;
+    /** Not applicable to explicit config — use `EnvConfig` instead */
+    env?: never;
+}
+/**
+ * Use pre-configured transport.
+ */
+interface TransportConfig extends BaseConfig$1 {
+    /** Transport configuration */
+    transport: TransportLike;
+}
 /**
- * Feedback type.
+ * HTTP request options.
+ */
+interface RequestOptions$1 {
+    /** HTTP method */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Query parameters to append to the URL */
+    params?: Record<string, string | number | boolean | undefined>;
+    /** Request body (will be JSON-serialized) */
+    body?: unknown;
+    /** Additional headers to include */
+    headers?: Record<string, string>;
+    /**
+     * Unique identifier for this request.
+     * Used for log correlation and debugging.
+     * Auto-generated if not provided.
+     */
+    requestId?: string;
+}
+/**
+ * Duck-typed transport interface for testing and advanced use.
  */
-type FeedbackType = 'QUESTION' | 'LESSON'
+interface TransportLike {
+    /** Base URL of the API */
+    baseUrl: string;
+    /** Make an authenticated request */
+    request<T>(path: string, options?: RequestOptions$1): Promise<T>;
+}
+/**
+ * Configuration using a pre-configured transport.
+ *
+ * For advanced use cases like sharing a transport between clients
+ * or using a custom transport implementation.
+ *
+ * @template T - Transport type (defaults to TransportLike, clients should specify their full transport type)
+ */
+interface TransportOnlyConfig<T extends TransportLike = TransportLike> {
+    /** Existing transport instance */
+    transport: T;
+}
+/**
+ * Union of all client configuration types.
+ */
+type ClientConfig = EnvConfig | TokenProviderEnvConfig | ExplicitConfig | TransportConfig | Partial<ExplicitConfig>;
+/**
+ * Parameters for listing resources with pagination, sorting, and filtering.
+ *
+ * Common across all Timeback APIs (OneRoster, Edubridge, QTI, etc.).
+ *
+ * @typeParam T - Entity type for type-safe `where` clause (defaults to unknown)
+ *
+ * @example
+ * ```typescript
+ * // Type-safe where
+ * client.users.list({
+ *   where: { status: 'active', role: 'teacher' },
+ *   sort: 'familyName',
+ * })
+ * ```
+ */
+interface ListParams<T = unknown> {
+    /**
+     * Maximum items per page.
+     * @default 100
+     */
+    limit?: number;
+    /**
+     * Number of items to skip (for pagination).
+     * @default 0
+     */
+    offset?: number;
+    /**
+     * Field name to sort results by.
+     *
+     * Type-safe: only valid field names for this resource are accepted.
+     *
+     * @example
+     * ```typescript
+     * sort: 'familyName'
+     * ```
+     */
+    sort?: keyof T & string;
+    /**
+     * Sort direction.
+     * @default "asc"
+     */
+    orderBy?: 'asc' | 'desc';
+    /**
+     * Type-safe filter using object syntax.
+     *
+     * Multiple fields are combined with AND. Use `OR` for OR logic.
+     *
+     * @example
+     * ```typescript
+     * // Simple equality
+     * where: { status: 'active' }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Multiple fields (AND)
+     * where: { status: 'active', role: 'teacher' }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With operators
+     * where: { score: { gte: 90 }, status: { ne: 'deleted' } }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // OR condition
+     * where: { role: { in: ['teacher', 'aide'] } }
+     * ```
+     */
+    where?: WhereClause<T>;
+    /**
+     * Fields to include in the response.
+     * Reduces payload size by requesting only needed fields.
+     * @example ['sourcedId', 'givenName', 'familyName']
+     */
+    fields?: string[];
+    /**
+     * Free-text search across multiple fields (proprietary extension).
+     * For users: searches givenName, familyName, email.
+     * @example "john@example.com"
+     */
+    search?: string;
+    /**
+     * Maximum total items to return across all pages.
+     *
+     * Unlike `limit` (which sets page size), `max` caps the total number
+     * of items yielded by the paginator. Pagination stops once this many
+     * items have been returned.
+     *
+     * @example
+     * ```typescript
+     * // Get at most 50 users total
+     * client.users.list({ max: 50 })
+     * ```
+     */
+    max?: number;
+}
+/**
+ * Response from a paginated API request.
+ */
+interface PaginatedResponse<T> {
+    /** Array of items in this page */
+    data: T[];
+    /** Whether more pages are available */
+    hasMore: boolean;
+    /** Total count of items (if provided by server) */
+    total?: number;
+}
+/**
+ * Result of fetching a single page of resources.
+ *
+ * @typeParam T - The type of items in the page
+ */
+interface PageResult<T> {
+    /** Array of items in this page */
+    data: T[];
+    /** Whether more pages are available */
+    hasMore: boolean;
+    /** Total count of items (if provided by server) */
+    total?: number;
+    /** Offset to use for fetching the next page */
+    nextOffset?: number;
+}
+/**
+ * Options for toArray() method.
+ */
+interface ToArrayOptions {
+    /**
+     * Maximum number of items to collect.
+     *
+     * Throws an error if this limit is exceeded, preventing OOM on large datasets.
+     * Use `for await...of` to stream results instead.
+     *
+     * @default 10_000
+     * @example Set to Infinity to disable (use with caution!)
+     */
+    maxItems?: number;
+}
+/**
+ * Function that fetches a page of results.
+ * Provided by the transport layer.
+ */
+type PageFetcher<T> = (path: string, options: {
+    params: Record<string, string | number | boolean | undefined>;
+}) => Promise<PaginatedResponse<T>>;
+/**
+ * Pagination style for API requests.
+ *
+ * - `'offset'`: Uses limit/offset parameters (default, e.g., OneRoster)
+ * - `'page'`: Uses limit/page parameters (1-indexed, e.g., QTI)
+ */
+type PaginationStyle = 'offset' | 'page';
+/**
+ * Options for creating a Paginator.
+ */
+interface PaginatorOptions<T, F = unknown> {
+    /** Function to fetch a page of results */
+    fetcher: PageFetcher<T>;
+    /** API endpoint path */
+    path: string;
+    /** List parameters (filter, sort, limit, offset) */
+    params?: ListParams<F>;
+    /** Maximum total items to return across all pages (client-side cap) */
+    max?: number;
+    /** Response key containing the items array (e.g., "users") */
+    unwrapKey?: string;
+    /** Logger instance (defaults to client-common logger) */
+    logger?: Logger;
+    /** Optional transform function applied to each item before yielding */
+    transform?: (item: T) => T;
+    /**
+     * Pagination style to use for API requests.
+     *
+     * - `'offset'` (default): Sends `limit` and `offset` params
+     * - `'page'`: Sends `limit` and `page` params (1-indexed)
+     *
+     * @default 'offset'
+     */
+    paginationStyle?: PaginationStyle;
+}
+/**
+ * Result of an auth check operation.
+ */
+interface AuthCheckResult$1 {
+    /** Whether auth succeeded */
+    ok: boolean;
+    /** Time taken to complete the check (ms) */
+    latencyMs: number;
+    /** Error message if failed */
+    error?: string;
+    /** Detailed check results */
+    checks: {
+        /** Token acquisition succeeded */
+        tokenAcquisition: boolean;
+    };
+}
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// COMMON STRUCTURES
-// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Config Types
+ *
+ * Types for TimebackProvider and provider resolution.
+ */
 
 /**
- * Correct response value.
+ * Caliper API path profile.
+ * Defines paths for Caliper operations. Use `null` for unsupported operations.
  */
-interface CorrectResponse {
-	value: string[]
+interface CaliperPaths {
+    /** Path for sending events (POST) */
+    send: string;
+    /** Path for validating events (POST), null if not supported */
+    validate: string | null;
+    /** Path for listing events (GET), null if not supported */
+    list: string | null;
+    /** Path template for getting single event (GET), use {id} placeholder */
+    get: string | null;
+    /** Path template for job status (GET), use {id} placeholder */
+    jobStatus: string | null;
+}
+/**
+ * Webhook API path profile.
+ * Defines paths for webhook management operations.
+ * Nullability is at the platform level (`webhooks: WebhookPaths | null` in PlatformPaths).
+ */
+interface WebhookPaths {
+    /** Path for listing webhooks (GET) */
+    webhookList: string;
+    /** Path template for getting a single webhook (GET), use {id} placeholder */
+    webhookGet: string;
+    /** Path for creating a webhook (POST) */
+    webhookCreate: string;
+    /** Path template for updating a webhook (PUT), use {id} placeholder */
+    webhookUpdate: string;
+    /** Path template for deleting a webhook (DELETE), use {id} placeholder */
+    webhookDelete: string;
+    /** Path template for activating a webhook (PUT), use {id} placeholder */
+    webhookActivate: string;
+    /** Path template for deactivating a webhook (PUT), use {id} placeholder */
+    webhookDeactivate: string;
+    /** Path for listing all webhook filters (GET) */
+    webhookFilterList: string;
+    /** Path template for getting a single webhook filter (GET), use {id} placeholder */
+    webhookFilterGet: string;
+    /** Path for creating a webhook filter (POST) */
+    webhookFilterCreate: string;
+    /** Path template for updating a webhook filter (PUT), use {id} placeholder */
+    webhookFilterUpdate: string;
+    /** Path template for deleting a webhook filter (DELETE), use {id} placeholder */
+    webhookFilterDelete: string;
+    /** Path template for listing filters by webhook (GET), use {webhookId} placeholder */
+    webhookFiltersByWebhook: string;
+}
+/**
+ * Reporting API path profile.
+ * Defines paths for reporting MCP and REST operations.
+ * Nullability is at the platform level (`reporting: ReportingPaths | null` in PlatformPaths).
+ */
+interface ReportingPaths {
+    /** Path for the reporting MCP JSON-RPC endpoint (POST) */
+    mcp: string;
+    /** Path template for executing a saved query (GET), use {id} placeholder */
+    savedQueryExecute: string;
+    /** Path template for checking reporting group membership (GET), use {email} placeholder */
+    adminGroupCheck: string;
+    /** Path template for adding a user to the reporting group (POST), use {email} placeholder */
+    adminGroupAdd: string;
+    /** Path template for removing a user from the reporting group (DELETE), use {email} placeholder */
+    adminGroupRemove: string;
 }
-
 /**
- * Response declaration for assessment items.
+ * OneRoster API path profile.
+ * Defines the base path prefix for all OneRoster resources.
  */
-interface ResponseDeclaration {
-	identifier: string
-	cardinality: Cardinality
-	baseType?: BaseType
-	correctResponse: CorrectResponse
+interface OneRosterPaths {
+    /** Base path prefix for rostering resources (users, schools, classes, etc.) */
+    rostering: string;
+    /** Base path prefix for gradebook resources (lineItems, results, etc.) */
+    gradebook: string;
+    /** Base path prefix for resources API (digital learning resources) */
+    resources: string;
 }
-
 /**
- * Outcome declaration for items and tests.
+ * Edubridge API path profile.
+ * Defines path prefixes for Edubridge operations.
  */
-interface OutcomeDeclaration {
-	identifier: string
-	cardinality: Cardinality
-	baseType?: BaseType
+interface EdubridgePaths {
+    /** Base path prefix for all Edubridge resources */
+    base: string;
 }
-
 /**
- * Test outcome declaration with additional properties.
- */
-interface TestOutcomeDeclaration {
-	identifier: string
-	cardinality?: Cardinality
-	baseType: BaseType
-	normalMaximum?: number
-	normalMinimum?: number
-	defaultValue?: {
-		value?: unknown
-	}
+ * PowerPath API path profile.
+ * Defines path prefixes for PowerPath operations.
+ */
+interface PowerPathPaths {
+    /** Base path prefix for all PowerPath resources */
+    base: string;
 }
-
 /**
- * Inline feedback configuration.
+ * CASE API path profile.
+ * Defines path prefix for CASE (Competency and Academic Standards Exchange) operations.
  */
-interface InlineFeedback {
-	outcomeIdentifier: string
-	variableIdentifier: string
+interface CasePaths {
+    /** Base path prefix for all CASE resources */
+    base: string;
 }
-
 /**
- * Response processing configuration.
+ * CLR API path profile.
+ * Defines path prefixes for CLR (Comprehensive Learner Record) operations.
  */
-interface ResponseProcessing {
-	templateType: 'match_correct' | 'map_response'
-	responseDeclarationIdentifier: string
-	outcomeIdentifier: string
-	correctResponseIdentifier: string
-	incorrectResponseIdentifier: string
-	inlineFeedback?: InlineFeedback
+interface ClrPaths {
+    /** Path for upserting CLR credentials (POST) */
+    credentials: string;
+    /** Path for API discovery (GET) */
+    discovery: string;
+}
+/**
+ * Platform path profiles for all services.
+ * Use `null` to indicate a service is not supported on the platform.
+ */
+interface PlatformPaths {
+    caliper: CaliperPaths;
+    oneroster: OneRosterPaths;
+    webhooks: WebhookPaths | null;
+    reporting: ReportingPaths | null;
+    edubridge: EdubridgePaths | null;
+    powerpath: PowerPathPaths | null;
+    clr: ClrPaths | null;
+    case: CasePaths | null;
+}
+/**
+ * Services that have path configuration.
+ * Subset of ServiceName - excludes services without path profiles (e.g., 'qti').
+ */
+type PathEnabledService = keyof PlatformPaths;
+/**
+ * Supported Timeback platform implementations.
+ */
+type Platform = (typeof PLATFORMS)[number];
+/**
+ * Supported deployment environments.
+ */
+type Environment = 'staging' | 'production';
+/**
+ * Supported service names.
+ */
+type ServiceName = 'oneroster' | 'caliper' | 'webhooks' | 'reporting' | 'edubridge' | 'qti' | 'powerpath' | 'clr' | 'case';
+/**
+ * Resolved endpoint for a single service.
+ */
+interface ResolvedEndpoint {
+    /** Base URL for the service API */
+    baseUrl: string;
+    /** OAuth2 token URL for this endpoint. Undefined for public/no-auth services. */
+    authUrl?: string;
+}
+/**
+ * Auth credentials for a provider.
+ */
+interface ProviderAuth {
+    clientId: string;
+    clientSecret: string;
+}
+/**
+ * Configuration for environment-based provider.
+ * Uses known Timeback platform endpoints.
+ */
+interface ProviderEnvConfig {
+    /** Timeback platform (defaults to 'BEYOND_AI') */
+    platform?: Platform;
+    /** Target environment */
+    env: Environment;
+    /** OAuth2 credentials */
+    auth: ProviderAuth;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Configuration for explicit URL provider.
+ * Single base URL for all services.
+ */
+interface ProviderExplicitConfig {
+    /** Base URL for all services */
+    baseUrl: string;
+    /** OAuth2 token URL. Omit for public/no-auth services. */
+    authUrl?: string;
+    /** OAuth2 credentials. Required if authUrl is provided. */
+    auth?: ProviderAuth;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /**
+     * Use a built-in path profile by name.
+     * Defaults to 'BEYOND_AI' if neither pathProfile nor paths is specified.
+     */
+    pathProfile?: Platform;
+    /** Custom path overrides (takes precedence over pathProfile) */
+    paths?: Partial<PlatformPaths>;
+}
+/**
+ * Configuration for multi-service provider.
+ * Different URLs for different services.
+ */
+interface ProviderServicesConfig {
+    /** Per-service base URLs */
+    services: Partial<Record<ServiceName, string>>;
+    /** OAuth2 token URL. Omit for public/no-auth services. */
+    authUrl?: string;
+    /** OAuth2 credentials. Required if authUrl is provided. */
+    auth?: ProviderAuth;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /**
+     * Use a built-in path profile by name.
+     * Defaults to 'BEYOND_AI' if neither pathProfile nor paths is specified.
+     */
+    pathProfile?: Platform;
+    /** Custom path overrides (takes precedence over pathProfile) */
+    paths?: Partial<PlatformPaths>;
+}
+/**
+ * Union of all provider configuration types.
+ */
+type TimebackProviderConfig = ProviderEnvConfig | ProviderExplicitConfig | ProviderServicesConfig;
+/**
+ * Provider template - endpoints without auth.
+ * Used internally to define available platform+env combinations.
+ */
+interface ProviderTemplate {
+    platform: Platform;
+    env: Environment;
+}
+/**
+ * Registry of provider templates indexed by platform and environment.
+ *
+ * Use `satisfies ProviderRegistry` when defining a registry for type checking.
+ *
+ * @example
+ * const myRegistry = {
+ *   defaultPlatform: 'MY_PLATFORM',
+ *   templates: {
+ *     MY_PLATFORM: {
+ *       staging: { platform: 'BEYOND_AI', env: 'staging' },
+ *       production: { platform: 'BEYOND_AI', env: 'production' },
+ *     },
+ *   },
+ * } satisfies ProviderRegistry
+ */
+interface ProviderRegistry {
+    /** Default platform when none specified */
+    defaultPlatform: string;
+    /** Available templates indexed by platform → env */
+    templates: Record<string, Record<string, ProviderTemplate>>;
 }
-
 /**
- * Learning objective set for metadata.
+ * Client config that accepts a pre-built provider.
  */
-interface LearningObjectiveSet {
-	source: string
-	learningObjectiveIds: string[]
+interface ProviderClientConfig {
+    /** Pre-built provider */
+    provider: TimebackProvider;
 }
 
 /**
- * Item metadata.
+ * Timeback Provider
+ *
+ * Encapsulates platform connection configuration including endpoints and auth.
+ * Providers are complete "connection" objects that clients consume.
+ */
+
+/**
+ * Timeback Provider - encapsulates a complete platform connection.
+ *
+ * A provider contains everything needed to connect to Timeback APIs:
+ * - Service endpoints (URLs)
+ * - Authentication credentials
+ * - Configuration options
+ *
+ * Providers can be created from:
+ * - Platform + environment (uses known Timeback endpoints)
+ * - Explicit base URL (single URL for all services)
+ * - Per-service URLs (different URLs for each service)
+ *
+ * @example
+ * ```typescript
+ * // Environment-based provider (Timeback hosted)
+ * const provider = new TimebackProvider({
+ *   platform: 'BEYOND_AI',
+ *   env: 'staging',
+ *   auth: { clientId: '...', clientSecret: '...' },
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Explicit URL provider (self-hosted)
+ * const provider = new TimebackProvider({
+ *   baseUrl: 'https://api.myschool.edu',
+ *   authUrl: 'https://auth.myschool.edu/oauth/token',
+ *   auth: { clientId: '...', clientSecret: '...' },
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Per-service URLs
+ * const provider = new TimebackProvider({
+ *   services: {
+ *     oneroster: 'https://roster.myschool.edu',
+ *     caliper: 'https://analytics.myschool.edu',
+ *   },
+ *   authUrl: 'https://auth.myschool.edu/oauth/token',
+ *   auth: { clientId: '...', clientSecret: '...' },
+ * })
+ * ```
  */
-interface ItemMetadata {
-	subject?: string
-	grade?: Grade
-	difficulty?: Difficulty
-	learningObjectiveSet?: LearningObjectiveSet[]
+declare class TimebackProvider {
+    /** Platform identifier (if using known platform) */
+    readonly platform?: Platform;
+    /** Environment (if using known platform) */
+    readonly env?: Environment;
+    /** OAuth2 credentials. Undefined for public/no-auth services. */
+    readonly auth?: ProviderAuth;
+    /** Request timeout in milliseconds */
+    readonly timeout: number;
+    /** Resolved endpoints for each service */
+    /** @internal */
+    readonly _endpoints: Partial<Record<ServiceName, ResolvedEndpoint>>;
+    /** Token URL for authentication. Undefined for public/no-auth services. */
+    /** @internal */
+    readonly _authUrl?: string;
+    /** OAuth2 scope to request with access tokens. */
+    /** @internal */
+    readonly _tokenScope?: string;
+    /** API path profiles for this platform */
+    /** @internal */
+    readonly _pathProfiles: PlatformPaths;
+    /** Cached TokenManagers by authUrl (for token sharing) */
+    /** @internal */
+    readonly _tokenManagers: Map<string, TokenProvider>;
+    /**
+     * Create a new TimebackProvider.
+     *
+     * @param config - Provider configuration (env-based, explicit URL, or per-service)
+     * @throws {Error} If configuration is invalid or missing required fields
+     */
+    constructor(config: TimebackProviderConfig);
+    /**
+     * Get the resolved endpoint for a specific service.
+     *
+     * @param service - Service name (oneroster, caliper, edubridge, qti, powerpath)
+     * @returns Resolved endpoint with baseUrl and authUrl
+     * @throws If the service is not configured in this provider
+     */
+    getEndpoint(service: ServiceName): ResolvedEndpoint;
+    /**
+     * Check if a service is available in this provider.
+     *
+     * @param service - Service name to check
+     * @returns True if the service is configured
+     */
+    hasService(service: ServiceName): boolean;
+    /**
+     * Get all configured service names.
+     *
+     * @returns Array of service names available in this provider
+     */
+    getAvailableServices(): ServiceName[];
+    /**
+     * Get the token URL for this provider.
+     * @returns The token URL for authentication
+     */
+    getTokenUrl(): string | undefined;
+    /**
+     * Get endpoint with paths for a service that has path configuration.
+     *
+     * @param service - Service name that has paths in PlatformPaths
+     * @returns Resolved endpoint with baseUrl, authUrl, and paths
+     * @throws If service is not configured or not supported on this platform
+     */
+    getEndpointWithPaths<S extends PathEnabledService>(service: S & ServiceName): ResolvedEndpoint & {
+        paths: NonNullable<PlatformPaths[S]>;
+    };
+    /**
+     * Get all path profiles for this provider (raw, may contain nulls).
+     *
+     * @returns Platform path profiles
+     */
+    getPaths(): PlatformPaths;
+    /**
+     * Get paths for a specific service.
+     *
+     * @param service - Service name
+     * @returns Path configuration for the service
+     * @throws If the service is not supported on this platform
+     */
+    getServicePaths<S extends PathEnabledService>(service: S): NonNullable<PlatformPaths[S]>;
+    /**
+     * Check if a service is supported on this platform.
+     *
+     * @param service - Service name
+     * @returns true if the service has path configuration
+     */
+    hasServiceSupport(service: PathEnabledService): boolean;
+    /**
+     * Get a TokenProvider for a specific service.
+     *
+     * TokenProviders are cached by authUrl, so services sharing the same
+     * token endpoint will share the same cached OAuth tokens.
+     *
+     * @param service - Service name (oneroster, caliper, edubridge, qti, powerpath)
+     * @returns Cached TokenProvider for the service's token endpoint, or undefined for public/no-auth services
+     * @throws If the service is not configured in this provider
+     * @throws If auth is required but not configured
+     */
+    getTokenProvider(service: ServiceName): TokenProvider | undefined;
+    /**
+     * Verify that OAuth authentication is working.
+     *
+     * Attempts to acquire a token using the provider's credentials.
+     * Returns a health check result with success/failure and latency info.
+     *
+     * @returns Auth check result
+     * @throws {Error} If no auth is configured on this provider
+     */
+    checkAuth(): Promise<AuthCheckResult$1>;
+    /**
+     * Invalidate all cached OAuth tokens.
+     *
+     * Call this when closing the client or when tokens need to be refreshed.
+     * New tokens will be acquired on the next API call.
+     */
+    invalidateTokens(): void;
 }
 
 /**
- * Modal feedback element.
+ * Transport Types
+ *
+ * Types for HTTP transport layer.
  */
-interface ModalFeedback {
-	outcomeIdentifier: string
-	identifier: string
-	showHide: ShowHide
-	content: string
-	title: string
-}
 
 /**
- * Inline feedback element.
+ * Fetch function signature for HTTP requests.
+ * Avoids Bun-specific extensions on `typeof fetch`.
  */
-interface FeedbackInline {
-	outcomeIdentifier: string
-	identifier: string
-	showHide: ShowHide
-	content: string
-	class: string[]
-}
-
+type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /**
- * Block feedback element.
+ * HTTP request options.
  */
-interface FeedbackBlock {
-	outcomeIdentifier: string
-	identifier: string
-	showHide: ShowHide
-	content: string
-	class: string[]
+interface RequestOptions {
+    /** HTTP method */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Query parameters to append to the URL */
+    params?: Record<string, string | number | boolean | undefined>;
+    /** Request body (will be JSON-serialized) */
+    body?: unknown;
+    /** Additional headers to include */
+    headers?: Record<string, string>;
+    /**
+     * Unique identifier for this request.
+     * Used for log correlation and debugging.
+     * Auto-generated if not provided.
+     */
+    requestId?: string;
 }
-
 /**
- * Stylesheet reference.
+ * Auth credentials for environment mode.
+ * Token URL is derived automatically from environment.
  */
-interface Stylesheet {
-	href: string
-	type: string
+interface EnvAuth {
+    clientId: string;
+    clientSecret: string;
 }
-
 /**
- * Catalog info entry.
+ * Auth credentials for explicit mode.
+ * Requires explicit authUrl for custom APIs.
  */
-interface CatalogInfo {
-	id: string
-	support: string
-	content: string
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PAGINATION
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Pagination metadata from QTI list responses.
- */
-interface PaginationMeta {
-	/** Total items across all pages */
-	total: number
-	/** Current page number (1-indexed) */
-	page: number
-	/** Total number of pages */
-	pages: number
-	/** Items per page */
-	limit: number
-	/** Sort field */
-	sort: string
-	/** Sort order */
-	order: SortOrder
+interface ExplicitAuth {
+    clientId: string;
+    clientSecret: string;
+    authUrl: string;
 }
-
 /**
- * Assessment Items Types
- *
- * Types for QTI assessment item resources.
+ * Base configuration options shared by all modes.
  */
-
-
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// ASSESSMENT ITEM
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Assessment item entity.
- */
-interface AssessmentItem {
-	identifier: string
-	title: string
-	type: AssessmentItemType
-	qtiVersion: string
-	timeDependent: boolean
-	adaptive: boolean
-	responseDeclarations?: ResponseDeclaration[]
-	outcomeDeclarations?: OutcomeDeclaration[]
-	responseProcessing?: ResponseProcessing
-	metadata?: ItemMetadata
-	/** Raw QTI XML string */
-	rawXml: string
-	/**
-	 * Parsed XML→JSON content.
-	 * Structure varies by item type.
-	 */
-	content: Record<string, unknown>
-	modalFeedback?: ModalFeedback[]
-	feedbackInline?: FeedbackInline[]
-	feedbackBlock?: FeedbackBlock[]
-	createdAt: string
-	updatedAt: string
-	__v?: number
+interface BaseConfig {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom fetch implementation */
+    fetch?: FetchFn;
 }
-
 /**
- * Result of processing a response.
- *
- * Feedback is only present when the item has response processing
- * with feedback identifiers configured.
+ * Internal resolved transport configuration.
  */
-interface ProcessResponseResult {
-	/** Score (0.0–1.0) for the response. */
-	score: number
-	/** Feedback for the response (only present when item has feedback configured). */
-	feedback?: {
-		identifier: string
-		value: string
-	}
+interface ResolvedTransportConfig {
+    /** Base URL of the API */
+    baseUrl: string;
+    /** Request timeout in milliseconds */
+    timeout: number;
+    /** Fetch implementation */
+    fetch: FetchFn;
+    /** Token provider for authentication. Undefined for public/no-auth services. */
+    tokenProvider?: TokenProvider;
 }
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// SECTION ITEM REFERENCE
-// ═══════════════════════════════════════════════════════════════════════════════
-
 /**
- * Reference to an assessment item within a section.
+ * Transport configuration with explicit auth.
  */
-interface AssessmentItemRef {
-	identifier: string
-	/** Item reference href */
-	href: string
-	sequence?: number
+interface TransportConfigWithAuth extends BaseConfig {
+    baseUrl: string;
+    auth: ExplicitAuth;
+    tokenProvider?: never;
 }
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// SECTION
-// ═══════════════════════════════════════════════════════════════════════════════
-
 /**
- * Assessment section within a test part.
+ * Transport configuration with shared token provider.
  */
-interface AssessmentSection {
-	identifier: string
-	title: string
-	visible: boolean
-	required?: boolean
-	fixed?: boolean
-	sequence: number
-	'qti-assessment-item-ref'?: AssessmentItemRef[]
+interface TransportConfigWithTokenProvider extends BaseConfig {
+    baseUrl: string;
+    tokenProvider: TokenProvider;
+    auth?: never;
 }
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST PART
-// ═══════════════════════════════════════════════════════════════════════════════
-
 /**
- * Test part within an assessment test.
+ * Transport configuration for public/no-auth services.
  */
-interface TestPart {
-	identifier: string
-	navigationMode: NavigationMode
-	submissionMode: SubmissionMode
-	'qti-assessment-section': AssessmentSection[]
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// ASSESSMENT TEST
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Assessment test entity.
- */
-interface AssessmentTest {
-	identifier: string
-	title: string
-	qtiVersion: string
-	'qti-test-part': TestPart[]
-	/** Outcome declarations for the test. May be an empty array or absent. */
-	'qti-outcome-declaration'?: TestOutcomeDeclaration[]
-	timeLimit?: number
-	maxAttempts?: number
-	toolsEnabled?: Record<string, boolean>
-	metadata?: Record<string, unknown>
-	/** Raw QTI XML string */
-	rawXml: string
-	/**
-	 * Parsed XML→JSON content.
-	 * Structure varies by test.
-	 */
-	content: Record<string, unknown>
-	createdAt: string
-	updatedAt: string
-	__v?: number
-	isValidXml?: boolean
+interface TransportConfigNoAuth extends BaseConfig {
+    baseUrl: string;
+    auth?: never;
+    tokenProvider?: never;
 }
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// QUESTIONS RESPONSE
-// ═══════════════════════════════════════════════════════════════════════════════
-
 /**
- * Question reference within a test.
+ * Configuration for BaseTransport.
  */
-interface QuestionReference {
-	identifier: string
-	href: string
-	testPart: string
-	section: string
-}
-
+type BaseTransportConfig = TransportConfigWithAuth | TransportConfigWithTokenProvider | TransportConfigNoAuth;
 /**
- * Question with full item details.
+ * Options for creating a BaseTransport.
  */
-interface QuestionWithItem {
-	reference: QuestionReference
-	question: AssessmentItem
+interface BaseTransportOptions {
+    /** Transport configuration */
+    config: BaseTransportConfig;
+    /** Logger instance for request/response logging */
+    logger: Logger;
 }
-
 /**
- * Response from GET /assessment-tests/{identifier}/questions.
- */
-interface QuestionsResponse {
-	assessmentTest: string
-	title: string
-	totalQuestions: number
-	questions: QuestionWithItem[]
+ * Result of an auth check operation.
+ */
+interface AuthCheckResult {
+    /** Whether auth succeeded */
+    ok: boolean;
+    /** Time taken to complete the check (ms) */
+    latencyMs: number;
+    /** Error message if failed */
+    error?: string;
+    /** Detailed check results */
+    checks: {
+        /** Token acquisition succeeded */
+        tokenAcquisition: boolean;
+    };
 }
 
 /**
- * Lesson Types
+ * Base Transport Layer
+ *
+ * HTTP transport with OAuth2 authentication, retries, and error handling.
+ * Clients can extend this for protocol-specific features.
  *
- * Types for QTI lesson and question feedback resources.
- */
-
-
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LESSON FEEDBACK
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Lesson feedback entity.
  */
-interface LessonFeedback {
-	questionId?: string
-	userId: string
-	feedback: string
-	type: FeedbackType
-	lessonId: string
-	humanApproved?: boolean | boolean[]
-}
-
 /**
- * Stimuli Types
+ * Base HTTP transport layer for API communication.
+ *
+ * Handles OAuth2 authentication, request/response lifecycle,
+ * and automatic retries for transient failures.
  *
- * Types for QTI stimulus resources.
+ * Clients can extend this class to add protocol-specific features
+ * like custom error parsing or pagination.
  */
-
-
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// STIMULUS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Stimulus entity.
- */
-interface Stimulus {
-	identifier: string
-	title: string
-	label?: string
-	language?: string
-	stylesheet?: Stylesheet
-	catalogInfo: CatalogInfo[]
-	toolName?: string
-	toolVersion?: string
-	metadata?: Record<string, unknown>
-	/** Raw QTI XML string */
-	rawXml: string
-	/**
-	 * Parsed XML→JSON content.
-	 * Structure varies.
-	 */
-	content: Record<string, unknown>
-	createdAt: string
-	updatedAt: string
-	__v?: number
+declare class BaseTransport {
+    protected readonly config: ResolvedTransportConfig;
+    protected readonly log: Logger;
+    /**
+     * Create a new BaseTransport instance.
+     *
+     * @param options - Transport options with config and logger
+     */
+    constructor(options: BaseTransportOptions);
+    /**
+     * The base URL for API requests.
+     * @returns The base URL
+     */
+    get baseUrl(): string;
+    /**
+     * Make an authenticated request to the API.
+     *
+     * Automatically retries on transient failures (429, 503).
+     *
+     * @template T - Expected response type
+     * @param path - API endpoint path
+     * @param options - Request options including method, params, body
+     * @returns Parsed JSON response
+     * @throws {ApiError} On API errors (4xx/5xx responses)
+     */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Check whether a resource exists at the given path.
+     *
+     * Returns `true` for successful 2xx responses, `false` only for 404 Not Found,
+     * and rethrows all other errors.
+     *
+     * @param path - API endpoint path
+     * @param options - Request options including method, params, body
+     * @returns Promise resolving to whether the resource exists
+     */
+    exists(path: string, options?: RequestOptions): Promise<boolean>;
+    /**
+     * Make a raw request, returning the Response object.
+     *
+     * ## Retry Behavior
+     * Automatically retries on transient failures (429, 503) with exponential
+     * backoff. Respects Retry-After header when present.
+     *
+     * ## Timeout Behavior
+     * Uses an operation-level timeout that spans ALL retry attempts.
+     * If configured timeout is 30s, the entire operation (including retries
+     * and backoff delays) must complete within 30s total.
+     *
+     * ## Flow
+     * 1. Build URL from path and query params
+     * 2. Start operation timer
+     * 3. Loop up to MAX_RETRIES times:
+     *    a. Check if we've exceeded the operation deadline
+     *    b. Get OAuth token (may be cached)
+     *    c. Make the HTTP request with per-request timeout
+     *    d. If 429/503 and not last attempt → calculate backoff and retry
+     *    e. If other error → throw appropriate ApiError subclass
+     *    f. If success → return response
+     * 4. If all retries exhausted → throw "Max retries exceeded"
+     *
+     * @param path - API endpoint path (relative to baseUrl)
+     * @param options - Request options (method, params, body, headers)
+     * @returns Raw fetch Response for custom handling
+     * @throws {ApiError} On timeout, non-retryable errors, or max retries exceeded
+     */
+    requestRaw(path: string, options?: RequestOptions): Promise<Response>;
+    /**
+     * Get a valid OAuth2 access token.
+     * @returns Promise resolving to access token or undefined
+     */
+    protected getAccessToken(): Promise<string | undefined>;
+    /**
+     * Construct full URL with query parameters.
+     *
+     * @param path - The relative path or absolute URL
+     * @param params - Query parameters
+     * @returns Full URL string
+     * @throws {Error} If path is an absolute URL (security protection)
+     */
+    protected buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string;
+    /**
+     * Parse successful response or delegate to error handler.
+     * @param response - The fetch Response
+     * @returns Parsed response as type T
+     */
+    protected handleResponse<T>(response: Response): Promise<T>;
+    /**
+     * Parse JSON response with context-preserving error handling.
+     *
+     * Unlike raw `response.json()`, this method:
+     * - Logs structured error context (URL, status, content-type, body preview)
+     * - Throws `ApiError` with `parseError` and `body` in the response object
+     * - Aids debugging when upstream services return malformed JSON
+     *
+     * @template T - Expected shape of the parsed response
+     * @param response - The fetch Response to parse
+     * @returns Parsed JSON as type T
+     * @throws {ApiError} When JSON parsing fails, with status code and body preview
+     */
+    protected parseJsonResponse<T>(response: Response): Promise<T>;
+    /**
+     * Parse error response and throw appropriate ApiError subclass.
+     *
+     * Handles both JSON and non-JSON error responses gracefully.
+     * Clients can override this to add protocol-specific error parsing.
+     *
+     * @param response - The error Response (status >= 400)
+     * @param requestId - Request ID for log correlation
+     * @throws {UnauthorizedError} For 401 responses (also invalidates token)
+     * @throws {ForbiddenError} For 403 responses
+     * @throws {NotFoundError} For 404 responses
+     * @throws {ValidationError} For 422 responses
+     * @throws {ApiError} For all other error status codes
+     */
+    protected handleErrorResponse(response: Response, requestId?: string): Promise<never>;
+    /**
+     * Extract error message from response body.
+     *
+     * Checks common error formats:
+     * - `message` (most APIs)
+     * - `error` (some APIs)
+     * - `imsx_description` (IMS Global: OneRoster, Caliper, QTI)
+     *
+     * Override in client transports for API-specific error formats
+     * not covered here (e.g., Edubridge's `errors[]` array format).
+     *
+     * @param body - The error response body
+     * @param fallback - Fallback message if none found
+     * @returns Extracted error message
+     */
+    protected extractErrorMessage(body: unknown, fallback: string): string;
+    /**
+     * Delay execution for retry backoff.
+     *
+     * @param ms - Number of milliseconds to delay
+     * @returns Promise that resolves after delay
+     */
+    protected sleep(ms: number): Promise<void>;
+    /**
+     * Parse Retry-After header value.
+     *
+     * Handles both formats per RFC 7231:
+     * - Numeric seconds: "120"
+     * - HTTP-date: "Wed, 21 Oct 2025 07:28:00 GMT"
+     *
+     * @param retryAfter - Retry-After header value
+     * @param attempt - Current attempt number (0-based)
+     * @returns Delay in milliseconds
+     */
+    protected parseRetryAfter(retryAfter: string | null, attempt: number): number;
 }
 
 /**
- * Validation Types
+ * Pagination Utilities
  *
- * Types for QTI XML validation resources.
+ * Helpers for iterating over paginated API responses.
  */
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// VALIDATION
-// ═══════════════════════════════════════════════════════════════════════════════
-
 /**
- * Single validation result.
+ * Async iterator for paginated API responses.
  *
- * When the entity exists, the response includes `xmlContent` and `validationErrors`.
- * When the entity is not found (batch only), the response includes `error` instead.
- */
-interface ValidationResult {
-	success: boolean
-	entityId: string
-	xmlContent?: string
-	validationErrors?: string[]
-	message: string
-	error?: string
-}
-
-/**
- * Batch validation result.
+ * Automatically fetches subsequent pages as you iterate, making it easy
+ * to process large datasets without manual pagination handling.
+ *
+ * @typeParam T - The type of items being paginated
+ *
+ * @example
+ * ```typescript
+ * // Iterate over all items
+ * for await (const user of paginator) {
+ *   console.log(user.name)
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Collect all items into an array
+ * const allUsers = await paginator.toArray()
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Get just the first page
+ * const page = await paginator.firstPage()
+ * console.log(`Got ${page.data.length} of ${page.total} users`)
+ * ```
  */
-interface BatchValidationResult {
-	results: ValidationResult[]
+declare class Paginator$1<T, F = unknown> implements AsyncIterable<T> {
+    private readonly fetcher;
+    private readonly path;
+    private readonly params;
+    private readonly max?;
+    private readonly unwrapKey?;
+    private readonly log;
+    private readonly transform?;
+    private readonly paginationStyle;
+    /**
+     * Create a new Paginator.
+     *
+     * @param options - Paginator configuration
+     */
+    constructor(options: PaginatorOptions<T, F>);
+    /**
+     * Builds query parameters for the paginated request.
+     *
+     * Converts the type-safe `where` clause to a filter string for the API,
+     * and merges with other list parameters (sort, orderBy, fields, search).
+     * Excludes client-side params like `max` that shouldn't be sent to the API.
+     *
+     * Uses the configured pagination style:
+     * - `'offset'`: Sends `{ limit, offset }` params
+     * - `'page'`: Sends `{ limit, page }` params (1-indexed)
+     *
+     * @param limit - Maximum items per page
+     * @param offset - Number of items to skip (converted to page if using page style)
+     * @returns Query parameters ready for the request
+     */
+    private buildRequestParams;
+    /**
+     * Extracts and validates items from response data.
+     *
+     * Handles two response formats:
+     * - Direct array: `[item1, item2, ...]`
+     * - Wrapped object: `{ users: [item1, item2, ...] }` (when unwrapKey is set)
+     *
+     * @param data - Raw response data from the API
+     * @param pageNumber - Current page number (for error messages)
+     * @returns Validated array of items
+     * @throws {Error} If extracted data is not an array
+     */
+    private extractItems;
+    /**
+     * Validates that extracted data is an array.
+     *
+     * Protects against malformed API responses that could cause:
+     * - Infinite loops (empty non-array values)
+     * - Unexpected iteration (strings yield characters, not items)
+     * - Runtime crashes (objects are not iterable)
+     *
+     * @param data - Data to validate (should be an array)
+     * @param pageNumber - Current page number (for error messages)
+     * @returns The data cast to T[] if valid
+     * @throws {Error} If data is not an array (with helpful message including unwrapKey)
+     */
+    private validateItems;
+    /**
+     * Determines if more pages are available based on response metadata.
+     *
+     * Uses a three-tier fallback strategy:
+     * 1. Link header (most reliable)
+     * 2. X-Total-Count header
+     * 3. Full page heuristic (assumes more if page is full and no total provided)
+     *
+     * Always returns false if the page is empty to prevent infinite loops
+     * from buggy servers that return hasMore: true with no data.
+     * @param response - Response with pagination metadata
+     * @param itemCount - Number of items in current page
+     * @param offset - Current offset
+     * @param limit - Current limit
+     * @returns True if more pages are available
+     */
+    private hasMorePages;
+    /**
+     * Async iterator implementation.
+     *
+     * Yields items one at a time, automatically fetching new pages as needed.
+     * Stops when `max` items have been yielded (if specified).
+     *
+     * @yields Items of type T from paginated responses
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /**
+     * Collect all items into an array.
+     *
+     * **Warning**: Use with caution on large datasets as this loads
+     * all items into memory. Consider iterating with `for await...of`
+     * for better memory efficiency.
+     *
+     * @param options - Optional configuration
+     * @param options.maxItems - Maximum items to collect (default: 10,000).
+     *   Throws if limit is reached. Set to `Infinity` to disable.
+     * @returns Promise resolving to an array of all items
+     * @throws {Error} If maxItems limit is exceeded
+     */
+    toArray(options?: ToArrayOptions): Promise<T[]>;
+    /**
+     * Fetch only the first page of results.
+     *
+     * Useful when you need pagination metadata (total count, hasMore)
+     * or want to implement custom pagination UI.
+     *
+     * @returns Promise resolving to the first page with metadata
+     */
+    firstPage(): Promise<PageResult<T>>;
 }
 
 /**
@@ -639,291 +1611,6 @@ declare class Transport extends BaseTransport {
     requestPaginated<T>(path: string, options?: RequestOptions): Promise<PaginatedResponse<T>>;
 }
 
-type input<T> = T extends {
-    _zod: {
-        input: any;
-    };
-} ? T["_zod"]["input"] : unknown;
-
-/**
- * QTI Schemas
- *
- * Strict Zod schemas for QTI-related CLI/API inputs.
- *
- * These are intentionally "full-shape" schemas so CLI code can validate input
- * and then pass typed values directly into the QTI SDK without widening/casting.
- */
-
-
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LIST PARAMS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-declare const QtiPaginationParams = z
-	.object({
-		page: z.number().int().positive().optional(),
-		limit: z.number().int().positive().optional(),
-		sort: z.string().optional(),
-		order: z.enum(['asc', 'desc']).optional(),
-	})
-	.strict()
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// ASSESSMENT ITEMS (REQUEST INPUTS)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * XML-format creation input.
- *
- * The preferred way to create assessment items — send raw QTI 3.0 XML and the
- * server validates it against IMS QTI XSDs.
- */
-declare const QtiAssessmentItemXmlCreateInput = z
-	.object({
-		format: z.string().pipe(z.literal('xml')),
-		xml: NonEmptyString,
-		metadata: QtiItemMetadata.optional(),
-	})
-	.strict()
-
-/**
- * JSON-format creation input (experimental on the server side).
- *
- * Sends a structured/parsed representation of a QTI item.
- */
-declare const QtiAssessmentItemJsonCreateInput = z
-	.object({
-		identifier: NonEmptyString,
-		title: NonEmptyString,
-		type: QtiAssessmentItemType,
-		qtiVersion: z.string().optional(),
-		timeDependent: z.boolean().optional(),
-		adaptive: z.boolean().optional(),
-		responseDeclarations: z.array(QtiResponseDeclaration).optional(),
-		outcomeDeclarations: z.array(QtiOutcomeDeclaration).optional(),
-		responseProcessing: QtiResponseProcessing.optional(),
-		metadata: QtiItemMetadata.optional(),
-		modalFeedback: z.array(QtiModalFeedback).optional(),
-		feedbackInline: z.array(QtiFeedbackInline).optional(),
-		feedbackBlock: z.array(QtiFeedbackBlock).optional(),
-	})
-	.strict()
-
-/**
- * Union of XML and JSON creation inputs for assessment items.
- *
- * Accepts either `{ format: 'xml', xml, metadata? }` or the structured JSON
- * shape with `{ identifier, title, type, ... }`.
- */
-declare const QtiAssessmentItemCreateInput = z.union([
-	QtiAssessmentItemXmlCreateInput,
-	QtiAssessmentItemJsonCreateInput,
-])
-
-declare const QtiAssessmentItemUpdateInput = z
-	.object({
-		identifier: NonEmptyString.optional(),
-		title: NonEmptyString,
-		type: QtiAssessmentItemType,
-		qtiVersion: z.string().optional(),
-		timeDependent: z.boolean().optional(),
-		adaptive: z.boolean().optional(),
-		responseDeclarations: z.array(QtiResponseDeclaration).optional(),
-		outcomeDeclarations: z.array(QtiOutcomeDeclaration).optional(),
-		responseProcessing: QtiResponseProcessing.optional(),
-		metadata: QtiItemMetadata.optional(),
-		modalFeedback: z.array(QtiModalFeedback).optional(),
-		feedbackInline: z.array(QtiFeedbackInline).optional(),
-		feedbackBlock: z.array(QtiFeedbackBlock).optional(),
-		rawXml: z.string(),
-		content: z.record(z.string(), z.unknown()),
-	})
-	.strict()
-
-declare const QtiAssessmentItemProcessResponseInput = z
-	.object({
-		identifier: NonEmptyString,
-		response: z.union([z.string(), z.array(z.string())]),
-	})
-	.strict()
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// ASSESSMENT TESTS (REQUEST INPUTS)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-declare const QtiAssessmentItemRef = z
-	.object({
-		identifier: NonEmptyString,
-		href: NonEmptyString,
-		sequence: z.number().int().positive().optional(),
-	})
-	.strict()
-
-declare const QtiAssessmentSection = z
-	.object({
-		identifier: NonEmptyString,
-		title: NonEmptyString,
-		visible: z.boolean(),
-		required: z.boolean().optional(),
-		fixed: z.boolean().optional(),
-		sequence: z.number().int().positive(),
-		'qti-assessment-item-ref': z.array(QtiAssessmentItemRef).optional(),
-	})
-	.strict()
-
-declare const QtiTestPart = z
-	.object({
-		identifier: NonEmptyString,
-		navigationMode: z.string().pipe(QtiNavigationMode),
-		submissionMode: z.string().pipe(QtiSubmissionMode),
-		'qti-assessment-section': z.array(QtiAssessmentSection),
-	})
-	.strict()
-
-declare const QtiReorderItemsInput = z
-	.object({
-		items: z.array(QtiAssessmentItemRef).min(1),
-	})
-	.strict()
-
-declare const QtiAssessmentTestMetadataUpdateInput = z
-	.object({
-		metadata: z.record(z.string(), z.unknown()).optional(),
-	})
-	.strict()
-
-declare const QtiAssessmentTestCreateInput = z
-	.object({
-		identifier: NonEmptyString,
-		title: NonEmptyString,
-		qtiVersion: z.string().optional(),
-		toolName: z.string().optional(),
-		toolVersion: z.string().optional(),
-		timeLimit: z.number().optional(),
-		maxAttempts: z.number().optional(),
-		toolsEnabled: z.record(z.string(), z.boolean()).optional(),
-		metadata: z.record(z.string(), z.unknown()).optional(),
-		'qti-test-part': z.array(QtiTestPart),
-		'qti-outcome-declaration': z.array(QtiTestOutcomeDeclaration).optional(),
-	})
-	.strict()
-
-declare const QtiAssessmentTestUpdateInput = z
-	.object({
-		identifier: NonEmptyString.optional(),
-		title: NonEmptyString,
-		qtiVersion: z.string().optional(),
-		toolName: z.string().optional(),
-		toolVersion: z.string().optional(),
-		timeLimit: z.number().optional(),
-		maxAttempts: z.number().optional(),
-		toolsEnabled: z.record(z.string(), z.boolean()).optional(),
-		metadata: z.record(z.string(), z.unknown()).optional(),
-		'qti-test-part': z.array(QtiTestPart),
-		'qti-outcome-declaration': z.array(QtiTestOutcomeDeclaration).optional(),
-	})
-	.strict()
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// STIMULI (REQUEST INPUTS)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-declare const QtiStimulusCreateInput = z
-	.object({
-		identifier: NonEmptyString,
-		title: NonEmptyString,
-		label: z.string().optional(),
-		language: z.string().optional(),
-		stylesheet: QtiStylesheet.optional(),
-		content: z.string(),
-		catalogInfo: z.array(QtiCatalogInfo).optional(),
-		toolName: z.string().optional(),
-		toolVersion: z.string().optional(),
-		metadata: z.record(z.string(), z.unknown()).optional(),
-	})
-	.strict()
-
-declare const QtiStimulusUpdateInput = z
-	.object({
-		identifier: NonEmptyString.optional(),
-		title: NonEmptyString,
-		label: z.string().optional(),
-		language: z.string().optional(),
-		stylesheet: QtiStylesheet.optional(),
-		content: z.string(),
-		catalogInfo: z.array(QtiCatalogInfo).optional(),
-		toolName: z.string().optional(),
-		toolVersion: z.string().optional(),
-		metadata: z.record(z.string(), z.unknown()).optional(),
-	})
-	.strict()
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// VALIDATION (REQUEST INPUTS)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-declare const QtiValidateInput = z
-	.object({
-		xml: z.string().optional(),
-		schema: QtiValidationSchema,
-		entityId: z.string().optional(),
-	})
-	.strict()
-
-declare const QtiValidateBatchInput = z
-	.object({
-		xml: z.array(z.string()),
-		schema: QtiValidationSchema,
-		entityIds: z.array(z.string()),
-	})
-	.strict()
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LESSON FEEDBACK (REQUEST INPUTS)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-declare const QtiLessonFeedbackInput = z
-	.object({
-		questionId: z.string().optional(),
-		userId: NonEmptyString,
-		feedback: NonEmptyString,
-		lessonId: NonEmptyString,
-		humanApproved: z.boolean().optional(),
-	})
-	.strict()
-
-type ListAssessmentTestsParams = input<typeof QtiPaginationParams>
-type ListTestPartsParams = input<typeof QtiPaginationParams>
-type ListSectionsParams = input<typeof QtiPaginationParams>
-type ListAssessmentItemsParams = input<typeof QtiPaginationParams>
-type ListStimuliParams = input<typeof QtiPaginationParams>
-
-type CreateAssessmentTestRequest = input<typeof QtiAssessmentTestCreateInput>
-type UpdateAssessmentTestRequest = input<typeof QtiAssessmentTestUpdateInput>
-type UpdateTestMetadataRequest = input<typeof QtiAssessmentTestMetadataUpdateInput>
-type CreateTestPartRequest = input<typeof QtiTestPart>
-type UpdateTestPartRequest = input<typeof QtiTestPart>
-type CreateSectionRequest = input<typeof QtiAssessmentSection>
-type UpdateSectionRequest = input<typeof QtiAssessmentSection>
-type AddItemRequest = input<typeof QtiAssessmentItemRef>
-type ReorderItemsRequest = input<typeof QtiReorderItemsInput>
-
-type CreateAssessmentItemXmlRequest = input<typeof QtiAssessmentItemXmlCreateInput>
-type CreateAssessmentItemJsonRequest = input<typeof QtiAssessmentItemJsonCreateInput>
-type CreateAssessmentItemRequest = input<typeof QtiAssessmentItemCreateInput>
-type UpdateAssessmentItemRequest = input<typeof QtiAssessmentItemUpdateInput>
-type ProcessResponseRequest = input<typeof QtiAssessmentItemProcessResponseInput>
-
-type CreateStimulusRequest = input<typeof QtiStimulusCreateInput>
-type UpdateStimulusRequest = input<typeof QtiStimulusUpdateInput>
-
-type ValidateRequest = input<typeof QtiValidateInput>
-type ValidateBatchRequest = input<typeof QtiValidateBatchInput>
-
-type SubmitLessonRequest = input<typeof QtiLessonFeedbackInput>
-type SubmitQuestionRequest = input<typeof QtiLessonFeedbackInput>
-
 /**
  * Assessment Items Resource
  *
@@ -1493,7 +2180,7 @@ declare class ValidateResource {
 declare const QtiClient: {
     new (config?: QtiClientConfig): {
         readonly transport: QtiTransportLike;
-        readonly _provider?: _timeback_internal_client_infra.TimebackProvider | undefined;
+        readonly _provider?: TimebackProvider | undefined;
         readonly assessmentItems: AssessmentItemsResource;
         readonly assessmentTests: AssessmentTestsResource;
         readonly stimuli: StimuliResource;
@@ -1501,7 +2188,7 @@ declare const QtiClient: {
         readonly lesson: LessonResource;
         readonly general: GeneralResource;
         getTransport(): QtiTransportLike;
-        checkAuth(): Promise<_timeback_internal_client_infra.AuthCheckResult>;
+        checkAuth(): Promise<AuthCheckResult>;
     };
 };
 
@@ -1550,4 +2237,4 @@ declare function createQtiClient(registry?: ProviderRegistry): {
 };
 
 export { Paginator, QtiClient, Transport, createQtiClient };
-export type { AssessmentItem, AssessmentItemRef, AssessmentItemType, AssessmentSection, AssessmentTest, BaseType, BatchValidationResult, Cardinality, DeleteResponse, Difficulty, FeedbackBlock, FeedbackInline, FeedbackType, Grade, ItemMetadata, LessonFeedback, ListResponse, ModalFeedback, NavigationMode, OutcomeDeclaration, PaginationMeta, ProcessResponseResult, QtiClientConfig, QtiClientInstance, QuestionReference, QuestionWithItem, QuestionsResponse, ResponseDeclaration, ResponseProcessing, Stimulus, SubmissionMode, TestPart, ValidationResult };
+export type { AuthCheckResult, EnvAuth, Environment, ExplicitAuth, ListParams, PageResult, QtiClientConfig, QtiClientInstance };