@timeback/caliper 0.1.0

package/dist/lib/event-factories.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Event Factory Functions
+ *
+ * Pure factory functions for creating Timeback profile events.
+ * Use these when you want to batch multiple events into a single envelope.
+ */
+import type { ActivityCompletedEvent, ActivityCompletedInput, TimeSpentEvent, TimeSpentInput } from '../types';
+/**
+ * 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])
+ * ```
+ */
+export 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])
+ * ```
+ */
+export declare function createTimeSpentEvent(input: TimeSpentInput): TimeSpentEvent;
+//# sourceMappingURL=event-factories.d.ts.map

package/dist/lib/event-factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-factories.d.ts","sourceRoot":"","sources":["../../src/lib/event-factories.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EACX,sBAAsB,EACtB,sBAAsB,EACtB,cAAc,EACd,cAAc,EACd,MAAM,UAAU,CAAA;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,sBAAsB,GAAG,sBAAsB,CAoBzF;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAoB1E"}

package/dist/lib/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Internal Library Exports
+ *
+ * @internal
+ */
+export { resolveToProvider } from './resolve';
+export { Transport } from './transport';
+export { Paginator } from './pagination';
+export { createActivityEvent, createTimeSpentEvent } from './event-factories';
+export type { ResolvedConfig } from '@timeback/internal-client-infra';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAE7E,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA"}

package/dist/lib/pagination.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pagination Utilities
+ *
+ * Re-exports the common Paginator with Caliper-specific configuration.
+ */
+import { Paginator as BasePaginator } from '@timeback/internal-client-infra';
+import type { ListParams } from '@timeback/internal-client-infra';
+import type { CaliperTransportLike } from '../types';
+/**
+ * Caliper-specific Paginator that uses the Caliper transport.
+ *
+ * Uses body-based pagination with the events response format.
+ *
+ * @typeParam T - The type of items being paginated
+ */
+export declare class Paginator<T> extends BasePaginator<T> {
+    /**
+     * Create a new Caliper Paginator.
+     *
+     * @param transport - Caliper transport instance
+     * @param path - API endpoint path
+     * @param params - List parameters including optional max
+     */
+    constructor(transport: CaliperTransportLike, path: string, params?: ListParams);
+}
+//# sourceMappingURL=pagination.d.ts.map

package/dist/lib/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../src/lib/pagination.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAI5E,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,iCAAiC,CAAA;AACpF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEpD;;;;;;GAMG;AACH,qBAAa,SAAS,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,YAAY,SAAS,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,UAAe,EAWjF;CACD"}

package/dist/lib/resolve.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Provider Resolution
+ *
+ * Caliper-specific wrapper around the generic provider resolver.
+ *
+ * @internal
+ */
+import type { ProviderRegistry } from '@timeback/internal-client-infra';
+import type { CaliperClientConfig, CaliperResolvedProvider } from '../types';
+/**
+ * Resolve Caliper client config to a TimebackProvider.
+ *
+ * @param config - Client configuration
+ * @param registry - Provider registry for platform/env resolution
+ * @returns Resolved provider or transport
+ * @throws {Error} If configuration is invalid or incomplete
+ *
+ * @internal
+ */
+export declare function resolveToProvider(config: CaliperClientConfig, registry?: ProviderRegistry): CaliperResolvedProvider;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/lib/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/lib/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAE5E;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,GAAE,gBAA4C,GACpD,uBAAuB,CAEzB"}

package/dist/lib/transport.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Transport Layer
+ *
+ * HTTP transport for Caliper API communication.
+ */
+import { BaseTransport } from '@timeback/internal-client-infra';
+import type { CaliperPaths, PaginatedResponse, RequestOptions } from '@timeback/internal-client-infra';
+import type { CaliperTransportConfig } from '../types';
+/**
+ * HTTP transport layer for Caliper API communication.
+ *
+ * Extends BaseTransport with Caliper-specific path configuration.
+ * Uses body-based pagination (events array + pagination metadata).
+ */
+export 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>>;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/lib/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/lib/transport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAI/D,OAAO,KAAK,EACX,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAWtD;;;;;GAKG;AACH,qBAAa,SAAU,SAAQ,aAAa;IAC3C,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAE5B,YAAY,MAAM,EAAE,sBAAsB,EAGzC;IAED;;;;;;;;;;OAUG;IACG,gBAAgB,CAAC,CAAC,EACvB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAY/B;CACD"}

package/dist/resources/events.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Events Resource
+ *
+ * Manage Caliper events - send, list, and retrieve.
+ */
+import { Paginator } from '../lib/pagination';
+import type { ActivityCompletedInput, CaliperEnvelope, CaliperEvent, CaliperTransportLike, ListEventsParams, ListEventsResult, SendEventsResult, StoredEvent, TimeSpentInput, ValidationResult } from '../types';
+/**
+ * Caliper Events resource.
+ *
+ * Provides methods to send, list, and retrieve Caliper events.
+ */
+export declare class EventsResource {
+    private readonly transport;
+    constructor(transport: CaliperTransportLike);
+    /**
+     * Send Caliper events.
+     *
+     * Wraps events in an envelope and sends to the API.
+     * Events are validated against the IMS Caliper specification
+     * and queued for async processing.
+     *
+     * @param sensor - Sensor identifier (IRI format)
+     * @param events - Array of Caliper events
+     * @returns Job ID for tracking processing status
+     *
+     * @remarks
+     * **API Response Drift**: The official API docs (caliper/response.yaml) document
+     * the response as `{ status, message, errors? }`, but the actual API returns
+     * `{ jobId }`. This client correctly handles the actual response.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.events.send(
+     *   'https://example.edu/sensors/1',
+     *   [event1, event2]
+     * )
+     * ```
+     */
+    send(sensor: string, events: CaliperEvent[]): Promise<SendEventsResult>;
+    /**
+     * Send a raw Caliper envelope.
+     *
+     * Use this when you need full control over the envelope structure.
+     * For most cases, prefer `send()` which builds the envelope for you.
+     *
+     * @param envelope - Caliper envelope containing events
+     * @returns Job ID for tracking processing status
+     *
+     * @remarks
+     * **API Response Drift**: See `send()` for details on response format drift.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.events.sendEnvelope({
+     *   sensor: 'https://example.edu/sensors/1',
+     *   sendTime: new Date().toISOString(),
+     *   dataVersion: 'http://purl.imsglobal.org/ctx/caliper/v1p2',
+     *   data: [event1, event2],
+     * })
+     * ```
+     */
+    sendEnvelope(envelope: CaliperEnvelope): Promise<SendEventsResult>;
+    /**
+     * Validate Caliper events without storing them.
+     *
+     * Use this to check if events conform to the IMS Caliper specification
+     * before sending them for processing.
+     *
+     * @param envelope - Caliper envelope containing events to validate
+     * @returns Validation result with status and any errors
+     *
+     * @example
+     * ```typescript
+     * const result = await client.events.validate({
+     *   sensor: 'https://example.edu/sensors/1',
+     *   sendTime: new Date().toISOString(),
+     *   dataVersion: 'http://purl.imsglobal.org/ctx/caliper/v1p2',
+     *   data: [event1, event2],
+     * })
+     *
+     * if (result.status === 'success') {
+     *   console.log('Events are valid!')
+     * } else {
+     *   console.log('Validation errors:', result.errors)
+     * }
+     * ```
+     */
+    validate(envelope: CaliperEnvelope): Promise<ValidationResult>;
+    /**
+     * List Caliper events with optional filtering.
+     *
+     * @param params - Filter parameters
+     * @returns Events array and pagination metadata
+     *
+     * @remarks
+     * **API Response Drift**: The official API docs (caliper/response.yaml) document
+     * the response as `{ status, message, errors? }`, but the actual API returns
+     * `{ events: StoredEvent[], pagination: { total, totalPages, currentPage, limit } }`.
+     * This client correctly handles the actual response.
+     *
+     * @example
+     * ```typescript
+     * const { events } = await client.events.list({
+     *   limit: 50,
+     *   actorEmail: 'student@example.edu',
+     *   startDate: '2024-01-01',
+     * })
+     *
+     * // Access pagination metadata
+     * const { events, pagination } = await client.events.list({ limit: 10 })
+     * console.log(`Total: ${pagination.total}`)
+     * ```
+     */
+    list(params?: ListEventsParams): Promise<ListEventsResult>;
+    /**
+     * Stream Caliper events with automatic pagination.
+     *
+     * Returns a Paginator that lazily fetches pages as you iterate.
+     * Use this for large datasets or when you need all matching events.
+     *
+     * @param params - Filter parameters (same as list())
+     * @returns Paginator for async iteration
+     *
+     * @example Iterate over all events
+     * ```typescript
+     * for await (const event of client.events.stream({ startDate: '2024-01-01' })) {
+     *   console.log(event.id)
+     * }
+     * ```
+     *
+     * @example Collect all events into an array
+     * ```typescript
+     * const allEvents = await client.events
+     *   .stream({ startDate: '2024-01-01' })
+     *   .toArray()
+     * ```
+     *
+     * @example Limit total events fetched
+     * ```typescript
+     * const events = await client.events
+     *   .stream({ startDate: '2024-01-01', max: 1000 })
+     *   .toArray()
+     * ```
+     */
+    stream(params?: ListEventsParams & {
+        max?: number;
+    }): Paginator<StoredEvent>;
+    /**
+     * Get a specific event by its external ID.
+     *
+     * @param externalId - The event's external ID (URN UUID format, e.g., 'urn:uuid:...')
+     * @returns The stored event
+     *
+     * @remarks
+     * **API Response Drift**: The official API docs (caliper/response.yaml) document
+     * the response as `{ status, message, errors? }`, but the actual API returns
+     * `{ status, event: StoredEvent }`. This client correctly handles the actual response.
+     *
+     * **Important**: Use `externalId` (URN UUID), not the internal numeric `id`.
+     * The `StoredEvent` returned from `list()` contains both - use `event.externalId`.
+     *
+     * @example
+     * ```typescript
+     * const event = await client.events.get('urn:uuid:c51570e4-f8ed-4c18-bb3a-dfe51b2cc594')
+     * ```
+     */
+    get(externalId: string): Promise<StoredEvent>;
+    /**
+     * Send an activity event (Timeback Profile).
+     *
+     * Records student activity completion with performance metrics.
+     * This is a first-class method for the Timeback platform.
+     *
+     * @param sensor - Sensor identifier (IRI format)
+     * @param input - Activity completion data
+     * @returns Job ID for tracking processing status
+     *
+     * @example
+     * ```typescript
+     * const result = await client.events.sendActivity(
+     *   'https://myapp.example.com/sensors/main',
+     *   {
+     *     actor: {
+     *       id: 'https://api.example.com/users/123',
+     *       type: 'TimebackUser',
+     *       email: 'student@example.edu',
+     *     },
+     *     object: {
+     *       id: 'https://myapp.example.com/activities/456',
+     *       type: 'TimebackActivityContext',
+     *       subject: 'Math',
+     *       app: { name: 'My Learning App' },
+     *     },
+     *     metrics: [
+     *       { type: 'totalQuestions', value: 10 },
+     *       { type: 'correctQuestions', value: 8 },
+     *       { type: 'xpEarned', value: 150 },
+     *     ],
+     *   },
+     * )
+     * ```
+     */
+    sendActivity(sensor: string, input: ActivityCompletedInput): Promise<SendEventsResult>;
+    /**
+     * Send a time spent event (Timeback Profile).
+     *
+     * Records time spent on an activity, categorized by engagement type.
+     * This is a first-class method for the Timeback platform.
+     *
+     * @param sensor - Sensor identifier (IRI format)
+     * @param input - Time spent data
+     * @returns Job ID for tracking processing status
+     *
+     * @example
+     * ```typescript
+     * const result = await client.events.sendTimeSpent(
+     *   'https://myapp.example.com/sensors/main',
+     *   {
+     *     actor: {
+     *       id: 'https://api.example.com/users/123',
+     *       type: 'TimebackUser',
+     *       email: 'student@example.edu',
+     *     },
+     *     object: {
+     *       id: 'https://myapp.example.com/activities/456',
+     *       type: 'TimebackActivityContext',
+     *       subject: 'Reading',
+     *       app: { name: 'My Learning App' },
+     *     },
+     *     metrics: [
+     *       { type: 'active', value: 1800 },  // 30 minutes
+     *       { type: 'inactive', value: 300 }, // 5 minutes
+     *     ],
+     *   },
+     * )
+     * ```
+     */
+    sendTimeSpent(sensor: string, input: TimeSpentInput): Promise<SendEventsResult>;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/resources/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/resources/events.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAG7C,OAAO,KAAK,EACX,sBAAsB,EACtB,eAAe,EACf,YAAY,EACZ,oBAAoB,EAEpB,gBAAgB,EAEhB,gBAAgB,EAEhB,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,MAAM,UAAU,CAAA;AAEjB;;;;GAIG;AACH,qBAAa,cAAc;IACd,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,oBAAoB,EAAI;IAEhE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAStE;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAcvE;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAoBnE;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,IAAI,CAAC,MAAM,GAAE,gBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA2BnE;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,MAAM,GAAE,gBAAgB,GAAG;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,SAAS,CAAC,WAAW,CAAC,CAwB/E;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACG,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAgBlD;IAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAWrF;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAW9E;CACD"}

