@openstax/ts-utils 1.33.0 → 1.34.0

package/dist/esm/services/lrsGateway/attempt-utils.js

@@ -1,236 +0,0 @@
-/*
- * the structure of xapi statements for handling multiple attempts of an activity
- * including the option of a parent activity/attempt such that a new attempt
- * of a parent activity inherently creates a new attempt scope for sub-activities
- * is done by convention using certain context and verb pieces of a statement.
- * this module provides helpers for creating and retrieving statements according
- * to this convention.
- */
-import formatISODuration from 'date-fns/formatISODuration';
-import intervalToDuration from 'date-fns/intervalToDuration';
-import isAfter from 'date-fns/isAfter';
-import isBefore from 'date-fns/isBefore';
-import parseISO from 'date-fns/parseISO';
-var Verb;
-(function (Verb) {
-    Verb["Attempted"] = "http://adlnet.gov/expapi/verbs/attempted";
-    Verb["Completed"] = "http://adlnet.gov/expapi/verbs/completed";
-})(Verb || (Verb = {}));
-export const matchAttempt = (statement) => statement.verb.id === Verb.Attempted;
-export const matchAttemptCompleted = (attempt) => (statement) => {
-    var _a, _b;
-    return statement.verb.id === Verb.Completed
-        && statement.context !== undefined
-        && ((_a = statement.context.statement) === null || _a === void 0 ? void 0 : _a.id) === attempt.id
-        && statement.context.registration === ((_b = attempt.context) === null || _b === void 0 ? void 0 : _b.registration);
-};
-export const resolveAttempts = (statements, options) => statements.filter(statement => {
-    var _a;
-    return matchAttempt(statement)
-        && (!(options === null || options === void 0 ? void 0 : options.activityIRI) || statement.object.id === options.activityIRI)
-        && (!(options === null || options === void 0 ? void 0 : options.parentActivityAttempt) || ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === options.parentActivityAttempt);
-});
-export const resolveCompletedForAttempt = (statements, attempt, activityIRI) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
-    && (!activityIRI || statement.object.id === activityIRI));
-export const oldestStatement = (statements) => statements.reduce((result, statement) => result && isBefore(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
-export const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && isAfter(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
-export const resolveAttemptInfo = (statements, options) => {
-    // TODO optimize. i'm 100% that this could all be done in one iteration but i'm not messing around with that for now.
-    const attempts = resolveAttempts(statements, options);
-    /* attempts that have a completed statement */
-    const completedAttempts = attempts.filter(attempt => !!resolveCompletedForAttempt(statements, attempt, options === null || options === void 0 ? void 0 : options.activityIRI));
-    /* the last attempt sorted by timestamp */
-    const currentAttempt = (options === null || options === void 0 ? void 0 : options.currentAttempt)
-        ? attempts.find(attempt => attempt.id === options.currentAttempt)
-        : (options === null || options === void 0 ? void 0 : options.currentPreference) === 'oldest'
-            ? oldestStatement(attempts)
-            : mostRecentStatement(attempts);
-    /* all statements for the current attempt (doesn't include the attempt or completed statements) */
-    const currentAttemptStatements = currentAttempt ? statements.filter(statement => {
-        var _a;
-        return (!(options === null || options === void 0 ? void 0 : options.activityIRI) || statement.object.id === options.activityIRI)
-            && ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === currentAttempt.id;
-    }) : [];
-    const currentAttemptCompleted = currentAttempt && resolveCompletedForAttempt(statements, currentAttempt, options === null || options === void 0 ? void 0 : options.activityIRI);
-    const mostRecentAttemptWithCompleted = completedAttempts.reduce((current, attempt) => current && isAfter(parseISO(current.timestamp), parseISO(attempt.timestamp)) ? current : attempt, completedAttempts[0]);
-    const mostRecentAttemptWithCompletedCompleted = mostRecentAttemptWithCompleted
-        && resolveCompletedForAttempt(statements, mostRecentAttemptWithCompleted, options === null || options === void 0 ? void 0 : options.activityIRI);
-    /*
-     * the structure allows for the possibility of multiple incomplete attempts.
-     * the implementation can choose at its discretion to ignore the currentAttempt
-     * and instead make a new one, for instance if the implementation desires
-     * an attempt timeout feature
-     */
-    return {
-        attempts: attempts.length,
-        completedAttempts: completedAttempts.length,
-        currentAttempt,
-        currentAttemptCompleted: currentAttemptCompleted,
-        currentAttemptStatements,
-        mostRecentAttemptWithCompleted,
-        mostRecentAttemptWithCompletedCompleted,
-    };
-};
-/*
- * loads all statements (for this actor) that have the given activityIRI as the object.id or the context.contextActivities.parent.id
- *
- * note: if you filter on attempt you're only gonna get the `Attempted` statements from the child activities, subsequent child activity
- * statements would then have to be fetched using
- * `gateway.getAllXapiStatements({ activity: childActivityIRI, registration: childAttemptStatementID })`.
- * this is because child activities could have multiple attempts under one attempt on the parent activity.
- */
-export const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, options) => {
-    const { attempt, ...partialOptions } = options ? options : { attempt: undefined };
-    const getOptions = attempt ? { registration: attempt, ...partialOptions } : partialOptions;
-    return gateway.getAllXapiStatements({
-        activity: activityIRI,
-        related_activities: true,
-        ...getOptions,
-    });
-};
-export const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
-    const { parentActivityAttempt, ...partialOptions } = options ? options : { parentActivityAttempt: undefined };
-    const loadOptions = parentActivityAttempt ? { ...partialOptions, registration: parentActivityAttempt } : partialOptions;
-    return resolveAttemptInfo(await gateway.getAllXapiStatements({ ...loadOptions, activity: activityIRI }), { ...options, activityIRI });
-};
-export const createStatement = (verb, activity, attempt, parentActivityIRI) => {
-    return {
-        context: {
-            ...(parentActivityIRI ? {
-                contextActivities: {
-                    parent: [
-                        {
-                            id: parentActivityIRI,
-                            objectType: 'Activity',
-                        },
-                    ],
-                },
-            } : {}),
-            registration: attempt,
-        },
-        object: {
-            definition: {
-                extensions: {
-                    ...activity.extensions
-                },
-                name: {
-                    'en-US': activity.name,
-                },
-                type: activity.type,
-            },
-            id: activity.iri,
-            objectType: 'Activity'
-        },
-        verb,
-    };
-};
-/*
- * activity:
- *  - iri: the IRI formatted id for this activity
- *  - type: the IRI formatted activity type (eg: http://id.tincanapi.com/activitytype/school-assignment)
- *  - name: the plaintext name of the activity, for reporting
- *
- * parentActivity:
- *  - iri: the IRI formatted id for the parent activity
- *  - attempt: the statement id for the parent attempt (the object of which should be the parentActivity.iri)
- */
-export const createAttemptStatement = (activity, parentActivity) => {
-    return {
-        ...((parentActivity === null || parentActivity === void 0 ? void 0 : parentActivity.iri) || (parentActivity === null || parentActivity === void 0 ? void 0 : parentActivity.attempt) ? {
-            context: {
-                ...(parentActivity.iri ? {
-                    contextActivities: {
-                        parent: [
-                            {
-                                id: parentActivity.iri,
-                                objectType: 'Activity',
-                            },
-                        ],
-                    },
-                } : {}),
-                ...(parentActivity.attempt ? {
-                    registration: parentActivity.attempt,
-                } : {})
-            },
-        } : {}),
-        object: {
-            definition: {
-                extensions: {
-                    ...activity.extensions
-                },
-                name: {
-                    'en-US': activity.name,
-                },
-                type: activity.type,
-            },
-            id: activity.iri,
-            objectType: 'Activity'
-        },
-        verb: {
-            display: { 'en-US': 'Attempted' },
-            id: Verb.Attempted,
-        },
-    };
-};
-/* resolves with the statement id */
-export const putAttemptStatement = async (gateway, activity, parentActivity) => {
-    return (await gateway.putXapiStatements([createAttemptStatement(activity, parentActivity)]))[0];
-};
-/*
- * creates a statement under the given attempt.
- *
- * `result` optional context for the attempt result (score, selected answer, etc)
- */
-export const createAttemptActivityStatement = (attemptStatement, verb, result) => {
-    var _a;
-    return {
-        context: {
-            ...(((_a = attemptStatement.context) === null || _a === void 0 ? void 0 : _a.contextActivities) ? {
-                contextActivities: attemptStatement.context.contextActivities,
-            } : {}),
-            registration: attemptStatement.id,
-        },
-        object: attemptStatement.object,
-        verb: verb,
-        ...(result ? { result } : {}),
-    };
-};
-export const putAttemptActivityStatement = async (gateway, attemptStatement, verb, result) => {
-    return (await gateway.putXapiStatements([createAttemptActivityStatement(attemptStatement, verb, result)]))[0];
-};
-/*
- * creates a statement that completes the given attempt.
- *
- * `result` optional context for the attempt result (score, selected answer, etc)
- */
-export const createCompletedStatement = (attemptStatement, result) => {
-    var _a, _b;
-    return {
-        context: {
-            ...(((_a = attemptStatement.context) === null || _a === void 0 ? void 0 : _a.contextActivities) ? {
-                contextActivities: attemptStatement.context.contextActivities,
-            } : {}),
-            ...(((_b = attemptStatement.context) === null || _b === void 0 ? void 0 : _b.registration) ? {
-                registration: attemptStatement.context.registration,
-            } : {}),
-            statement: {
-                objectType: 'StatementRef',
-                id: attemptStatement.id,
-            }
-        },
-        object: attemptStatement.object,
-        verb: {
-            display: { 'en-US': 'Completed' },
-            id: Verb.Completed,
-        },
-        result: {
-            duration: formatISODuration(intervalToDuration({
-                start: parseISO(attemptStatement.timestamp), end: new Date()
-            })),
-            ...result,
-        }
-    };
-};
-export const putCompletedStatement = async (gateway, attemptStatement, result) => {
-    return (await gateway.putXapiStatements([createCompletedStatement(attemptStatement, result)]))[0];
-};

package/dist/esm/services/lrsGateway/file-system.d.ts

@@ -1,15 +0,0 @@
-import { ConfigProviderForConfig } from '../../config';
-import { AuthProvider } from '../authProvider';
-import { LrsGateway } from '.';
-type Config = {
-    name: string;
-};
-interface Initializer<C> {
-    dataDir: string;
-    fs?: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
-    configSpace?: C;
-}
-export declare const fileSystemLrsGateway: <C extends string = "fileSystem">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => ({ authProvider }: {
-    authProvider: AuthProvider;
-}) => LrsGateway;
-export {};

package/dist/esm/services/lrsGateway/file-system.js

@@ -1,110 +0,0 @@
-import * as fsModule from 'fs';
-import path from 'path';
-import formatISO from 'date-fns/formatISO';
-import { v4 as uuid } from 'uuid';
-import { assertDefined } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { UnauthorizedError } from '../../errors';
-import { ifDefined } from '../../guards';
-const pageSize = 5;
-export const fileSystemLrsGateway = (initializer) => (configProvider) => ({ authProvider }) => {
-    const name = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].name);
-    const filePath = name.then((fileName) => path.join(initializer.dataDir, fileName));
-    const { readFile, writeFile } = ifDefined(initializer.fs, fsModule);
-    let data;
-    const load = filePath.then(path => new Promise(resolve => {
-        readFile(path, (err, readData) => {
-            if (err) {
-                console.error(err);
-            }
-            else {
-                try {
-                    data = JSON.parse(readData.toString());
-                    if (typeof data !== 'object' || !(data instanceof Array)) {
-                        data = undefined;
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            resolve();
-        });
-    }));
-    let previousSave;
-    const putXapiStatements = async (statements) => {
-        const user = assertDefined(await authProvider.getUser(), new UnauthorizedError);
-        const statementsWithDefaults = statements.map(statement => ({
-            ...statement,
-            id: uuid(),
-            actor: {
-                account: {
-                    homePage: 'https://openstax.org',
-                    name: user.uuid,
-                },
-                objectType: 'Agent',
-            },
-            timestamp: formatISO(new Date()),
-        }));
-        await load;
-        await previousSave;
-        const path = await filePath;
-        const save = previousSave = new Promise(resolve => {
-            data = data || [];
-            data.push(...statementsWithDefaults.map(statement => ({ ...statement, stored: statement.timestamp })));
-            writeFile(path, JSON.stringify(data, null, 2), () => resolve());
-        });
-        await save;
-        return statementsWithDefaults;
-    };
-    const getAllXapiStatements = async ({ user, anyUser, fetchUntil, ...options }) => {
-        const authUser = await authProvider.getUser();
-        await load;
-        let filteredData = (data || []).filter(statement => {
-            var _a, _b, _c, _d;
-            const statementDate = new Date(statement.timestamp);
-            const sinceDate = options.since ? new Date(options.since) : null;
-            const untilDate = options.until ? new Date(options.until) : null;
-            return (anyUser === true || statement.actor.account.name === (user || assertDefined(authUser, new UnauthorizedError()).uuid))
-                && (!options.verb || statement.verb.id === options.verb)
-                && (!options.registration || ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === options.registration)
-                && (!options.activity || (options.related_activities
-                    ? ((statement.object.id === options.activity && statement.object.objectType === 'Activity')
-                        || (!!((_d = (_c = (_b = statement.context) === null || _b === void 0 ? void 0 : _b.contextActivities) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.find(parent => parent.id === options.activity && parent.objectType === 'Activity'))))
-                    : (statement.object.id === options.activity && statement.object.objectType === 'Activity')))
-                && (!sinceDate || statementDate >= sinceDate)
-                && (!untilDate || statementDate <= untilDate);
-        });
-        if (fetchUntil) {
-            for (let i = 0; i < filteredData.length; i += pageSize) {
-                if (fetchUntil(filteredData.slice(0, i + pageSize))) {
-                    filteredData = filteredData.slice(0, i + pageSize);
-                    break;
-                }
-            }
-        }
-        return filteredData;
-    };
-    const getMoreXapiStatements = async (more) => {
-        const { args, offset } = JSON.parse(more);
-        const allResults = await getAllXapiStatements(...args);
-        const end = offset + pageSize;
-        return {
-            more: allResults.length > end ? JSON.stringify({ args, offset: end }) : '',
-            statements: allResults.slice(offset, end)
-        };
-    };
-    const getXapiStatements = async (...args) => {
-        const allResults = await getAllXapiStatements(...args);
-        return {
-            more: allResults.length > pageSize ? JSON.stringify({ args, offset: pageSize }) : '',
-            statements: allResults.slice(0, pageSize)
-        };
-    };
-    return {
-        putXapiStatements,
-        getAllXapiStatements,
-        getXapiStatements,
-        getMoreXapiStatements,
-    };
-};

package/dist/esm/services/lrsGateway/index.d.ts

@@ -1,122 +0,0 @@
-import { ConfigProviderForConfig } from '../../config';
-import { GenericFetch } from '../../fetch';
-import { WithRequired } from '../../types';
-import { AuthProvider } from '../authProvider';
-import { Logger } from '../logger';
-type Config = {
-    lrsHost: string;
-    lrsAuthorization: string;
-};
-interface Initializer<C> {
-    configSpace?: C;
-    fetch: GenericFetch;
-}
-export interface XapiStatement {
-    actor: {
-        account: {
-            homePage: 'https://openstax.org';
-            name: string;
-        };
-        objectType: 'Agent';
-    };
-    id: string;
-    context?: {
-        contextActivities?: {
-            parent?: [
-                {
-                    id: string;
-                    objectType: 'Activity';
-                }
-            ];
-        };
-        statement?: {
-            objectType: 'StatementRef';
-            id: string;
-        };
-        registration?: string;
-        platform?: string;
-    };
-    object: {
-        definition?: {
-            extensions?: {
-                [key: string]: string;
-            };
-            name: {
-                [key: string]: string;
-            };
-            type: string;
-        };
-        id: string;
-        objectType: 'Activity';
-    };
-    result?: {
-        score?: {
-            scaled?: number;
-            raw?: number;
-            min?: number;
-            max?: number;
-        };
-        success?: boolean;
-        completion?: boolean;
-        response?: string;
-        duration?: string;
-        extensions?: {
-            [key: string]: string;
-        };
-    };
-    verb: {
-        display?: {
-            [key: string]: string;
-        };
-        id: string;
-    };
-    timestamp: string;
-    stored?: string;
-}
-export type SavedXapiStatement = WithRequired<XapiStatement, 'stored'>;
-export type EagerXapiStatement = Omit<XapiStatement, 'stored'>;
-export type UXapiStatement = XapiStatement | EagerXapiStatement | SavedXapiStatement;
-export type LrsGateway = ReturnType<ReturnType<ReturnType<typeof lrsGateway>>>;
-export type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
-export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => ({ authProvider, logger }: {
-    authProvider: AuthProvider;
-    logger: Logger;
-}) => {
-    putXapiStatements: (statements: Array<(Pick<XapiStatement, "object" | "verb" | "context" | "result"> & {
-        id?: string;
-    }) | UXapiStatement>) => Promise<EagerXapiStatement[]>;
-    getXapiStatements: (params: {
-        verb?: string;
-        activity?: string;
-        registration?: string;
-        related_activities?: boolean;
-        user?: string;
-        anyUser?: boolean;
-        since?: string;
-        until?: string;
-    } & {
-        ensureSync?: boolean;
-    }) => Promise<{
-        more: string;
-        statements: XapiStatement[];
-    }>;
-    getMoreXapiStatements: (more: string) => Promise<{
-        more: string;
-        statements: XapiStatement[];
-    }>;
-    getAllXapiStatements: ({ fetchUntil, ...params }: ({
-        verb?: string;
-        activity?: string;
-        registration?: string;
-        related_activities?: boolean;
-        user?: string;
-        anyUser?: boolean;
-        since?: string;
-        until?: string;
-    } & {
-        ensureSync?: boolean;
-    }) & {
-        fetchUntil?: (statements: XapiStatement[]) => boolean;
-    }) => Promise<XapiStatement[]>;
-};
-export {};

package/dist/esm/services/lrsGateway/index.js

@@ -1,111 +0,0 @@
-import * as queryString from 'query-string';
-import { once } from '../..';
-import { assertDefined } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { UnauthorizedError } from '../../errors';
-import { fetchStatusRetry } from '../../fetch/fetchStatusRetry';
-import { ifDefined } from '../../guards';
-import { retryWithDelay } from '../../misc/helpers';
-import { METHOD } from '../../routing';
-import { addStatementDefaultFields } from './addStatementDefaultFields';
-export const lrsGateway = (initializer) => (configProvider) => {
-    const config = configProvider[ifDefined(initializer.configSpace, 'lrs')];
-    const lrsHost = once(() => resolveConfigValue(config.lrsHost));
-    const lrsAuthorization = once(() => resolveConfigValue(config.lrsAuthorization));
-    return ({ authProvider, logger }) => {
-        const fetcher = fetchStatusRetry(initializer.fetch, {
-            logger,
-            retries: 2,
-            wait: 1000,
-            status: [502]
-        });
-        // Note: This method actually uses POST
-        const putXapiStatements = async (statements) => {
-            const user = assertDefined(await authProvider.getUser(), new UnauthorizedError);
-            const statementsWithDefaults = statements.map(statement => addStatementDefaultFields(statement, user));
-            const response = await fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
-                body: JSON.stringify(statementsWithDefaults),
-                headers: {
-                    Authorization: await lrsAuthorization(),
-                    'Content-Type': 'application/json',
-                    'X-Experience-API-Version': '1.0.0',
-                },
-                method: METHOD.POST,
-            });
-            if (![200, 201].includes(response.status)) {
-                throw new Error(`Unexpected LRS POST statements response code ${response.status} with body:
-
-${await response.text()}`);
-            }
-            await response.json();
-            return statementsWithDefaults;
-        };
-        // Note: This code does not currently handle a single statement response,
-        // which can return 404 if the statement is not found
-        const formatGetXapiStatementsResponse = async (response) => {
-            if (response.status !== 200) {
-                throw new Error(`Unexpected LRS GET statements response code ${response.status} with body:
-
-${await response.text()}`);
-            }
-            return response.json();
-        };
-        const getMoreXapiStatements = async (more) => fetcher((await lrsHost()).replace(/\/+$/, '') + more, {
-            headers: {
-                Authorization: await lrsAuthorization(),
-                'X-Experience-API-Version': '1.0.0',
-            },
-        }).then(formatGetXapiStatementsResponse);
-        const fetchXapiStatements = async ({ user, anyUser, ...options }) => fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
-            ...options,
-            ...(anyUser === true ? {} : {
-                agent: JSON.stringify({
-                    account: {
-                        homePage: 'https://openstax.org',
-                        name: user || assertDefined(await authProvider.getUser(), new UnauthorizedError()).uuid,
-                    },
-                    objectType: 'Agent',
-                }),
-            })
-        }), {
-            headers: {
-                Authorization: await lrsAuthorization(),
-                'X-Experience-API-Version': '1.0.0',
-            },
-        });
-        const getXapiStatements = async (params) => {
-            const { ensureSync, ...fetchParams } = params;
-            if (ensureSync) {
-                const date = new Date();
-                return retryWithDelay(async (abort) => {
-                    // this function retries for the consistency, if the fetch errors just abort
-                    const response = await fetchXapiStatements(fetchParams).catch(abort);
-                    const consistentThrough = response.headers.get('X-Experience-API-Consistent-Through');
-                    if (!consistentThrough || new Date(consistentThrough) < date) {
-                        throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date.toISOString()}.`);
-                    }
-                    return formatGetXapiStatementsResponse(response);
-                }, { retries: 4, logger });
-            }
-            else {
-                return fetchXapiStatements(fetchParams).then(formatGetXapiStatementsResponse);
-            }
-        };
-        const getAllXapiStatements = async ({ fetchUntil, ...params }) => {
-            const loadRemaining = async (result) => {
-                if (!result.more || (fetchUntil && fetchUntil(result.statements))) {
-                    return result.statements;
-                }
-                const { more, statements } = await getMoreXapiStatements(result.more);
-                return loadRemaining({ more, statements: [...result.statements, ...statements] });
-            };
-            return loadRemaining(await getXapiStatements(params));
-        };
-        return {
-            putXapiStatements,
-            getXapiStatements,
-            getMoreXapiStatements,
-            getAllXapiStatements,
-        };
-    };
-};

package/dist/esm/services/lrsGateway/xapiUtils.d.ts

@@ -1,68 +0,0 @@
-import { AccountsGateway, MappedUserInfo } from '../accountsGateway';
-import { AuthProvider } from '../authProvider';
-import { ActivityState } from './attempt-utils';
-import { LrsGateway } from '.';
-export interface Grade {
-    activityProgress: 'Initialized' | 'Started' | 'inProgress' | 'Submitted' | 'Completed';
-    comment?: string;
-    gradingProgress: 'FullyGraded' | 'Pending' | 'PendingManual' | 'Failed' | 'NotReady';
-    scoreGiven: number;
-    scoreMaximum: number;
-    submission?: {
-        startedAt?: string;
-        submittedAt?: string;
-    };
-    userId?: string;
-}
-export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
-    activity?: string;
-    anyUser?: boolean;
-    currentPreference?: "latest" | "oldest";
-    ensureSync?: boolean;
-    user?: string;
-}) => Promise<{
-    [key: string]: ActivityState;
-}>;
-export declare const getScoreGrade: (score: {
-    scaled?: number;
-    raw?: number;
-    min?: number;
-    max?: number;
-}, options: {
-    maxScore?: number;
-    startedAt?: string;
-    submittedAt?: string;
-    userId?: string;
-}) => Grade;
-export type Progress = {
-    scaled: number;
-    max?: number;
-    raw?: number;
-};
-export type GradeAndProgress = {
-    grade: Grade;
-    progress: Progress;
-    name?: string;
-};
-export declare const getCurrentGrade: (services: {
-    lrs: LrsGateway;
-    ltiAuthProvider: AuthProvider;
-}, registration: string, options?: {
-    currentPreference?: "latest" | "oldest";
-    incompleteAttemptCallback?: (info: ActivityState) => Promise<GradeAndProgress>;
-    name?: string;
-    scoreMaximum?: number;
-    userId?: string;
-}) => Promise<GradeAndProgress | null>;
-export type UserActivityInfo = MappedUserInfo<ActivityState>;
-export declare const getAssignmentGrades: (services: {
-    accountsGateway: AccountsGateway;
-    lrs: LrsGateway;
-}, assignmentIRI: string, registration: string, options?: {
-    anyUser?: boolean;
-    currentPreference?: "latest" | "oldest";
-    incompleteAttemptsCallback?: (mappedInfo: UserActivityInfo[]) => Promise<GradeAndProgress[]>;
-    platformId?: string;
-    scoreMaximum?: number;
-    user?: string;
-}) => Promise<GradeAndProgress[]>;