@openstax/ts-utils 1.44.1 → 1.44.3

package/dist/esm/services/authProvider/utils/decryptAndVerify.js

@@ -1,5 +1,5 @@
 import { createDecipheriv, verify } from 'crypto';
-import { isPlainObject } from '../../../guards';
+import { isPlainObject } from '../../../guards/index.js';
 export const decryptJwe = (jwe, encryptionPrivateKey) => {
     const jweParts = jwe.split('.', 6);
     if (jweParts.length !== 5 || jweParts[1]) {

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -1,5 +1,5 @@
-import { User } from '..';
-import { Window } from '../browser';
+import { Window } from '../browser.js';
+import { User } from '../index.js';
 export type UserData<T = User> = {
     user?: T;
     token: string | null;

package/dist/esm/services/authProvider/utils/userRoleValidator.d.ts

@@ -1,6 +1,6 @@
-import { AuthProvider } from '..';
-import { AssertionFailed } from '../../../assertions';
-import { ConfigProviderForConfig } from '../../../config';
+import { AssertionFailed } from '../../../assertions/index.js';
+import { ConfigProviderForConfig } from '../../../config/index.js';
+import { AuthProvider } from '../index.js';
 type Config = {
     application: string;
 };

package/dist/esm/services/authProvider/utils/userRoleValidator.js

@@ -1,7 +1,7 @@
-import { doThrow } from '../../../assertions';
-import { resolveConfigValue } from '../../../config/resolveConfigValue';
-import { UnauthorizedError } from '../../../errors';
-import { once } from '../../../misc/helpers';
+import { doThrow } from '../../../assertions/index.js';
+import { resolveConfigValue } from '../../../config/resolveConfigValue.js';
+import { UnauthorizedError } from '../../../errors/index.js';
+import { once } from '../../../misc/helpers.js';
 export const createUserRoleValidator = (auth, config) => {
     const application = once(() => resolveConfigValue(config.application));
     const getUserRoles = async () => {

package/dist/esm/services/authProvider/utils/userSubrequest.d.ts

@@ -1,3 +1,3 @@
-import { ApiUser } from '..';
-import { GenericFetch } from '../../../fetch';
+import { GenericFetch } from '../../../fetch/index.js';
+import { ApiUser } from '../index.js';
 export declare const loadUserData: (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => Promise<ApiUser | undefined>;

package/dist/esm/services/documentStore/dynamoEncoding.d.ts

@@ -1,5 +1,5 @@
 import { AttributeValue } from '@aws-sdk/client-dynamodb';
-import { DocumentBaseType, DocumentBaseValueTypes } from '.';
+import { DocumentBaseType, DocumentBaseValueTypes } from './index.js';
 export declare const encodeDynamoAttribute: (value: DocumentBaseValueTypes) => AttributeValue;
 export declare const encodeDynamoDocument: (base: DocumentBaseType) => {
     [k: string]: AttributeValue;

package/dist/esm/services/documentStore/dynamoEncoding.js

@@ -1,4 +1,4 @@
-import { isPlainObject } from '../../guards';
+import { isPlainObject } from '../../guards/index.js';
 export const encodeDynamoAttribute = (value) => {
     if (typeof value === 'string') {
         return { S: value };

package/dist/esm/services/documentStore/unversioned/dynamodb.d.ts

@@ -1,6 +1,6 @@
 import { DynamoDB } from '@aws-sdk/client-dynamodb';
-import { Config, TDocument } from '..';
-import { ConfigProviderForConfig } from '../../../config';
+import { ConfigProviderForConfig } from '../../../config/index.js';
+import { Config, TDocument } from '../index.js';
 interface Initializer<C> {
     configSpace?: C;
     dynamoClient?: DynamoDB;

package/dist/esm/services/documentStore/unversioned/dynamodb.js

@@ -1,10 +1,10 @@
 import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, QueryCommand, ScanCommand, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
 import asyncPool from 'tiny-async-pool';
-import { once } from '../../..';
-import { resolveConfigValue } from '../../../config';
-import { ConflictError, NotFoundError } from '../../../errors';
-import { ifDefined } from '../../../guards';
-import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
+import { resolveConfigValue } from '../../../config/index.js';
+import { ConflictError, NotFoundError } from '../../../errors/index.js';
+import { ifDefined } from '../../../guards/index.js';
+import { once } from '../../../index.js';
+import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding.js';
 export const dynamoUnversionedDocumentStore = (initializer) => {
     const init = ifDefined(initializer, {});
     const dynamodb = once(() => { var _a; return (_a = init.dynamoClient) !== null && _a !== void 0 ? _a : new DynamoDB({ apiVersion: '2012-08-10' }); });

package/dist/esm/services/documentStore/unversioned/file-system.d.ts

@@ -1,5 +1,5 @@
-import { Config, TDocument } from '..';
-import { ConfigProviderForConfig } from '../../../config';
+import { ConfigProviderForConfig } from '../../../config/index.js';
+import { Config, TDocument } from '../index.js';
 interface Initializer<C> {
     dataDir: string;
     fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;

package/dist/esm/services/documentStore/unversioned/file-system.js

@@ -1,9 +1,9 @@
 import * as fsModule from 'fs';
 import path from 'path';
-import { hashValue } from '../../..';
-import { resolveConfigValue } from '../../../config';
-import { ConflictError, NotFoundError } from '../../../errors';
-import { ifDefined, isDefined } from '../../../guards';
+import { resolveConfigValue } from '../../../config/index.js';
+import { ConflictError, NotFoundError } from '../../../errors/index.js';
+import { ifDefined, isDefined } from '../../../guards/index.js';
+import { hashValue } from '../../../index.js';
 export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
     const tableName = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].tableName);
     const tablePath = tableName.then((table) => path.join(initializer.dataDir, table));

package/dist/esm/services/documentStore/unversioned/index.d.ts

@@ -1,2 +1,2 @@
-import { dynamoUnversionedDocumentStore } from './dynamodb';
+import { dynamoUnversionedDocumentStore } from './dynamodb.js';
 export type UnversionedDocumentStoreCreator = typeof dynamoUnversionedDocumentStore;

package/dist/esm/services/documentStore/versioned/dynamodb.d.ts

@@ -1,7 +1,7 @@
 import { DynamoDB } from '@aws-sdk/client-dynamodb';
-import { Config } from '..';
-import { ConfigProviderForConfig } from '../../../config';
-import { VersionedDocumentAuthor, VersionedTDocument } from '.';
+import { ConfigProviderForConfig } from '../../../config/index.js';
+import { Config } from '../index.js';
+import { VersionedDocumentAuthor, VersionedTDocument } from './index.js';
 interface Initializer<C> {
     configSpace?: C;
     dynamoClient?: DynamoDB;

package/dist/esm/services/documentStore/versioned/dynamodb.js

@@ -1,8 +1,8 @@
 import { DynamoDB, PutItemCommand, QueryCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
-import { once } from '../../..';
-import { resolveConfigValue } from '../../../config';
-import { ifDefined } from '../../../guards';
-import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
+import { resolveConfigValue } from '../../../config/index.js';
+import { ifDefined } from '../../../guards/index.js';
+import { once } from '../../../index.js';
+import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding.js';
 // i'm not really excited about getAuthor being required, but ts is getting confused about the type when unspecified
 export const dynamoVersionedDocumentStore = (initializer) => {
     const init = ifDefined(initializer, {});

package/dist/esm/services/documentStore/versioned/file-system.d.ts

@@ -1,6 +1,6 @@
-import { Config } from '..';
-import { ConfigProviderForConfig } from '../../../config';
-import { VersionedDocumentAuthor, VersionedTDocument } from '.';
+import { ConfigProviderForConfig } from '../../../config/index.js';
+import { Config } from '../index.js';
+import { VersionedDocumentAuthor, VersionedTDocument } from './index.js';
 interface Initializer<C> {
     dataDir: string;
     fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;

package/dist/esm/services/documentStore/versioned/file-system.js

@@ -1,4 +1,4 @@
-import { fileSystemUnversionedDocumentStore } from '../unversioned/file-system';
+import { fileSystemUnversionedDocumentStore } from '../unversioned/file-system.js';
 const PAGE_LIMIT = 5;
 export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
     const unversionedDocuments = fileSystemUnversionedDocumentStore(initializer)()(configProvider)({}, 'id');

package/dist/esm/services/documentStore/versioned/index.d.ts

@@ -1,5 +1,5 @@
-import { TDocument } from '..';
-import { dynamoVersionedDocumentStore } from './dynamodb';
+import { TDocument } from '../index.js';
+import { dynamoVersionedDocumentStore } from './dynamodb.js';
 export type VersionedDocumentAuthor = {
     type: 'user';
     uuid: string;

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

@@ -1,5 +1,5 @@
-import { ConfigProviderForConfig } from '../../config';
-import { GenericFetch } from '../../fetch';
+import { ConfigProviderForConfig } from '../../config/index.js';
+import { GenericFetch } from '../../fetch/index.js';
 export type Config = {
     defaultCorrectness?: string;
     exercisesHost: string;

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

@@ -1,9 +1,9 @@
 import * as queryString from 'query-string';
-import { once } from '../..';
-import { assertString } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
-import { METHOD } from '../../routing';
+import { assertString } from '../../assertions/index.js';
+import { resolveConfigValue } from '../../config/index.js';
+import { ifDefined } from '../../guards/index.js';
+import { once } from '../../index.js';
+import { METHOD } from '../../routing/index.js';
 export const exercisesGateway = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'exercises')];
     const exercisesHost = once(() => resolveConfigValue(config.exercisesHost));

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

@@ -1,4 +1,4 @@
-import { isPlainObject } from '../../guards';
+import { isPlainObject } from '../../guards/index.js';
 export const isFileValue = (thing) => isPlainObject(thing)
     && Object.keys(thing).every(key => ['dataType', 'path', 'label', 'mimeType'].includes(key))
     && thing.dataType === 'file'

package/dist/esm/services/fileServer/localFileServer.d.ts

@@ -1,5 +1,5 @@
-import { ConfigProviderForConfig } from '../../config';
-import { FileServerAdapter } from '.';
+import { ConfigProviderForConfig } from '../../config/index.js';
+import { FileServerAdapter } from './index.js';
 export type Config = {
     port?: string;
     host?: string;

package/dist/esm/services/fileServer/localFileServer.js

@@ -1,39 +1,100 @@
-/* cspell:ignore originalname */
+/* spell-checker: ignore originalname busboy */
 import crypto from 'crypto';
 import fs from 'fs';
 import https from 'https';
 import path from 'path';
-import cors from 'cors';
-import express from 'express';
-import multer from 'multer';
+import { pipeline } from 'stream/promises';
+import Busboy from 'busboy';
 import { v4 as uuid } from 'uuid';
-import { assertString } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
-import { memoize } from '../../misc/helpers';
+import { assertString } from '../../assertions/index.js';
+import { resolveConfigValue } from '../../config/index.js';
+import { ifDefined } from '../../guards/index.js';
+import { memoize } from '../../misc/helpers.js';
 /* istanbul ignore next */
-const startServer = memoize((port, uploadDir) => {
-    // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
-    const upload = multer({ dest: uploadDir, preservePath: true });
-    const fileServerApp = express();
-    fileServerApp.use(cors());
-    fileServerApp.use(express.static(uploadDir));
-    fileServerApp.post('/', upload.single('file'), async (req, res) => {
-        const file = req.file;
-        if (!file) {
-            return res.status(400).send({ message: 'file is required' });
+const serveStaticFile = async (filePath, res) => {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        if (!stat.isFile()) {
+            res.writeHead(404);
+            res.end();
+            return;
         }
-        const destinationName = req.body.key.replace('${filename}', file.originalname);
+        res.writeHead(200, { 'Content-Length': stat.size });
+        await pipeline(fs.createReadStream(filePath), res);
+    }
+    catch {
+        res.writeHead(404);
+        res.end();
+    }
+};
+/* istanbul ignore next */
+const handleUpload = (req, res, uploadDir) => {
+    const busboy = Busboy({ headers: req.headers });
+    let key = '';
+    let originalName = '';
+    let tempPath = '';
+    busboy.on('field', (name, value) => {
+        if (name === 'key')
+            key = value;
+    });
+    busboy.on('file', (_name, file, info) => {
+        originalName = info.filename;
+        tempPath = path.join(uploadDir, uuid());
+        file.pipe(fs.createWriteStream(tempPath));
+    });
+    busboy.on('finish', async () => {
+        if (!tempPath) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ message: 'file is required' }));
+            return;
+        }
+        const destinationName = key.replace('${filename}', originalName);
         const destinationPath = path.join(uploadDir, destinationName);
         const destinationDirectory = path.dirname(destinationPath);
         await fs.promises.mkdir(destinationDirectory, { recursive: true });
-        await fs.promises.rename(file.path, destinationPath);
-        res.status(201).send();
+        await fs.promises.rename(tempPath, destinationPath);
+        res.writeHead(201);
+        res.end();
     });
+    req.pipe(busboy);
+};
+/* istanbul ignore next */
+const setCorsHeaders = (res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+};
+/* istanbul ignore next */
+const startServer = memoize((port, uploadDir) => {
     const server = https.createServer({
         key: fs.readFileSync(assertString(process.env.SSL_KEY_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
         cert: fs.readFileSync(assertString(process.env.SSL_CRT_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
-    }, fileServerApp);
+    }, (req, res) => {
+        setCorsHeaders(res);
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/') {
+            handleUpload(req, res, uploadDir);
+            return;
+        }
+        if (req.method === 'GET') {
+            const urlPath = decodeURIComponent(new URL(req.url || '/', 'https://localhost').pathname);
+            const filePath = path.join(uploadDir, urlPath);
+            // prevent directory traversal
+            if (!filePath.startsWith(uploadDir)) {
+                res.writeHead(403);
+                res.end();
+                return;
+            }
+            serveStaticFile(filePath, res);
+            return;
+        }
+        res.writeHead(405);
+        res.end();
+    });
     server.once('error', function (err) {
         if (err.code === 'EADDRINUSE') {
             // when the local dev server reloads files on every request it doesn't

package/dist/esm/services/fileServer/s3FileServer.d.ts

@@ -1,6 +1,6 @@
 import { S3Client } from '@aws-sdk/client-s3';
-import { ConfigProviderForConfig } from '../../config';
-import { FileServerAdapter } from '.';
+import { ConfigProviderForConfig } from '../../config/index.js';
+import { FileServerAdapter } from './index.js';
 export type Config = {
     bucketName: string;
     bucketRegion: string;

package/dist/esm/services/fileServer/s3FileServer.js

@@ -1,13 +1,13 @@
-/* cspell:ignore presigner */
+/* spell-checker: ignore presigner */
 import path from 'path';
 import { CopyObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { v4 as uuid } from 'uuid';
-import { once } from '../..';
-import { assertDefined } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
+import { assertDefined } from '../../assertions/index.js';
+import { resolveConfigValue } from '../../config/index.js';
+import { ifDefined } from '../../guards/index.js';
+import { once } from '../../index.js';
 export const s3FileServer = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
     const bucketName = once(() => resolveConfigValue(config.bucketName));

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

@@ -1,7 +1,7 @@
 import { APIGatewayProxyEventV2 } from 'aws-lambda';
 import { VerifyConfig } from 'http-message-signatures';
 import { JWK } from 'node-jose';
-import { ConfigProviderForConfig } from '../../config';
+import { ConfigProviderForConfig } from '../../config/index.js';
 type Config = {
     apiHost: string;
     bypassSignatureVerification: string;

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

@@ -1,13 +1,13 @@
-// cspell:ignore algs, httpbis, keyid
+/* spell-checker: ignore algs httpbis keyid */
 import { createHash } from 'crypto';
 import { createVerifier, httpbis } from 'http-message-signatures';
 import { SigningKeyNotFoundError } from 'jwks-rsa';
 import { ByteSequence, parseDictionary, parseItem, Token } from 'structured-headers';
-import { assertString } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { InvalidRequestError } from '../../errors';
-import { once } from '../../misc/helpers';
-import { getJwksClient } from '../../misc/jwks';
+import { assertString } from '../../assertions/index.js';
+import { resolveConfigValue } from '../../config/index.js';
+import { InvalidRequestError } from '../../errors/index.js';
+import { once } from '../../misc/helpers.js';
+import { getJwksClient } from '../../misc/jwks.js';
 export const createHttpMessageVerifier = ({ configSpace, fetcher }) => (configProvider) => {
     const config = configProvider[configSpace !== null && configSpace !== void 0 ? configSpace : 'verifier'];
     const getApiHost = once(async () => await resolveConfigValue(config.apiHost));

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

@@ -1,2 +1,2 @@
-export { createLaunchSigner } from './signer';
-export { createLaunchVerifier } from './verifier';
+export { createLaunchSigner } from './signer.js';
+export { createLaunchVerifier } from './verifier.js';

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

@@ -1,2 +1,2 @@
-export { createLaunchSigner } from './signer';
-export { createLaunchVerifier } from './verifier';
+export { createLaunchSigner } from './signer.js';
+export { createLaunchVerifier } from './verifier.js';

package/dist/esm/services/launchParams/signer.d.ts

@@ -1,6 +1,6 @@
 import { JWK } from 'node-jose';
-import { ConfigProviderForConfig } from '../../config';
-import type { JsonCompatibleStruct } from '../../routing';
+import { ConfigProviderForConfig } from '../../config/index.js';
+import type { JsonCompatibleStruct } from '../../routing/index.js';
 type Config = {
     alg: string;
     expiresIn: string;

package/dist/esm/services/launchParams/signer.js

@@ -1,9 +1,9 @@
 import jwt from 'jsonwebtoken';
 import ms from 'ms';
 import { JWK } from 'node-jose';
-import { once } from '../..';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
+import { resolveConfigValue } from '../../config/index.js';
+import { ifDefined } from '../../guards/index.js';
+import { once } from '../../index.js';
 const SUPPORTED_ALGORITHMS = [
     'RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'PS256', 'PS384', 'PS512'
 ];

package/dist/esm/services/launchParams/verifier.d.ts

@@ -1,6 +1,6 @@
 import jwt from 'jsonwebtoken';
 import type { JWK } from 'node-jose';
-import { ConfigProviderForConfig } from '../../config';
+import { ConfigProviderForConfig } from '../../config/index.js';
 type Config = {
     trustedDomain: string;
     bypassSignatureVerification: string;

package/dist/esm/services/launchParams/verifier.js

@@ -1,9 +1,9 @@
 import jwt, { TokenExpiredError } from 'jsonwebtoken';
-import { resolveConfigValue } from '../../config';
-import { InvalidRequestError, SessionExpiredError } from '../../errors';
-import { ifDefined } from '../../guards';
-import { once } from '../../misc/helpers';
-import { getJwksKey } from '../../misc/jwks';
+import { resolveConfigValue } from '../../config/index.js';
+import { InvalidRequestError, SessionExpiredError } from '../../errors/index.js';
+import { ifDefined } from '../../guards/index.js';
+import { once } from '../../misc/helpers.js';
+import { getJwksKey } from '../../misc/jwks.js';
 /**
  * Creates a class that can verify launch params
  */

package/dist/esm/services/logger/console.d.ts

@@ -1,4 +1,4 @@
 /**
  * Creates a logger that logs to the console.
  */
-export declare const createConsoleLogger: () => import(".").Logger;
+export declare const createConsoleLogger: () => import("./index.js").Logger;

package/dist/esm/services/logger/console.js

@@ -1,4 +1,4 @@
-import { createCoreLogger } from '.';
+import { createCoreLogger } from './index.js';
 /**
  * Creates a logger that logs to the console.
  */

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

@@ -1,4 +1,4 @@
-import { JsonCompatibleStruct } from '../../routing';
+import { JsonCompatibleStruct } from '../../routing/index.js';
 /**
  * The log level
  */

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

@@ -1,4 +1,4 @@
-import { EagerXapiStatement, UXapiStatement, XapiStatement } from '.';
+import { EagerXapiStatement, UXapiStatement, XapiStatement } from './index.js';
 export declare const addStatementDefaultFields: (statement: (Pick<XapiStatement, "object" | "verb" | "context" | "result"> & {
     id?: string;
 }) | UXapiStatement, user: {

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

@@ -1,14 +1,9 @@
 import formatISO from 'date-fns/formatISO';
 import { v4 as uuid } from 'uuid';
+import { formatAgent } from './attempt-utils.js';
 export const addStatementDefaultFields = (statement, user) => ({
     id: uuid(),
-    actor: {
-        account: {
-            homePage: 'https://openstax.org',
-            name: user.uuid,
-        },
-        objectType: 'Agent',
-    },
+    actor: formatAgent(user.uuid),
     timestamp: formatISO(new Date()),
     ...statement,
 });

package/dist/esm/services/lrsGateway/attempt-utils.d.ts

@@ -1,4 +1,5 @@
-import { LrsGateway, UXapiStatement } from '.';
+import { LrsGateway, UXapiStatement, XapiAgent } from './index.js';
+export declare const formatAgent: (agent: string | XapiAgent) => XapiAgent;
 export declare const EXT_PENDING_SCORING = "https://openstax.org/xapi/extensions/pending-scoring";
 export type AttemptEntry = {
     attempt: UXapiStatement;
@@ -41,7 +42,7 @@ export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGat
     attempt?: string;
     ensureSync?: boolean;
     user?: string;
-}) => Promise<import(".").XapiStatement[]>;
+}) => Promise<import("./index.js").XapiStatement[]>;
 export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
     currentAttempt?: string;
     parentActivityAttempt?: string;
@@ -54,7 +55,7 @@ export declare const createStatement: (verb: UXapiStatement["verb"], activity: {
     extensions?: {
         [key: string]: string;
     };
-}, attempt: string, parentActivityIRI?: string) => Pick<UXapiStatement, "object" | "verb" | "context">;
+}, attempt: string, parentActivityIRI?: string, instructor?: string) => Pick<UXapiStatement, "object" | "verb" | "context">;
 export declare const createAttemptStatement: (activity: {
     iri: string;
     type: string;
@@ -76,14 +77,14 @@ export declare const putAttemptStatement: (gateway: LrsGateway, activity: {
 }, parentActivity?: {
     iri?: string;
     attempt?: string;
-}) => Promise<import(".").EagerXapiStatement>;
+}) => Promise<import("./index.js").EagerXapiStatement>;
 export declare const createAttemptActivityStatement: (attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
-export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Promise<import(".").EagerXapiStatement>;
+export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Promise<import("./index.js").EagerXapiStatement>;
 export declare const createCompletedStatement: (attemptStatement: UXapiStatement, result?: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
-export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"], user?: string) => Promise<import(".").EagerXapiStatement>;
+export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"], user?: string) => Promise<import("./index.js").EagerXapiStatement>;
 export declare const createCompletedPendingScoringStatement: (attemptStatement: UXapiStatement) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
-export declare const putCompletedPendingScoringStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, user?: string) => Promise<import(".").EagerXapiStatement>;
-export declare const createScoredStatement: (attemptStatement: UXapiStatement, result: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
-export declare const putScoredStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"], user?: string) => Promise<import(".").EagerXapiStatement>;
+export declare const putCompletedPendingScoringStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, user?: string) => Promise<import("./index.js").EagerXapiStatement>;
+export declare const createScoredStatement: (attemptStatement: UXapiStatement, result: UXapiStatement["result"], instructor?: string) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
+export declare const putScoredStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"], user?: string, instructor?: string) => Promise<import("./index.js").EagerXapiStatement>;
 export declare const createScoredPendingScoringStatement: (attemptStatement: UXapiStatement, result: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
-export declare const putScoredPendingScoringStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"], user?: string) => Promise<import(".").EagerXapiStatement>;
+export declare const putScoredPendingScoringStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"], user?: string) => Promise<import("./index.js").EagerXapiStatement>;