package/dist/resources/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Caliper Resources
+ */
+export { EventsResource } from './events';
+export { JobsResource } from './jobs';
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA"}

package/dist/resources/jobs.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Jobs Resource
+ *
+ * Track status of async event processing jobs.
+ */
+import type { CaliperTransportLike, JobStatus, WaitForCompletionOptions } from '../types';
+/**
+ * Jobs resource for tracking async processing.
+ *
+ * When events are submitted, they are queued for async processing.
+ * Use this resource to check job status and retrieve results.
+ */
+export declare class JobsResource {
+    private readonly transport;
+    constructor(transport: CaliperTransportLike);
+    /**
+     * Get the status of a processing job.
+     *
+     * @param jobId - The job ID returned from events.send()
+     * @returns Job status including state and results
+     *
+     * @example
+     * ```typescript
+     * const status = await client.jobs.getStatus(jobId)
+     *
+     * if (status.state === 'completed') {
+     *   console.log('Events processed:', status.returnValue?.results)
+     * }
+     * ```
+     */
+    getStatus(jobId: string): Promise<JobStatus>;
+    /**
+     * Wait for a job to complete with polling.
+     *
+     * @param jobId - The job ID to wait for
+     * @param options - Polling options
+     * @returns Final job status
+     * @throws {Error} If job fails or times out
+     *
+     * @example
+     * ```typescript
+     * const result = await client.events.send(envelope)
+     * const status = await client.jobs.waitForCompletion(result.jobId)
+     * console.log('Processed events:', status.returnValue?.results)
+     * ```
+     */
+    waitForCompletion(jobId: string, options?: WaitForCompletionOptions): Promise<JobStatus>;
+}
+//# sourceMappingURL=jobs.d.ts.map

