@algebrakit/sdk 1.0.0

package/dist/demo/demo.js

@@ -0,0 +1,373 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApiClient_1 = require("../src/ApiClient");
+const config_1 = require("./config");
+// Test exercise ID as specified in requirements
+const TEST_EXERCISE_ID = 'fa42e943-8213-41a6-8a91-8c22a929ffe9';
+/**
+ * Displays penalties in a formatted way
+ */
+function displayPenalties(penalties, level) {
+    if (!penalties) {
+        console.log(`   ${level} Penalties: None`);
+        return;
+    }
+    console.log(`   ${level} Penalties:`);
+    console.log(`     - Hints Requested: ${penalties.hintsRequested || 0}`);
+    console.log(`     - Math Errors: ${penalties.mathErrors || 0}`);
+    console.log(`     - Marks Penalty: ${penalties.marksPenalty || 0}`);
+}
+/**
+ * Step 1: Validate exercise
+ */
+function validateExercise(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\nStep 1: Validating Exercise');
+        console.log(`   Exercise ID: ${TEST_EXERCISE_ID}`);
+        try {
+            const request = {
+                exerciseId: TEST_EXERCISE_ID
+            };
+            const response = yield client.validateExercise(request);
+            console.log('Exercise validation successful');
+            console.log(`   - Valid: ${response.valid}`);
+            console.log(`   - Marks: ${response.marks || 'N/A'}`);
+            console.log(`   - Random: ${response.random || false}`);
+            if (response.interactions) {
+                const interactionCount = Object.keys(response.interactions).length;
+                console.log(`   - Interactions: ${interactionCount}`);
+            }
+        }
+        catch (error) {
+            console.error('   ❌ Exercise validation failed:', error.message);
+            throw error;
+        }
+    });
+}
+/**
+ * Step 2: Create a new session
+ */
+function createSession(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\nStep 2: Creating New Session');
+        console.log(`   Exercise ID: ${TEST_EXERCISE_ID}`);
+        try {
+            const request = {
+                exercises: [
+                    {
+                        exerciseId: TEST_EXERCISE_ID,
+                        version: 'latest'
+                    }
+                ],
+                apiVersion: 2
+            };
+            const response = yield client.createSession(request);
+            // Extract session ID from response
+            if (response && response.length > 0 && response[0].sessions && response[0].sessions.length > 0) {
+                const sessionId = response[0].sessions[0].sessionId;
+                console.log('Session created successfully');
+                console.log(`   - Session ID: ${sessionId}`);
+                console.log(`   - Success: ${response[0].success}`);
+                return sessionId;
+            }
+            else {
+                throw new Error('No session ID returned in response');
+            }
+        }
+        catch (error) {
+            console.error('   ❌ Session creation failed:', error.message);
+            throw error;
+        }
+    });
+}
+/**
+ * Step 3: Lock and unlock the session
+ */
+function lockUnlockSession(client, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\nStep 3: Testing Session Lock/Unlock');
+        console.log(`   Session ID: ${sessionId}`);
+        try {
+            // Lock the session
+            console.log('   Locking session...');
+            const lockRequest = {
+                action: 'LOCK',
+                sessionIds: [sessionId]
+            };
+            yield client.lockSession(lockRequest);
+            console.log('   Session locked successfully');
+            // Unlock the session
+            console.log('   Unlocking session...');
+            const unlockRequest = {
+                action: 'UNLOCK',
+                sessionIds: [sessionId]
+            };
+            yield client.lockSession(unlockRequest);
+            console.log('   Session unlocked successfully');
+        }
+        catch (error) {
+            console.error('   ❌ Lock/Unlock operation failed:', error.message);
+            throw error;
+        }
+    });
+}
+/**
+ * Step 4: Get session score with penalty information
+ */
+function getSessionScore(client, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\nStep 4: Getting Session Score with Penalties');
+        console.log(`   Session ID: ${sessionId}`);
+        try {
+            const request = {
+                sessionId: sessionId,
+                lockSession: false
+            };
+            const response = yield client.getSessionScore(request);
+            console.log('   Session score retrieved successfully');
+            // Display exercise-level scoring with penalties
+            console.log('\n   Exercise Level Scoring:');
+            console.log(`   - Finished: ${response.scoring.finished}`);
+            console.log(`   - Marks Total: ${response.scoring.marksTotal}`);
+            console.log(`   - Marks Earned: ${response.scoring.marksEarned}`);
+            displayPenalties(response.scoring.penalties, 'Exercise');
+            // Display question-level scoring with penalties
+            if (response.questions && response.questions.length > 0) {
+                console.log('\n   Question Level Scoring:');
+                response.questions.forEach((question, qIndex) => {
+                    console.log(`\n   Question ${qIndex + 1} (ID: ${question.id}):`);
+                    console.log(`     - Finished: ${question.scoring.finished}`);
+                    console.log(`     - Marks Total: ${question.scoring.marksTotal}`);
+                    console.log(`     - Marks Earned: ${question.scoring.marksEarned}`);
+                    displayPenalties(question.scoring.penalties, 'Question');
+                    // Display interaction-level scoring with penalties
+                    if (question.interactions && question.interactions.length > 0) {
+                        console.log(`\n     💡 Interactions for Question ${qIndex + 1}:`);
+                        question.interactions.forEach((interaction, iIndex) => {
+                            console.log(`\n     Interaction ${iIndex + 1} (ID: ${interaction.id}):`);
+                            console.log(`       - Type: ${interaction.type}`);
+                            console.log(`       - Status: ${interaction.status}`);
+                            console.log(`       - Progress: ${interaction.progress}`);
+                            console.log(`       - Finished: ${interaction.scoring.finished}`);
+                            console.log(`       - Marks Total: ${interaction.scoring.marksTotal}`);
+                            console.log(`       - Marks Earned: ${interaction.scoring.marksEarned}`);
+                            displayPenalties(interaction.scoring.penalties, 'Interaction');
+                        });
+                    }
+                });
+            }
+            // Verify penalty aggregation
+            console.log('\n   Verifying Penalty Aggregation:');
+            verifyPenaltyAggregation(response);
+        }
+        catch (error) {
+            console.error('   ❌ Failed to get session score:', error.message);
+            throw error;
+        }
+    });
+}
+/**
+ * Verify that penalties are correctly aggregated across levels
+ */
+function verifyPenaltyAggregation(response) {
+    var _a;
+    let totalHintsFromQuestions = 0;
+    let totalErrorsFromQuestions = 0;
+    let totalPenaltyFromQuestions = 0;
+    // Sum up penalties from all questions
+    (_a = response.questions) === null || _a === void 0 ? void 0 : _a.forEach(question => {
+        var _a;
+        if (question.scoring.penalties) {
+            totalHintsFromQuestions += question.scoring.penalties.hintsRequested || 0;
+            totalErrorsFromQuestions += question.scoring.penalties.mathErrors || 0;
+            totalPenaltyFromQuestions += question.scoring.penalties.marksPenalty || 0;
+        }
+        // Also verify question level aggregation from interactions
+        let questionHints = 0;
+        let questionErrors = 0;
+        let questionPenalty = 0;
+        (_a = question.interactions) === null || _a === void 0 ? void 0 : _a.forEach(interaction => {
+            if (interaction.scoring.penalties) {
+                questionHints += interaction.scoring.penalties.hintsRequested || 0;
+                questionErrors += interaction.scoring.penalties.mathErrors || 0;
+                questionPenalty += interaction.scoring.penalties.marksPenalty || 0;
+            }
+        });
+        // Verify question-level aggregation
+        const qPenalties = question.scoring.penalties;
+        if (qPenalties) {
+            const hintsMatch = (qPenalties.hintsRequested || 0) === questionHints;
+            const errorsMatch = (qPenalties.mathErrors || 0) === questionErrors;
+            const penaltyMatch = (qPenalties.marksPenalty || 0) === questionPenalty;
+            console.log(`   Question ${question.id} aggregation: ${hintsMatch && errorsMatch && penaltyMatch ? '✅' : '❌'}`);
+            if (!hintsMatch)
+                console.log(`     ⚠️  Hints mismatch: ${qPenalties.hintsRequested} vs ${questionHints}`);
+            if (!errorsMatch)
+                console.log(`     ⚠️  Errors mismatch: ${qPenalties.mathErrors} vs ${questionErrors}`);
+            if (!penaltyMatch)
+                console.log(`     ⚠️  Penalty mismatch: ${qPenalties.marksPenalty} vs ${questionPenalty}`);
+        }
+    });
+    // Verify exercise-level aggregation
+    const exercisePenalties = response.scoring.penalties;
+    if (exercisePenalties) {
+        const hintsMatch = (exercisePenalties.hintsRequested || 0) === totalHintsFromQuestions;
+        const errorsMatch = (exercisePenalties.mathErrors || 0) === totalErrorsFromQuestions;
+        const penaltyMatch = (exercisePenalties.marksPenalty || 0) === totalPenaltyFromQuestions;
+        console.log(`   Exercise level aggregation: ${hintsMatch && errorsMatch && penaltyMatch ? '✅' : '❌'}`);
+        if (!hintsMatch)
+            console.log(`     ⚠️  Hints mismatch: ${exercisePenalties.hintsRequested} vs ${totalHintsFromQuestions}`);
+        if (!errorsMatch)
+            console.log(`     ⚠️  Errors mismatch: ${exercisePenalties.mathErrors} vs ${totalErrorsFromQuestions}`);
+        if (!penaltyMatch)
+            console.log(`     ⚠️  Penalty mismatch: ${exercisePenalties.marksPenalty} vs ${totalPenaltyFromQuestions}`);
+    }
+    else {
+        console.log('   ℹNo penalties at exercise level (might be a new session)');
+    }
+}
+/**
+ * Step 5: Get detailed session information
+ */
+function getSessionInfo(client, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\n📄 Step 5: Getting Detailed Session Information');
+        console.log(`   Session ID: ${sessionId}`);
+        try {
+            const request = {
+                sessionId: sessionId
+            };
+            const response = yield client.getSessionInfo(request);
+            console.log('   Session info retrieved successfully!');
+            if (response.elements && response.elements.length > 0) {
+                console.log(`   - Elements: ${response.elements.length}`);
+                response.elements.forEach((element, index) => {
+                    console.log(`\n   Element ${index + 1}:`);
+                    console.log(`     - Type: ${element.type}`);
+                    if (element.items) {
+                        console.log(`     - Items: ${element.items.length}`);
+                    }
+                });
+            }
+            if (response.tagDescriptions) {
+                const tagCount = Object.keys(response.tagDescriptions).length;
+                console.log(`\n   - Tag Descriptions: ${tagCount} tags`);
+            }
+        }
+        catch (error) {
+            console.error('   ❌ Failed to get session info:', error.message);
+            throw error;
+        }
+    });
+}
+/**
+ * Step 6: Create a session using an AK_Exercise specification
+ */
+function createSessionWithExerciseSpec(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\nStep 6: Creating Session with AK_Exercise Spec');
+        // Define an exercise using the AK_Exercise format
+        const exerciseSpec = {
+            type: 'AK_Exercise',
+            version: 1,
+            studentProfile: 'uk_KS5',
+            questionMode: 'ALL_AT_ONCE',
+            symbols: [
+                { name: 'x', type: 'VARIABLE' },
+            ],
+            elements: [
+                {
+                    blocks: [
+                        {
+                            type: 'CONTENT',
+                            content: 'Simplify the following expression.',
+                        },
+                        {
+                            type: 'INTERACTION',
+                            interaction: {
+                                type: 'MULTISTEP',
+                                solutionPart: {
+                                    task: {
+                                        type: 'SIMPLIFY',
+                                        expression: '2x + 3x',
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+        try {
+            // Validate the exercise spec first
+            const validateResponse = yield client.validateExercise({ exerciseSpec });
+            console.log(`   Validation: valid=${validateResponse.valid}, marks=${validateResponse.marks}`);
+            // Create a session from the spec
+            const request = {
+                exercises: [{ exerciseSpec }],
+                apiVersion: 2,
+            };
+            const response = yield client.createSession(request);
+            if (response && response.length > 0 && response[0].sessions && response[0].sessions.length > 0) {
+                const sessionId = response[0].sessions[0].sessionId;
+                console.log('   Session created successfully from AK_Exercise spec');
+                console.log(`   - Session ID: ${sessionId}`);
+                return sessionId;
+            }
+            else {
+                throw new Error('No session ID returned in response');
+            }
+        }
+        catch (error) {
+            console.error('   Session creation from spec failed:', error.message);
+            throw error;
+        }
+    });
+}
+/**
+ * Main demo function
+ */
+function runDemo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\nAlgebrakit TypeScript SDK Demo');
+        console.log('='.repeat(50));
+        // Load configuration
+        const config = (0, config_1.loadConfig)();
+        // Initialize API client
+        const client = new ApiClient_1.ApiClient(config.apiUrl, config.apiKey);
+        try {
+            // Run test scenario
+            yield validateExercise(client);
+            const sessionId = yield createSession(client);
+            yield lockUnlockSession(client, sessionId);
+            yield getSessionScore(client, sessionId);
+            yield getSessionInfo(client, sessionId);
+            // Demo: create session from AK_Exercise spec
+            yield createSessionWithExerciseSpec(client);
+        }
+        catch (error) {
+            console.error('\n❌ Demo failed with error:', error.message);
+            if (error.response) {
+                console.error('   Response status:', error.response.status);
+                console.error('   Response data:', JSON.stringify(error.response.data, null, 2));
+            }
+            process.exit(1);
+        }
+    });
+}
+// Handle errors gracefully
+process.on('unhandledRejection', (error) => {
+    console.error('\n❌ Unhandled error:', error.message);
+    process.exit(1);
+});
+// Run the demo
+runDemo();

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ApiClient';
+export * from './types/ApiTypes';
+export * from './utils/errorHandler';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApiClient"), exports);
+__exportStar(require("./types/ApiTypes"), exports);
+__exportStar(require("./utils/errorHandler"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,mDAAiC;AACjC,uDAAqC"}

package/dist/src/ApiClient.js

@@ -0,0 +1,108 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * ApiClient is a wrapper around Axios to interact with the Algebrakit Webservice API.
+ */
+class ApiClient {
+    /**
+     * Initialize the API client with a base URL and API key.
+     * @param baseUrl The base URL of the Algebrakit Webservice API.
+     * @param apiKey The API key for authentication.
+     */
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.axiosInstance = axios_1.default.create({
+            baseURL: baseUrl,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey
+            },
+        });
+    }
+    /**
+     * Create new exercise sessions.
+     * @param request The request payload for creating sessions.
+     * @returns The response containing session creation results.
+     */
+    createSession(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/session/create', request).then(r => r.data);
+        });
+    }
+    /**
+     * Retrieve results from exercise sessions.
+     * @param request The request payload for retrieving session scores.
+     * @returns The response containing session scores.
+     */
+    getSessionScore(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/session/score', request).then(r => r.data);
+        });
+    }
+    /**
+     * Lock or unlock exercise sessions.
+     * @param request The request payload for locking/unlocking sessions.
+     * @returns The response confirming the action.
+     */
+    lockSession(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/sessions/lock', request).then(r => r.data);
+        });
+    }
+    /**
+     * Retrieve detailed information about a session.
+     * @param request The request payload for retrieving session information.
+     * @returns The response containing session details.
+     */
+    getSessionInfo(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/session/info', request).then(r => r.data);
+        });
+    }
+    /**
+     * Retrieve existing sessions by their IDs.
+     * @param request The request payload containing session IDs.
+     * @returns The response containing session data for each ID.
+     */
+    retrieveSession(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/session/retrieve', request).then(r => r.data);
+        });
+    }
+    /**
+     * Validate an exercise definition or ID.
+     * @param request The request payload for exercise validation.
+     * @returns The response containing validation results and details.
+     */
+    validateExercise(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/exercise/validate', request).then(r => r.data);
+        });
+    }
+    /**
+     * Retrieve published information about an exercise (structure, versions, history).
+     * @param request The request payload containing the exercise ID.
+     * @returns The response containing published info about the exercise.
+     */
+    getExercisePublishedInfo(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.axiosInstance.post('/exercise/published-info', request).then(r => r.data);
+        });
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApiClient"), exports);
+__exportStar(require("./types/ApiTypes"), exports);

