@timeback/caliper 0.1.7-beta.20260309185602 → 0.2.0

package/dist/{chunk-xkrn9zda.js → chunk-m7qcd4j8.js}

@@ -121,12 +121,14 @@ var LEARNWITHAI_QTI_URLS = {
 var PLATFORM_ENDPOINTS = {
   BEYOND_AI: {
     token: BEYONDAI_TOKEN_URLS,
+    tokenScope: undefined,
     api: BEYONDAI_API_URLS,
     caliper: BEYONDAI_CALIPER_URLS,
     qti: BEYONDAI_QTI_URLS
   },
   LEARNWITH_AI: {
     token: LEARNWITHAI_TOKEN_URLS,
+    tokenScope: "https://purl.imsglobal.org/spec/caliper/v1p2/scope/events.write",
     api: LEARNWITHAI_API_URLS,
     caliper: LEARNWITHAI_CALIPER_URLS,
     qti: LEARNWITHAI_QTI_URLS
@@ -510,7 +512,7 @@ class TokenManager {
         Authorization: `Basic ${credentials}`,
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: "grant_type=client_credentials"
+      body: this.config.scope ? `grant_type=client_credentials&scope=${encodeURIComponent(this.config.scope)}` : "grant_type=client_credentials"
     });
     const duration = Math.round(performance.now() - start);
     if (!response.ok) {
@@ -574,7 +576,7 @@ var BEYONDAI_PATHS = {
 };
 var LEARNWITHAI_PATHS = {
   caliper: {
-    send: "/events/1.0/",
+    send: "/caliper/v1p2",
     validate: null,
     list: null,
     get: null,
@@ -589,7 +591,9 @@ var LEARNWITHAI_PATHS = {
   edubridge: null,
   powerpath: null,
   clr: null,
-  case: null
+  case: {
+    base: "/case/1.1"
+  }
 };
 var PLATFORM_PATHS = {
   BEYOND_AI: BEYONDAI_PATHS,
@@ -626,6 +630,7 @@ class TimebackProvider {
   timeout;
   endpoints;
   authUrl;
+  tokenScope;
   pathProfiles;
   tokenManagers = new Map;
   constructor(config) {
@@ -641,6 +646,7 @@ class TimebackProvider {
         throw new Error(`Unknown platform: ${platform}`);
       }
       this.authUrl = platformEndpoints.token[env];
+      this.tokenScope = platformEndpoints.tokenScope ?? undefined;
       this.pathProfiles = PLATFORM_PATHS[platform] ?? BEYONDAI_PATHS;
       this.endpoints = {
         oneroster: {
@@ -766,7 +772,8 @@ class TimebackProvider {
         credentials: {
           clientId: this.auth.clientId,
           clientSecret: this.auth.clientSecret
-        }
+        },
+        scope: this.tokenScope
       });
       this.tokenManagers.set(authUrl, manager);
     }
@@ -784,7 +791,8 @@ class TimebackProvider {
         credentials: {
           clientId: this.auth.clientId,
           clientSecret: this.auth.clientSecret
-        }
+        },
+        scope: this.tokenScope
       });
       this.tokenManagers.set(this.authUrl, manager);
     }
@@ -1515,7 +1523,7 @@ function issue(path, message) {
 function validateWithSchema(schema, data, context) {
   const result = schema.safeParse(data);
   if (result.success) {
-    return;
+    return result.data;
   }
   const issues = result.error.issues.map((errorIssue) => ({
     path: errorIssue.path.join(".") || "(root)",

package/dist/{chunk-9wzc4pgh.js → chunk-mr61jp0f.js}

@@ -6,5 +6,6 @@ var CALIPER_ENV_VARS = {
   clientSecret: ["TIMEBACK_API_CLIENT_SECRET", "TIMEBACK_CLIENT_SECRET", "CALIPER_CLIENT_SECRET"]
 };
 var CALIPER_DATA_VERSION = "http://purl.imsglobal.org/ctx/caliper/v1p2";
+var QUESTION_RESULT_SCORE_TYPE = "QUESTION_RESULT";
 
-export { CALIPER_ENV_VARS, CALIPER_DATA_VERSION };
+export { CALIPER_ENV_VARS, CALIPER_DATA_VERSION, QUESTION_RESULT_SCORE_TYPE };

package/dist/constants.d.ts

@@ -21,4 +21,8 @@ export declare const CALIPER_ENV_VARS: {
  * Caliper JSON-LD context version.
  */
 export declare const CALIPER_DATA_VERSION = "http://purl.imsglobal.org/ctx/caliper/v1p2";
+/**
+ * Score type for individual question results (LWAI GradeEvent).
+ */
+export declare const QUESTION_RESULT_SCORE_TYPE: "QUESTION_RESULT";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,oBAAoB,+CAA+C,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,oBAAoB,+CAA+C,CAAA;AAEhF;;GAEG;AACH,eAAO,MAAM,0BAA0B,mBAA6B,CAAA"}

package/dist/errors.js

@@ -5,7 +5,7 @@ import {
   NotFoundError,
   UnauthorizedError,
   ValidationError
-} from "./chunk-xkrn9zda.js";
+} from "./chunk-m7qcd4j8.js";
 import"./chunk-6jf1natv.js";
 export {
   ValidationError,

package/dist/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1D,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAC1G,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAoB,MAAM,SAAS,CAAA;AAE1F;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,gBAA4C;;QAQxF,gBAAgB;;QAGhB,gBAAgB;;QAGhB,iFAAiF;;QAEjF,qFAAqF;;QA+CrF;;;WAGG;;QAKH;;;;WAIG;;;EASJ"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1D,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAoB,MAAM,SAAS,CAAA;AAE1F;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,gBAA4C;;QAQxF,gBAAgB;;QAGhB,gBAAgB;;QAGhB,iFAAiF;;QAEjF,qFAAqF;;QA+CrF;;;WAGG;;QAKH;;;;WAIG;;;EASJ"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _timeback_internal_client_infra from '@timeback/internal-client-infra';
-import { ClientConfig, TransportOnlyConfig, CaliperPaths, RequestOptions, PaginatedResponse, ProviderClientConfig, BaseTransportConfig, Paginator as Paginator$1, ListParams, ProviderRegistry, TimebackProvider, AuthCheckResult, BaseTransport } from '@timeback/internal-client-infra';
+import { ClientConfig, TransportOnlyConfig, CaliperPaths, RequestOptions, PaginatedResponse, ProviderClientConfig, BaseTransportConfig, BaseTransport, Paginator as Paginator$1, ListParams, ProviderRegistry, TimebackProvider, AuthCheckResult } from '@timeback/internal-client-infra';
 export { AuthCheckResult, EnvAuth, Environment, ExplicitAuth } from '@timeback/internal-client-infra';
 
 /**
@@ -469,23 +469,28 @@ type CaliperProfile =
 	| 'TimebackProfile'
 
 /**
- * Base Caliper entity - can be a URI string or an object with properties.
+ * Base Caliper entity representation.
+ *
+ * Many Caliper fields can be provided either as an IRI string or as an
+ * object-shaped entity, so the shared protocol model keeps this flexible.
  */
 type CaliperEntity = string | { [key: string]: unknown }
 
 /**
- * Caliper actor entity (for sending events).
+ * One actor-object shape for sending events.
  *
- * Timeback API requires actors to have extensions.email.
+ * This is a structured actor object with an `id`, a `type`, and an
+ * `extensions` bag containing `email`. It is one valid actor-object shape,
+ * not the only representation allowed by `CaliperEvent.actor`.
  */
 interface CaliperActor {
 	/** Unique identifier (IRI format) */
 	id: string
 	/** Entity type (e.g., 'Person', 'TimebackUser') */
 	type: string
-	/** Extensions - email is required by Timeback API */
+	/** Extensions carried on this actor-object shape */
 	extensions: {
-		/** Actor's email address (required by Timeback) */
+		/** Actor email on this actor-object shape */
 		email: string
 		/** Additional extension properties */
 		[key: string]: unknown
@@ -504,8 +509,8 @@ interface CaliperEvent {
 	id: string
 	/** Event type */
 	type: string
-	/** The agent who initiated the event (string URL, CaliperActor, or TimebackUser) */
-	actor: string | CaliperActor | TimebackUser
+	/** The agent who initiated the event (IRI string, CaliperActor, TimebackUser, or generic entity) */
+	actor: CaliperEntity | CaliperActor | TimebackUser
 	/** The action or predicate */
 	action: string
 	/** The object of the interaction */
@@ -556,8 +561,8 @@ interface CaliperEnvelope {
  * Result of sending events.
  */
 interface SendEventsResult {
-	/** Job ID for tracking async processing */
-	jobId: string
+	/** Job ID for tracking async processing (undefined when the platform does not return one) */
+	jobId: string | undefined
 }
 
 /**
@@ -655,6 +660,34 @@ interface ListEventsResult {
 	pagination: PaginationMeta
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// QUESTION EVENT TYPES (Standard Caliper)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * AssessmentItemEvent (Question Seen / Question Answered).
+ *
+ * Represents when a student is presented with a question (Started)
+ * or submits an answer (Completed).
+ */
+interface AssessmentItemEvent extends CaliperEvent {
+	type: 'AssessmentItemEvent'
+	action: 'Started' | 'Completed'
+	profile: 'AssessmentProfile'
+}
+
+/**
+ * GradeEvent for question-level grading.
+ *
+ * Represents when a question response is graded, with a Score entity
+ * containing `scoreType: "QUESTION_RESULT"` in the `generated` field.
+ */
+interface QuestionGradeEvent extends CaliperEvent {
+	type: 'GradeEvent'
+	action: 'Graded'
+	profile: 'GradingProfile'
+}
+
 /**
  * API Response Types
  *
@@ -859,19 +892,113 @@ declare const TimeSpentInput = z
 	.strict()
 type TimeSpentInput = input<typeof TimeSpentInput>
 
+declare const QuestionSeenInput = z
+	.object({
+		/** Actor (Person IRI or entity object with id, type, name, etc.) */
+		actor: z.union([z.string(), CaliperActor, TimebackUser]),
+		/** AssessmentItem being presented */
+		object: AssessmentItemObject,
+		/** Application identifier (IRI or entity) */
+		edApp: CaliperEntity,
+		/** Event identifier (auto-generated if omitted) */
+		id: z.string().optional(),
+		/** ISO 8601 datetime (defaults to now) */
+		eventTime: IsoDateTimeString.optional(),
+		/** Session context (IRI or entity) */
+		session: CaliperEntity.optional(),
+		/** Event-level extensions */
+		extensions: z.record(z.string(), z.unknown()).optional(),
+	})
+	.strict()
+type QuestionSeenInput = input<typeof QuestionSeenInput>
+
+declare const QuestionAnsweredInput = z
+	.object({
+		/** Actor (Person IRI or entity object with id, type, name, etc.) */
+		actor: z.union([z.string(), CaliperActor, TimebackUser]),
+		/** AssessmentItem being answered */
+		object: AssessmentItemObject,
+		/** Application identifier (IRI or entity) */
+		edApp: CaliperEntity,
+		/** Response entity with optional attempt and timing */
+		generated: ResponseGenerated.optional(),
+		/** Event identifier (auto-generated if omitted) */
+		id: z.string().optional(),
+		/** ISO 8601 datetime (defaults to now) */
+		eventTime: IsoDateTimeString.optional(),
+		/** Session context (IRI or entity) */
+		session: CaliperEntity.optional(),
+		/** Event-level extensions */
+		extensions: z.record(z.string(), z.unknown()).optional(),
+	})
+	.strict()
+type QuestionAnsweredInput = input<typeof QuestionAnsweredInput>
+
+declare const QuestionGradedInput = z
+	.object({
+		/** Actor (Person IRI or entity object with id, type, name, etc.) */
+		actor: z.union([z.string(), CaliperActor, TimebackUser]),
+		/** Attempt being graded (IRI) */
+		object: z.string(),
+		/** Score awarded for the question */
+		generated: ScoreGenerated,
+		/** Application identifier (IRI or entity) */
+		edApp: CaliperEntity,
+		/** Event identifier (auto-generated if omitted) */
+		id: z.string().optional(),
+		/** ISO 8601 datetime (defaults to now) */
+		eventTime: IsoDateTimeString.optional(),
+		/** Session context (IRI or entity) */
+		session: CaliperEntity.optional(),
+		/** Event-level extensions */
+		extensions: z.record(z.string(), z.unknown()).optional(),
+	})
+	.strict()
+type QuestionGradedInput = input<typeof QuestionGradedInput>
+
 declare const CaliperListEventsParams = z
 	.object({
 		limit: z.number().int().positive().optional(),
 		offset: z.number().int().min(0).optional(),
-		sensor: z.string().min(1).optional(),
+		sensor: NonEmptyString.optional(),
 		startDate: IsoDateTimeString.optional(),
 		endDate: IsoDateTimeString.optional(),
-		actorId: z.string().min(1).optional(),
+		actorId: NonEmptyString.optional(),
 		actorEmail: z.email().optional(),
 	})
 	.strict()
 type CaliperListEventsParams = input<typeof CaliperListEventsParams>
 
+/**
+ * Transport Layer
+ *
+ * HTTP transport for Caliper API communication.
+ */
+
+/**
+ * HTTP transport layer for Caliper API communication.
+ *
+ * Extends BaseTransport with Caliper-specific path configuration.
+ * Uses body-based pagination (events array + pagination metadata).
+ */
+declare class Transport extends BaseTransport {
+    /** API path profiles for Caliper operations */
+    readonly paths: CaliperPaths;
+    constructor(config: CaliperTransportConfig);
+    /**
+     * Make a paginated request using body-based pagination.
+     *
+     * Caliper APIs return pagination metadata in the response body:
+     * - `events`: Array of items
+     * - `pagination`: { total, totalPages, currentPage, limit }
+     *
+     * @param path - API endpoint path
+     * @param options - Request options
+     * @returns Normalized paginated response with hasMore and total
+     */
+    requestPaginated<T>(path: string, options?: RequestOptions): Promise<PaginatedResponse<T>>;
+}
+
 /**
  * Pagination Utilities
  *
@@ -896,6 +1023,139 @@ declare class Paginator<T> extends Paginator$1<T> {
     constructor(transport: CaliperTransportLike, path: string, params?: ListParams);
 }
 
+/**
+ * Event Factory Functions
+ *
+ * Pure factory functions for creating Caliper events.
+ * Use these when you want to batch multiple events into a single envelope.
+ */
+
+/**
+ * Create an ActivityEvent from input.
+ *
+ * Pure factory function - creates the event object without sending.
+ * Use this when you want to batch multiple events into a single envelope.
+ *
+ * @param input - Activity completion data
+ * @returns A fully-formed ActivityCompletedEvent ready to send
+ *
+ * @example
+ * ```typescript
+ * import { createActivityEvent, createTimeSpentEvent } from '@timeback/caliper'
+ *
+ * const activityEvent = createActivityEvent({
+ *   actor: { id: '...', type: 'TimebackUser', email: 'student@example.edu' },
+ *   object: { id: '...', type: 'TimebackActivityContext', subject: 'Math', app: { name: 'My App' } },
+ *   metrics: [
+ *     { type: 'totalQuestions', value: 10 },
+ *     { type: 'correctQuestions', value: 8 },
+ *   ],
+ * })
+ *
+ * const timeSpentEvent = createTimeSpentEvent({
+ *   actor: { id: '...', type: 'TimebackUser', email: 'student@example.edu' },
+ *   object: { id: '...', type: 'TimebackActivityContext', subject: 'Math', app: { name: 'My App' } },
+ *   metrics: [{ type: 'active', value: 1800 }],
+ * })
+ *
+ * // Send both in one envelope
+ * await client.events.send(sensor, [activityEvent, timeSpentEvent])
+ * ```
+ */
+declare function createActivityEvent(input: ActivityCompletedInput): ActivityCompletedEvent;
+/**
+ * Create a TimeSpentEvent from input.
+ *
+ * Pure factory function - creates the event object without sending.
+ * Use this when you want to batch multiple events into a single envelope.
+ *
+ * @param input - Time spent data
+ * @returns A fully-formed TimeSpentEvent ready to send
+ *
+ * @example
+ * ```typescript
+ * import { createTimeSpentEvent } from '@timeback/caliper'
+ *
+ * const event = createTimeSpentEvent({
+ *   actor: { id: '...', type: 'TimebackUser', email: 'student@example.edu' },
+ *   object: { id: '...', type: 'TimebackActivityContext', subject: 'Reading', app: { name: 'My App' } },
+ *   metrics: [
+ *     { type: 'active', value: 1800 },
+ *     { type: 'inactive', value: 300 },
+ *   ],
+ * })
+ *
+ * await client.events.send(sensor, [event])
+ * ```
+ */
+declare function createTimeSpentEvent(input: TimeSpentInput): TimeSpentEvent;
+/**
+ * Create a Question Seen event (AssessmentItemEvent.Started).
+ *
+ * Fired when a question is presented to the student.
+ *
+ * @param input - Minimal question seen data
+ * @returns A fully-formed AssessmentItemEvent ready to send
+ *
+ * @example
+ * ```typescript
+ * const event = createQuestionSeenEvent({
+ *   actor: 'urn:uuid:student-123',
+ *   object: { id: 'urn:uuid:q-456', name: 'What is 2+2?' },
+ *   edApp: 'https://myapp.example.com',
+ * })
+ *
+ * await client.events.send(sensor, [event])
+ * ```
+ */
+declare function createQuestionSeenEvent(input: QuestionSeenInput): AssessmentItemEvent;
+/**
+ * Create a Question Answered event (AssessmentItemEvent.Completed).
+ *
+ * Fired when a student submits an answer to a question.
+ *
+ * @param input - Minimal question answered data
+ * @returns A fully-formed AssessmentItemEvent ready to send
+ *
+ * @example
+ * ```typescript
+ * const event = createQuestionAnsweredEvent({
+ *   actor: 'urn:uuid:student-123',
+ *   object: { id: 'urn:uuid:q-456', name: 'What is 2+2?' },
+ *   edApp: 'https://myapp.example.com',
+ *   generated: {
+ *     id: 'urn:uuid:response-789',
+ *     attempt: 'urn:uuid:attempt-101',
+ *   },
+ * })
+ *
+ * await client.events.send(sensor, [event])
+ * ```
+ */
+declare function createQuestionAnsweredEvent(input: QuestionAnsweredInput): AssessmentItemEvent;
+/**
+ * Create a Question Graded event (GradeEvent.Graded).
+ *
+ * Fired when a question response is scored. The Score entity is auto-filled
+ * with `type: "Score"` and `scoreType: "QUESTION_RESULT"`.
+ *
+ * @param input - Minimal question graded data
+ * @returns A fully-formed QuestionGradeEvent ready to send
+ *
+ * @example
+ * ```typescript
+ * const event = createQuestionGradedEvent({
+ *   actor: 'urn:uuid:student-123',
+ *   object: 'urn:uuid:attempt-101',
+ *   generated: { scoreGiven: 1, maxScore: 1, attempt: 'urn:uuid:attempt-101' },
+ *   edApp: 'https://myapp.example.com',
+ * })
+ *
+ * await client.events.send(sensor, [event])
+ * ```
+ */
+declare function createQuestionGradedEvent(input: QuestionGradedInput): QuestionGradeEvent;
+
 /**
  * Events Resource
  *
@@ -1140,6 +1400,78 @@ declare class EventsResource {
      * ```
      */
     sendTimeSpent(sensor: string, input: TimeSpentInput): Promise<SendEventsResult>;
+    /**
+     * Send a "question seen" event (AssessmentItemEvent.Started).
+     *
+     * Records when a question is presented to a student.
+     *
+     * @param sensor - Sensor identifier (IRI format)
+     * @param input - Question seen data
+     * @returns Job ID for tracking processing status
+     *
+     * @example
+     * ```typescript
+     * await client.events.sendQuestionSeen(
+     *   'https://myapp.example.com/sensors/main',
+     *   {
+     *     actor: 'urn:uuid:student-123',
+     *     object: { id: 'urn:uuid:q-456', name: 'What is 2+2?' },
+     *     edApp: 'https://myapp.example.com',
+     *   },
+     * )
+     * ```
+     */
+    sendQuestionSeen(sensor: string, input: QuestionSeenInput): Promise<SendEventsResult>;
+    /**
+     * Send a "question answered" event (AssessmentItemEvent.Completed).
+     *
+     * Records when a student submits an answer to a question.
+     *
+     * @param sensor - Sensor identifier (IRI format)
+     * @param input - Question answered data
+     * @returns Job ID for tracking processing status
+     *
+     * @example
+     * ```typescript
+     * await client.events.sendQuestionAnswered(
+     *   'https://myapp.example.com/sensors/main',
+     *   {
+     *     actor: 'urn:uuid:student-123',
+     *     object: { id: 'urn:uuid:q-456', name: 'What is 2+2?' },
+     *     edApp: 'https://myapp.example.com',
+     *     generated: {
+     *       id: 'urn:uuid:response-789',
+     *       attempt: 'urn:uuid:attempt-101',
+     *     },
+     *   },
+     * )
+     * ```
+     */
+    sendQuestionAnswered(sensor: string, input: QuestionAnsweredInput): Promise<SendEventsResult>;
+    /**
+     * Send a "question graded" event (GradeEvent.Graded).
+     *
+     * Records when a question response is scored. The Score entity is
+     * auto-filled with `scoreType: "QUESTION_RESULT"`.
+     *
+     * @param sensor - Sensor identifier (IRI format)
+     * @param input - Question graded data
+     * @returns Job ID for tracking processing status
+     *
+     * @example
+     * ```typescript
+     * await client.events.sendQuestionGraded(
+     *   'https://myapp.example.com/sensors/main',
+     *   {
+     *     actor: 'urn:uuid:student-123',
+     *     object: 'urn:uuid:attempt-101',
+     *     generated: { scoreGiven: 1, maxScore: 1, attempt: 'urn:uuid:attempt-101' },
+     *     edApp: 'https://myapp.example.com',
+     *   },
+     * )
+     * ```
+     */
+    sendQuestionGraded(sensor: string, input: QuestionGradedInput): Promise<SendEventsResult>;
 }
 
 /**
@@ -1316,107 +1648,14 @@ declare function createCaliperClient(registry?: ProviderRegistry): {
     };
 };
 
-/**
- * Event Factory Functions
- *
- * Pure factory functions for creating Timeback profile events.
- * Use these when you want to batch multiple events into a single envelope.
- */
-
-/**
- * Create an ActivityEvent from input.
- *
- * Pure factory function - creates the event object without sending.
- * Use this when you want to batch multiple events into a single envelope.
- *
- * @param input - Activity completion data
- * @returns A fully-formed ActivityCompletedEvent ready to send
- *
- * @example
- * ```typescript
- * import { createActivityEvent, createTimeSpentEvent } from '@timeback/caliper'
- *
- * const activityEvent = createActivityEvent({
- *   actor: { id: '...', type: 'TimebackUser', email: 'student@example.edu' },
- *   object: { id: '...', type: 'TimebackActivityContext', subject: 'Math', app: { name: 'My App' } },
- *   metrics: [
- *     { type: 'totalQuestions', value: 10 },
- *     { type: 'correctQuestions', value: 8 },
- *   ],
- * })
- *
- * const timeSpentEvent = createTimeSpentEvent({
- *   actor: { id: '...', type: 'TimebackUser', email: 'student@example.edu' },
- *   object: { id: '...', type: 'TimebackActivityContext', subject: 'Math', app: { name: 'My App' } },
- *   metrics: [{ type: 'active', value: 1800 }],
- * })
- *
- * // Send both in one envelope
- * await client.events.send(sensor, [activityEvent, timeSpentEvent])
- * ```
- */
-declare function createActivityEvent(input: ActivityCompletedInput): ActivityCompletedEvent;
-/**
- * Create a TimeSpentEvent from input.
- *
- * Pure factory function - creates the event object without sending.
- * Use this when you want to batch multiple events into a single envelope.
- *
- * @param input - Time spent data
- * @returns A fully-formed TimeSpentEvent ready to send
- *
- * @example
- * ```typescript
- * import { createTimeSpentEvent } from '@timeback/caliper'
- *
- * const event = createTimeSpentEvent({
- *   actor: { id: '...', type: 'TimebackUser', email: 'student@example.edu' },
- *   object: { id: '...', type: 'TimebackActivityContext', subject: 'Reading', app: { name: 'My App' } },
- *   metrics: [
- *     { type: 'active', value: 1800 },
- *     { type: 'inactive', value: 300 },
- *   ],
- * })
- *
- * await client.events.send(sensor, [event])
- * ```
- */
-declare function createTimeSpentEvent(input: TimeSpentInput): TimeSpentEvent;
-
 /**
  * Caliper JSON-LD context version.
  */
 declare const CALIPER_DATA_VERSION = "http://purl.imsglobal.org/ctx/caliper/v1p2";
-
 /**
- * Transport Layer
- *
- * HTTP transport for Caliper API communication.
- */
-
-/**
- * HTTP transport layer for Caliper API communication.
- *
- * Extends BaseTransport with Caliper-specific path configuration.
- * Uses body-based pagination (events array + pagination metadata).
+ * Score type for individual question results (LWAI GradeEvent).
  */
-declare class Transport extends BaseTransport {
-    /** API path profiles for Caliper operations */
-    readonly paths: CaliperPaths;
-    constructor(config: CaliperTransportConfig);
-    /**
-     * Make a paginated request using body-based pagination.
-     *
-     * Caliper APIs return pagination metadata in the response body:
-     * - `events`: Array of items
-     * - `pagination`: { total, totalPages, currentPage, limit }
-     *
-     * @param path - API endpoint path
-     * @param options - Request options
-     * @returns Normalized paginated response with hasMore and total
-     */
-    requestPaginated<T>(path: string, options?: RequestOptions): Promise<PaginatedResponse<T>>;
-}
+declare const QUESTION_RESULT_SCORE_TYPE: "QUESTION_RESULT";
 
-export { ActivityCompletedInput, CALIPER_DATA_VERSION, CaliperClient, CaliperListEventsParams as ListEventsParams, TimeSpentInput, Transport, createActivityEvent, createCaliperClient, createTimeSpentEvent };
-export type { ActivityCompletedEvent, ActivityMetricType, CaliperClientConfig, CaliperClientInstance, CaliperEnvelope, CaliperEvent, CaliperProfile, JobStatus, SendEventsResult, StoredEvent, TimeSpentEvent, TimeSpentMetric, TimeSpentMetricType, TimebackActivity, TimebackActivityContext, TimebackActivityMetric, TimebackActivityMetricsCollection, TimebackApp, TimebackCourse, TimebackEvent, TimebackSubject, TimebackTimeSpentMetricsCollection, TimebackUser, TimebackUserRole, ValidationResult };
+export { ActivityCompletedInput, CALIPER_DATA_VERSION, CaliperClient, CaliperListEventsParams as ListEventsParams, QUESTION_RESULT_SCORE_TYPE, QuestionAnsweredInput, QuestionGradedInput, QuestionSeenInput, TimeSpentInput, Transport, createActivityEvent, createCaliperClient, createQuestionAnsweredEvent, createQuestionGradedEvent, createQuestionSeenEvent, createTimeSpentEvent };
+export type { ActivityCompletedEvent, ActivityMetricType, AssessmentItemEvent, CaliperClientConfig, CaliperClientInstance, CaliperEnvelope, CaliperEvent, CaliperProfile, JobStatus, QuestionGradeEvent, SendEventsResult, StoredEvent, TimeSpentEvent, TimeSpentMetric, TimeSpentMetricType, TimebackActivity, TimebackActivityContext, TimebackActivityMetric, TimebackActivityMetricsCollection, TimebackApp, TimebackCourse, TimebackEvent, TimebackSubject, TimebackTimeSpentMetricsCollection, TimebackUser, TimebackUserRole, ValidationResult };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAMH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAE/C,YAAY,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACrD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7F,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAMtE,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAEjF,YAAY,EACX,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,iCAAiC,EACjC,kBAAkB,EAClB,eAAe,EACf,kCAAkC,EAClC,mBAAmB,EACnB,sBAAsB,EACtB,cAAc,EACd,aAAa,GACb,MAAM,mCAAmC,CAAA;AAE1C,YAAY,EACX,sBAAsB,EACtB,cAAc,EACd,uBAAuB,IAAI,gBAAgB,GAC3C,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAElD,YAAY,EACX,eAAe,EACf,YAAY,EACZ,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GAChB,MAAM,mCAAmC,CAAA;AAM1C,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAMH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAE/C,YAAY,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACrD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7F,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAMtE,OAAO,EACN,mBAAmB,EACnB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,GACpB,MAAM,OAAO,CAAA;AAEd,YAAY,EACX,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,iCAAiC,EACjC,kBAAkB,EAClB,eAAe,EACf,kCAAkC,EAClC,mBAAmB,EACnB,sBAAsB,EACtB,cAAc,EACd,aAAa,GACb,MAAM,mCAAmC,CAAA;AAE1C,YAAY,EACX,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,uBAAuB,IAAI,gBAAgB,GAC3C,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAA;AAE9E,YAAY,EACX,mBAAmB,EACnB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GAChB,MAAM,mCAAmC,CAAA;AAM1C,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA"}