package/dist/resources/jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.d.ts","sourceRoot":"","sources":["../../src/resources/jobs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACX,oBAAoB,EACpB,SAAS,EAET,wBAAwB,EACxB,MAAM,UAAU,CAAA;AAEjB;;;;;GAKG;AACH,qBAAa,YAAY;IACZ,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,oBAAoB,EAAI;IAEhE;;;;;;;;;;;;;;OAcG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAajD;IAED;;;;;;;;;;;;;;OAcG;IACG,iBAAiB,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,wBAA6B,GACpC,OAAO,CAAC,SAAS,CAAC,CAyBpB;CACD"}

package/dist/types/api.d.ts

@@ -0,0 +1,101 @@
+/**
+ * API Response Types
+ *
+ * Types for Caliper API responses.
+ *
+ * @remarks
+ * **IMPORTANT - API Docs Drift**: The official API documentation (caliper/response.yaml
+ * and caliper-api.yaml) does NOT accurately reflect actual API responses. The types
+ * in this file were derived from testing actual API responses. See individual type
+ * comments for specific discrepancies.
+ */
+import type { JobStatus, StoredEvent } from './events';
+/**
+ * Generic API response wrapper.
+ */
+export interface ApiResponse<T> {
+    status: 'success' | 'error';
+    message?: string;
+    data?: T;
+}
+/**
+ * Pagination metadata returned by list endpoints.
+ */
+export interface PaginationMeta {
+    /** Total number of items across all pages */
+    total: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Current page number (1-indexed) */
+    currentPage: number;
+    /** Number of items per page */
+    limit: number;
+}
+/**
+ * Response from GET /caliper/events (list events).
+ *
+ * @remarks
+ * **API Docs Drift**: Official docs (caliper/response.yaml) incorrectly show
+ * `{ status, message, errors? }`. Actual response is `{ events, pagination }`.
+ */
+export interface ListEventsResponse {
+    /** Array of stored events */
+    events: StoredEvent[];
+    /** Pagination metadata */
+    pagination: PaginationMeta;
+}
+/**
+ * Response from GET /caliper/events/:externalId (get single event).
+ *
+ * @remarks
+ * **API Docs Drift**: Official docs (caliper/response.yaml) incorrectly show
+ * `{ status, message, errors? }`. Actual response is `{ status, event }`.
+ */
+export interface GetEventResponse {
+    /** Status indicator */
+    status: 'success' | 'error';
+    /** The requested event */
+    event: StoredEvent;
+}
+/**
+ * Response from POST /caliper/event (send events).
+ *
+ * @remarks
+ * **API Docs Drift**: Official docs (caliper/response.yaml) incorrectly show
+ * `{ status, message, errors? }`. Actual response is `{ jobId }`.
+ * Use the jobId with `jobs.getStatus()` to track processing.
+ */
+export interface SendEventsResponse {
+    /** Job ID for tracking async processing */
+    jobId: string;
+}
+/**
+ * Job status response payload (GET /jobs/{jobId}/status).
+ *
+ * @remarks
+ * This endpoint is correctly documented in caliper/response.yaml.
+ */
+export interface JobStatusResponse {
+    job: JobStatus;
+}
+/**
+ * Options for waitForCompletion polling.
+ */
+export interface WaitForCompletionOptions {
+    /** Maximum time to wait in milliseconds (default: 30000) */
+    timeoutMs?: number;
+    /** Interval between status checks in milliseconds (default: 1000) */
+    pollIntervalMs?: number;
+}
+/**
+ * Validation result from the validate endpoint.
+ */
+export interface ValidationResult {
+    /** Whether validation succeeded */
+    status: 'success' | 'error';
+    /** Human-readable message */
+    message?: string;
+    /** Validation errors (if any) */
+    errors?: unknown;
+}
+//# sourceMappingURL=api.d.ts.map