package/dist/src/types/ApiTypes.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Types for the Algebrakit Webservice API.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./request/RequestTypes"), exports);
+__exportStar(require("./response/ResponseTypes"), exports);
+__exportStar(require("./shared/SharedTypes"), exports);
+__exportStar(require("./exercise/AK_ExerciseTypes"), exports);

package/dist/src/types/exercise/AK_ExerciseTypes.js

@@ -0,0 +1,5 @@
+"use strict";
+// AK_Exercise types for the Algebrakit Webservice API
+// These define the human-friendly exercise specification format accepted by
+// the session/create and exercise/validate endpoints.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/request/RequestTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+// Request types for the Algebrakit Webservice API
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/response/ResponseTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/shared/SharedTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+// Shared types for the Algebrakit Webservice API
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/errorHandler.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiError = handleApiError;
+/**
+ * Handles errors from Axios requests and provides a standardized error message.
+ * @param error The Axios error object.
+ * @returns A standardized error message.
+ */
+function handleApiError(error) {
+    if (error.response) {
+        // Server responded with a status code outside the 2xx range
+        return `API Error: ${error.response.status} - ${error.response.data}`;
+    }
+    else if (error.request) {
+        // Request was made but no response was received
+        return 'API Error: No response received from the server.';
+    }
+    else {
+        // Something happened in setting up the request
+        return `API Error: ${error.message}`;
+    }
+}

package/dist/types/ApiTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Types for the Algebrakit Webservice API.
+ */
+export * from './request/RequestTypes';
+export * from './response/ResponseTypes';
+export * from './shared/SharedTypes';
+export * from './exercise/AK_ExerciseTypes';
+//# sourceMappingURL=ApiTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ApiTypes.d.ts","sourceRoot":"","sources":["../../src/types/ApiTypes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC"}

package/dist/types/ApiTypes.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Types for the Algebrakit Webservice API.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./request/RequestTypes"), exports);
+__exportStar(require("./response/ResponseTypes"), exports);
+__exportStar(require("./shared/SharedTypes"), exports);
+__exportStar(require("./exercise/AK_ExerciseTypes"), exports);
+//# sourceMappingURL=ApiTypes.js.map

package/dist/types/ApiTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiTypes.js","sourceRoot":"","sources":["../../src/types/ApiTypes.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;;;;;;;;;;;;;AAEH,yDAAuC;AACvC,2DAAyC;AACzC,uDAAqC;AACrC,8DAA4C"}