package/dist/types/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/types/api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtD;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B,MAAM,EAAE,SAAS,GAAG,OAAO,CAAA;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,CAAC,CAAA;CACR;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,4BAA4B;IAC5B,UAAU,EAAE,MAAM,CAAA;IAClB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAA;CACb;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,6BAA6B;IAC7B,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,0BAA0B;IAC1B,UAAU,EAAE,cAAc,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,uBAAuB;IACvB,MAAM,EAAE,SAAS,GAAG,OAAO,CAAA;IAC3B,0BAA0B;IAC1B,KAAK,EAAE,WAAW,CAAA;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAA;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,GAAG,EAAE,SAAS,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,mCAAmC;IACnC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAA;IAC3B,6BAA6B;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iCAAiC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAA;CAChB"}

package/dist/types/client.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Client Configuration Types
+ *
+ * Configuration types for the Caliper client.
+ */
+import type { BaseTransportConfig, CaliperPaths, ClientConfig, EnvAuth, Environment, ExplicitAuth, PaginatedResponse, Platform, ProviderClientConfig, RequestOptions, ResolvedProvider, TransportOnlyConfig } from '@timeback/internal-client-infra';
+import type { CaliperClient } from '../client';
+/**
+ * Re-export vital config types for SDK users.
+ */
+export type { Environment, EnvAuth, ExplicitAuth, Platform };
+/**
+ * Transport interface for Caliper client.
+ *
+ * Extends base transport requirements with Caliper-specific paths.
+ * Required when using transport mode with CaliperClient.
+ */
+export interface CaliperTransportLike {
+    /** Base URL of the API */
+    baseUrl: string;
+    /** API path profiles for Caliper operations */
+    paths: CaliperPaths;
+    /** Make an authenticated request */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** Make a paginated request using body-based pagination */
+    requestPaginated<T>(path: string, options?: RequestOptions): Promise<PaginatedResponse<T>>;
+}
+/**
+ * Caliper client configuration options.
+ *
+ * Supports four modes:
+ * - **Provider mode**: `{ provider: TimebackProvider }` — pre-built provider with token sharing
+ * - **Environment mode**: `{ platform?, env, auth }` — Timeback hosted APIs
+ * - **Explicit mode**: `{ baseUrl, auth: { authUrl } }` — custom API URLs
+ * - **Transport mode**: `{ transport: CaliperTransportLike }` — custom transport with paths
+ *
+ * The `platform` field (in env mode) selects which Timeback implementation to use:
+ * - `'BEYOND_AI'` (default): BeyondAI's Timeback platform
+ * - `'LEARNWITH_AI'`: Samy's LearnWith.AI platform
+ */
+export type CaliperClientConfig = ClientConfig | TransportOnlyConfig<CaliperTransportLike> | ProviderClientConfig;
+/**
+ * Configuration for Caliper transport.
+ */
+export type CaliperTransportConfig = BaseTransportConfig & {
+    /** API path profiles for Caliper operations */
+    paths: CaliperPaths;
+};
+/**
+ * Resolved provider type for Caliper client.
+ */
+export type CaliperResolvedProvider = ResolvedProvider<CaliperTransportLike>;
+/**
+ * Instance type of CaliperClient.
+ */
+export type CaliperClientInstance = InstanceType<typeof CaliperClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/types/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/types/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACX,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,QAAQ,EACR,oBAAoB,EACpB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C;;GAEG;AACH,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,+CAA+C;IAC/C,KAAK,EAAE,YAAY,CAAA;IACnB,oCAAoC;IACpC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAC9D,2DAA2D;IAC3D,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAA;CAC1F;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAC5B,YAAY,GACZ,mBAAmB,CAAC,oBAAoB,CAAC,GACzC,oBAAoB,CAAA;AAEvB;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,GAAG;IAC1D,+CAA+C;IAC/C,KAAK,EAAE,YAAY,CAAA;CACnB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,CAAC,oBAAoB,CAAC,CAAA;AAE5E;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,YAAY,CAAC,OAAO,aAAa,CAAC,CAAA"}