@crimson-education/sdk 0.3.10 → 0.3.12

package/dist/core/client.d.ts

@@ -1,6 +1,7 @@
 import type { CrimsonClientConfig } from "./types";
 import { MissionsApi } from "./missions";
 import { TasksApi } from "./tasks";
+import { ReflectionsApi } from "./reflections";
 import { RoadmapApi } from "./roadmap";
 import { MissionLibraryApi } from "./missionLibrary";
 import { UsersApi } from "./users";
@@ -105,6 +106,7 @@ export declare class CrimsonClient {
     destroy(): void;
     missions: MissionsApi;
     tasks: TasksApi;
+    reflections: ReflectionsApi;
     roadmap: RoadmapApi;
     library: MissionLibraryApi;
     users: UsersApi;

package/dist/core/client.js

@@ -13,6 +13,7 @@ exports.CrimsonClient = void 0;
 exports.createCrimsonClient = createCrimsonClient;
 const missions_1 = require("./missions");
 const tasks_1 = require("./tasks");
+const reflections_1 = require("./reflections");
 const roadmap_1 = require("./roadmap");
 const missionLibrary_1 = require("./missionLibrary");
 const users_1 = require("./users");
@@ -48,6 +49,7 @@ class CrimsonClient {
         this.isResolvingDomain = false;
         this.missions = new missions_1.MissionsApi(this);
         this.tasks = new tasks_1.TasksApi(this);
+        this.reflections = new reflections_1.ReflectionsApi(this);
         this.roadmap = new roadmap_1.RoadmapApi(this);
         this.library = new missionLibrary_1.MissionLibraryApi(this);
         this.users = new users_1.UsersApi(this);

package/dist/core/gradeTemplates.d.ts

@@ -1,14 +1,18 @@
 import type { CrimsonClient } from "./client";
+export type GradeTemplateType = "grade" | "general";
+export type GradeTemplateGroup = "shared" | "custom";
+export type GradeTemplateDivision = "US" | "UK";
 export interface GradeTemplateMission {
     id: string;
     gradeTemplateId: string;
     templateMissionId: string;
     startYearOffset?: number;
-    startMonth: number;
+    startMonth?: number | null;
     startDay?: number;
     endYearOffset?: number;
-    endMonth: number;
+    endMonth?: number | null;
     endDay?: number;
+    orderIndex?: number;
     createdAt: string;
     updatedAt: string;
     title?: string;
@@ -33,23 +37,30 @@ export interface GradeTemplateTask {
 }
 export interface CreateGradeTemplateMissionInput {
     templateMissionId: string;
+    tenantId?: string;
     startYearOffset?: number;
-    startMonth: number;
+    startMonth?: number | null;
     startDay?: number;
     endYearOffset?: number;
-    endMonth: number;
+    endMonth?: number | null;
     endDay?: number;
+    orderIndex?: number;
 }
 export interface GradeTemplateBrief {
     id: string;
     title: string;
-    gradeLevel: number;
+    type?: GradeTemplateType;
+    division?: GradeTemplateDivision[] | null;
+    creatorId?: string;
+    group?: GradeTemplateGroup;
+    gradeLevel?: number | null;
     startYearOffset?: number;
-    startMonth: number;
+    startMonth?: number | null;
     startDay?: number;
     endYearOffset?: number;
-    endMonth: number;
+    endMonth?: number | null;
     endDay?: number;
+    numMissions?: number;
 }
 export interface GradeTemplate extends GradeTemplateBrief {
     missions: GradeTemplateMission[];
@@ -58,18 +69,27 @@ export interface GradeTemplate extends GradeTemplateBrief {
 }
 export interface CreateGradeTemplateInput {
     title: string;
-    gradeLevel: number;
+    tenantId?: string;
+    type?: GradeTemplateType;
+    division?: GradeTemplateDivision[] | null;
+    creatorId?: string;
+    group?: GradeTemplateGroup;
+    gradeLevel?: number | null;
     startYearOffset?: number;
-    startMonth: number;
+    startMonth?: number | null;
     startDay?: number;
     endYearOffset?: number;
-    endMonth: number;
+    endMonth?: number | null;
     endDay?: number;
 }
 export interface GradeTemplateFilters {
     ids?: string[];
     startGrade?: number;
     endGrade?: number;
+    groups?: GradeTemplateGroup[];
+    type?: GradeTemplateType;
+    division?: GradeTemplateDivision[];
+    numMissions?: boolean;
 }
 export interface AddGradeTemplateToRoadmapInput {
     studentId: string;
@@ -81,13 +101,21 @@ export interface AddGradeTemplateToRoadmapInput {
         endDate?: string;
     }[];
 }
+export interface AddGradeTemplateToRoadmapMissionResponse {
+    id: string;
+    isNew: boolean;
+    taskIds: string[];
+}
+export interface AddGradeTemplateToRoadmapResponse {
+    missions: AddGradeTemplateToRoadmapMissionResponse[];
+}
 export declare class GradeTemplatesApi {
     private client;
     constructor(client: CrimsonClient);
     /**
      * List grade templates
      */
-    listGradeTemplates(filters?: GradeTemplateFilters): Promise<GradeTemplate[]>;
+    listGradeTemplates(filters?: GradeTemplateFilters): Promise<GradeTemplateBrief[]>;
     /**
      * Get grade template by ID
      */
@@ -111,7 +139,5 @@ export declare class GradeTemplatesApi {
     /**
      * Add grade template to roadmap
      */
-    addGradeTemplateToRoadmap(id: string, input: AddGradeTemplateToRoadmapInput): Promise<{
-        success: boolean;
-    }>;
+    addGradeTemplateToRoadmap(id: string, input: AddGradeTemplateToRoadmapInput): Promise<AddGradeTemplateToRoadmapResponse>;
 }

package/dist/core/gradeTemplates.js

@@ -19,6 +19,7 @@ class GradeTemplatesApi {
      */
     listGradeTemplates(filters) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const params = new URLSearchParams();
             if ((filters === null || filters === void 0 ? void 0 : filters.startGrade) !== undefined) {
                 params.append("startgrade", String(filters.startGrade));
@@ -26,6 +27,18 @@ class GradeTemplatesApi {
             if ((filters === null || filters === void 0 ? void 0 : filters.endGrade) !== undefined) {
                 params.append("endgrade", String(filters.endGrade));
             }
+            if ((_a = filters === null || filters === void 0 ? void 0 : filters.groups) === null || _a === void 0 ? void 0 : _a.length) {
+                params.append("groups", filters.groups.join(","));
+            }
+            if (filters === null || filters === void 0 ? void 0 : filters.type) {
+                params.append("type", filters.type);
+            }
+            if ((_b = filters === null || filters === void 0 ? void 0 : filters.division) === null || _b === void 0 ? void 0 : _b.length) {
+                params.append("division", filters.division.join(","));
+            }
+            if ((filters === null || filters === void 0 ? void 0 : filters.numMissions) !== undefined) {
+                params.append("numMissions", String(filters.numMissions));
+            }
             const query = params.toString();
             const path = query
                 ? `/roadmap/grade-templates?${query}`

package/dist/core/index.d.ts

@@ -1,6 +1,7 @@
 export { CrimsonClient, createCrimsonClient } from "./client";
 export { MissionsApi } from "./missions";
 export { TasksApi, type TaskFilters, type TaskOrderBy } from "./tasks";
+export { ReflectionsApi, type CreateReflectionInput, type UpdateReflectionInput, type BatchUpdateReflectionsInput, type ListReflectionsResponse, type GroupedMission, type ReflectionComment, type AddReflectionCommentInput } from "./reflections";
 export { RoadmapApi } from "./roadmap";
 export { MissionLibraryApi } from "./missionLibrary";
 export { UsersApi } from "./users";

package/dist/core/index.js

@@ -14,7 +14,7 @@ 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 });
-exports.generateState = exports.generateCodeChallenge = exports.generateCodeVerifier = exports.createDefaultTokenStorage = exports.MemoryTokenStorage = exports.SessionStorageTokenStorage = exports.LocalStorageTokenStorage = exports.TokenManager = exports.createCrimsonOAuthAdapter = exports.OAuthAdapter = exports.IndigoApi = exports.StudentProfileApi = exports.AccountApi = exports.UsersApi = exports.MissionLibraryApi = exports.RoadmapApi = exports.TasksApi = exports.MissionsApi = exports.createCrimsonClient = exports.CrimsonClient = void 0;
+exports.generateState = exports.generateCodeChallenge = exports.generateCodeVerifier = exports.createDefaultTokenStorage = exports.MemoryTokenStorage = exports.SessionStorageTokenStorage = exports.LocalStorageTokenStorage = exports.TokenManager = exports.createCrimsonOAuthAdapter = exports.OAuthAdapter = exports.IndigoApi = exports.StudentProfileApi = exports.AccountApi = exports.UsersApi = exports.MissionLibraryApi = exports.RoadmapApi = exports.ReflectionsApi = exports.TasksApi = exports.MissionsApi = exports.createCrimsonClient = exports.CrimsonClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "CrimsonClient", { enumerable: true, get: function () { return client_1.CrimsonClient; } });
 Object.defineProperty(exports, "createCrimsonClient", { enumerable: true, get: function () { return client_1.createCrimsonClient; } });
@@ -22,6 +22,8 @@ var missions_1 = require("./missions");
 Object.defineProperty(exports, "MissionsApi", { enumerable: true, get: function () { return missions_1.MissionsApi; } });
 var tasks_1 = require("./tasks");
 Object.defineProperty(exports, "TasksApi", { enumerable: true, get: function () { return tasks_1.TasksApi; } });
+var reflections_1 = require("./reflections");
+Object.defineProperty(exports, "ReflectionsApi", { enumerable: true, get: function () { return reflections_1.ReflectionsApi; } });
 var roadmap_1 = require("./roadmap");
 Object.defineProperty(exports, "RoadmapApi", { enumerable: true, get: function () { return roadmap_1.RoadmapApi; } });
 var missionLibrary_1 = require("./missionLibrary");

package/dist/core/missionLibrary.d.ts

@@ -6,6 +6,8 @@ export interface TemplateMissionFilters extends PaginationParams {
     groups?: string[];
     keyword?: string;
     userId?: string;
+    division?: string;
+    attr?: Record<string, any>;
 }
 export interface TemplateTaskFilters extends PaginationParams {
     categories?: string[];
@@ -20,11 +22,15 @@ export interface TemplateTaskUpdateInput {
     title?: string;
     description?: string;
     operation: string;
+    visibleSc?: boolean;
+    visibleRoadmap?: boolean;
 }
 export interface TemplateMissionUpdateInput {
     title?: string;
     description?: string;
     tasks?: TemplateTaskUpdateInput[];
+    visibleSc?: boolean;
+    visibleRoadmap?: boolean;
 }
 export interface CopyTemplateMissionInput {
     linkId: string;
@@ -44,10 +50,14 @@ export interface TemplateMissionCreateInput {
     description: string;
     category: string;
     subcategory: string;
+    visibleSc?: boolean;
+    visibleRoadmap?: boolean;
     tasks: {
         id?: string | null;
         description: string;
         content: string;
+        visibleSc?: boolean;
+        visibleRoadmap?: boolean;
     }[];
 }
 export interface AddTemplateMissionToRoadmapInput {
@@ -59,6 +69,11 @@ export interface AddTemplateMissionToRoadmapInput {
     taskIds?: string[];
     ignoreLink?: boolean;
 }
+export interface AddTemplateMissionToRoadmapResponse {
+    missionId: string;
+    isNew: boolean;
+    taskIds: string[];
+}
 export declare class MissionLibraryApi {
     private client;
     constructor(client: CrimsonClient);
@@ -102,11 +117,7 @@ export declare class MissionLibraryApi {
     /**
      * Add a template mission to a user's roadmap (create or update)
      */
-    addToRoadmap(input: AddTemplateMissionToRoadmapInput): Promise<{
-        missionId: string;
-        isNew: boolean;
-        updated: boolean;
-    }>;
+    addToRoadmap(input: AddTemplateMissionToRoadmapInput): Promise<AddTemplateMissionToRoadmapResponse>;
     /**
      * Bulk assign missions from templates
      */

package/dist/core/missionLibrary.js

@@ -36,6 +36,12 @@ class MissionLibraryApi {
             if (filters === null || filters === void 0 ? void 0 : filters.userId) {
                 params.append("userId", filters.userId);
             }
+            if (filters === null || filters === void 0 ? void 0 : filters.division) {
+                params.append("division", filters.division);
+            }
+            if (filters === null || filters === void 0 ? void 0 : filters.attr) {
+                params.append("attr", JSON.stringify(filters.attr));
+            }
             if ((filters === null || filters === void 0 ? void 0 : filters.start) !== undefined) {
                 params.append("start", String(filters.start));
             }
@@ -167,11 +173,13 @@ class MissionLibraryApi {
      */
     updateTemplateMission(id, raw, update) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const data = {
                 title: (_a = update.title) !== null && _a !== void 0 ? _a : raw.title,
                 description: (_b = update.description) !== null && _b !== void 0 ? _b : raw.description,
                 tasks: update.tasks || [],
+                visibleSc: (_c = update.visibleSc) !== null && _c !== void 0 ? _c : raw.visibleSc,
+                visibleRoadmap: (_d = update.visibleRoadmap) !== null && _d !== void 0 ? _d : raw.visibleRoadmap,
                 // only allow updatecustom
                 type: 'custom',
                 category: raw.category,

package/dist/core/reflections.d.ts

@@ -0,0 +1,111 @@
+import type { CrimsonClient } from "./client";
+import type { Task } from "./types";
+export interface ReflectionComment {
+    id: string;
+    category?: string;
+    content?: string;
+    creatorUid?: string;
+    creatorName?: string;
+    updatedAt?: string;
+    createdAt?: string;
+}
+export interface AddReflectionCommentInput {
+    content: string;
+    category?: string;
+}
+export interface CreateReflectionInput {
+    missionId: string;
+    description?: string;
+    startAt?: string;
+    dueDate?: string;
+    status?: string;
+}
+export interface UpdateReflectionInput {
+    missionId: string;
+    description?: string;
+    startAt?: string;
+    dueDate?: string;
+    status?: string;
+}
+export interface BatchUpdateReflectionsInput {
+    missionId: string;
+    status?: string;
+    startAt?: string;
+    dueDate?: string;
+}
+export interface GroupedMission {
+    mission: Task["mission"];
+    reflections: Task[];
+    latestReflectionAt: string;
+}
+export interface ListReflectionsResponse {
+    data: GroupedMission[];
+    pagination: {
+        total: number;
+        start: number;
+        limit: number;
+        hasMore: boolean;
+    };
+}
+export declare class ReflectionsApi {
+    private client;
+    constructor(client: CrimsonClient);
+    /**
+     * Get all reflections of a student, grouped by mission
+     */
+    list(params: {
+        studentId: string;
+        roadmapId?: string;
+        status?: string[];
+        description?: string;
+        /** how many missions to return */
+        limit?: number;
+        start?: number;
+        /** limit number of reflections returned per mission; default 1 */
+        perMissionLimit?: number;
+    }): Promise<ListReflectionsResponse>;
+    /**
+     * Get all reflections by mission ID
+     */
+    getByMission(missionId: string): Promise<Task[]>;
+    /**
+     * Create a new reflection for a mission
+     */
+    create(missionId: string, data: Omit<CreateReflectionInput, "missionId">): Promise<Task>;
+    /**
+     * Update an existing reflection by ID
+     */
+    update(id: string, data: UpdateReflectionInput): Promise<Task>;
+    /**
+     * Batch update all reflections belonging to a mission
+     */
+    batchUpdateByMission(missionId: string, data: Omit<BatchUpdateReflectionsInput, "missionId">): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Delete a reflection by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get all comments for a reflection
+     */
+    getComments(reflectionId: string): Promise<ReflectionComment[]>;
+    /**
+     * Add a comment to a reflection
+     */
+    addComment(reflectionId: string, data: AddReflectionCommentInput): Promise<ReflectionComment>;
+    /**
+     * Update a reflection comment by comment ID
+     */
+    updateComment(commentId: string, content: string): Promise<ReflectionComment>;
+    /**
+     * Delete a single reflection comment by comment ID
+     */
+    deleteComment(commentId: string): Promise<void>;
+    /**
+     * Batch delete all comments for a reflection
+     */
+    deleteAllComments(reflectionId: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/core/reflections.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectionsApi = void 0;
+class ReflectionsApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get all reflections of a student, grouped by mission
+     */
+    list(params) {
+        const query = new URLSearchParams();
+        if (params.studentId)
+            query.append("studentId", params.studentId);
+        if (params.roadmapId)
+            query.append("roadmapId", params.roadmapId);
+        if (params.status)
+            params.status.forEach((s) => query.append("status", s));
+        if (params.description)
+            query.append("description", params.description);
+        if (params.limit !== undefined)
+            query.append("limit", params.limit.toString());
+        if (params.start !== undefined)
+            query.append("start", params.start.toString());
+        if (params.perMissionLimit !== undefined)
+            query.append("perMissionLimit", params.perMissionLimit.toString());
+        return this.client.fetch(`/roadmap/reflections?${query.toString()}`);
+    }
+    /**
+     * Get all reflections by mission ID
+     */
+    getByMission(missionId) {
+        return this.client.fetch(`/roadmap/missions/${missionId}/reflections`);
+    }
+    /**
+     * Create a new reflection for a mission
+     */
+    create(missionId, data) {
+        return this.client.fetch(`/roadmap/missions/${missionId}/reflections`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    /**
+     * Update an existing reflection by ID
+     */
+    update(id, data) {
+        return this.client.fetch(`/roadmap/reflections/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(data),
+        });
+    }
+    /**
+     * Batch update all reflections belonging to a mission
+     */
+    batchUpdateByMission(missionId, data) {
+        return this.client.fetch(`/roadmap/missions/${missionId}/reflections/batch`, {
+            method: "PUT",
+            body: JSON.stringify(data),
+        });
+    }
+    /**
+     * Delete a reflection by ID
+     */
+    delete(id) {
+        return this.client.fetch(`/roadmap/reflections/${id}`, {
+            method: "DELETE",
+        });
+    }
+    /**
+     * Get all comments for a reflection
+     */
+    getComments(reflectionId) {
+        return this.client.fetch(`/roadmap/reflections/${reflectionId}/comments`);
+    }
+    /**
+     * Add a comment to a reflection
+     */
+    addComment(reflectionId, data) {
+        return this.client.fetch(`/roadmap/reflections/${reflectionId}/comments`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    /**
+     * Update a reflection comment by comment ID
+     */
+    updateComment(commentId, content) {
+        return this.client.fetch(`/roadmap/reflections/comments/${commentId}`, {
+            method: "PUT",
+            body: JSON.stringify({ content }),
+        });
+    }
+    /**
+     * Delete a single reflection comment by comment ID
+     */
+    deleteComment(commentId) {
+        return this.client.fetch(`/roadmap/reflections/comments/${commentId}`, {
+            method: "DELETE",
+        });
+    }
+    /**
+     * Batch delete all comments for a reflection
+     */
+    deleteAllComments(reflectionId) {
+        return this.client.fetch(`/roadmap/reflections/${reflectionId}/comments`, {
+            method: "DELETE",
+        });
+    }
+}
+exports.ReflectionsApi = ReflectionsApi;

package/dist/core/tasks.d.ts

@@ -39,7 +39,7 @@ export declare class TasksApi {
         missionLinkIds?: string[];
         roadmapId?: string;
         userId?: string;
-    }, filters?: TaskFilters): Promise<PaginatedResult<Task>> | Promise<Task[]>;
+    }, filters?: TaskFilters): Promise<Task[]> | Promise<PaginatedResult<Task>>;
     /**
      * List tasks with pagination (requires roadmapId, always returns paginated result)
      */

package/dist/core/types.d.ts

@@ -1,4 +1,5 @@
 import type { OAuthConfig, TokenStorage } from "./auth/types";
+import type { ReflectionComment } from "./reflections";
 /**
  * OAuth-specific configuration for CrimsonClient
  */
@@ -108,9 +109,15 @@ export interface Task {
     mission?: {
         id: string;
         title: string;
+        status?: string;
         linkId?: string;
     };
     createdAt?: string;
+    /** comment summary attached to reflection-type tasks */
+    comments?: {
+        total: number;
+        latest?: ReflectionComment;
+    };
 }
 export interface Mission {
     id: string;
@@ -213,6 +220,8 @@ export interface TemplateMission {
     actionItemCount?: number;
     actionItems?: TemplateTask[];
     resources?: TemplateMissionResource[];
+    visibleSc?: boolean;
+    visibleRoadmap?: boolean;
     createdAt?: string;
     updatedAt?: string;
 }
@@ -236,6 +245,8 @@ export interface MissionDetail {
     members?: string[];
     integrationSource?: string;
     attr?: string;
+    visibleSc?: boolean;
+    visibleRoadmap?: boolean;
     actionItems?: Array<{
         id: string;
         description: string;
@@ -249,6 +260,8 @@ export interface MissionDetail {
         taskGroup?: string;
         attr?: string;
         resources?: TemplateTaskResource[];
+        visibleSc?: boolean;
+        visibleRoadmap?: boolean;
     }>;
     resources?: TemplateMissionResource[];
 }

package/dist/react/hooks/index.d.ts

@@ -11,3 +11,4 @@ export { useTemplateMissions, useTemplateMissionsInfinite, useTemplateTasks, use
 export { useStudentProfile, useStudentPrefilledInfo, studentProfileKeys, } from "./useStudentProfile";
 export { useIndigoMe, useStudentTutors, useTutorStudents, indigoKeys, } from "./useIndigo";
 export * from "./useGradeTemplates";
+export * from "./useReflections";

package/dist/react/hooks/index.js

@@ -82,3 +82,4 @@ Object.defineProperty(exports, "useStudentTutors", { enumerable: true, get: func
 Object.defineProperty(exports, "useTutorStudents", { enumerable: true, get: function () { return useIndigo_1.useTutorStudents; } });
 Object.defineProperty(exports, "indigoKeys", { enumerable: true, get: function () { return useIndigo_1.indigoKeys; } });
 __exportStar(require("./useGradeTemplates"), exports);
+__exportStar(require("./useReflections"), exports);

package/dist/react/hooks/useGradeTemplates.d.ts

@@ -1,10 +1,11 @@
 import type { GradeTemplateFilters, CreateGradeTemplateInput, CreateGradeTemplateMissionInput, AddGradeTemplateToRoadmapInput } from "../../core/gradeTemplates";
+export type { GradeTemplateFilters } from "../../core/gradeTemplates";
 export declare const gradeTemplateKeys: {
     all: readonly ["gradeTemplates"];
     list: (filters?: GradeTemplateFilters) => readonly ["gradeTemplates", "list", GradeTemplateFilters | undefined];
     detail: (id: string) => readonly ["gradeTemplates", "detail", string];
 };
-export declare function useGradeTemplates(filters?: GradeTemplateFilters, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("../../core/gradeTemplates").GradeTemplate[], Error>;
+export declare function useGradeTemplates(filters?: GradeTemplateFilters, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("../../core/gradeTemplates").GradeTemplateBrief[], Error>;
 export declare function useGradeTemplate(id: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("../../core/gradeTemplates").GradeTemplate, Error>;
 export declare function useCreateGradeTemplate(): import("@tanstack/react-query").UseMutationResult<import("../../core/gradeTemplates").GradeTemplate, Error, CreateGradeTemplateInput, unknown>;
 export declare function useDeleteGradeTemplate(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
@@ -16,9 +17,7 @@ export declare function useRemoveMissionFromGradeTemplate(): import("@tanstack/r
     gradeTemplateId: string;
     missionId: string;
 }, unknown>;
-export declare function useAddGradeTemplateToRoadmap(): import("@tanstack/react-query").UseMutationResult<{
-    success: boolean;
-}, Error, {
+export declare function useAddGradeTemplateToRoadmap(): import("@tanstack/react-query").UseMutationResult<import("../../core/gradeTemplates").AddGradeTemplateToRoadmapResponse, Error, {
     id: string;
     input: AddGradeTemplateToRoadmapInput;
 }, unknown>;

package/dist/react/hooks/useGradeTemplates.js

@@ -43,7 +43,7 @@ function useCreateGradeTemplate() {
         mutationFn: (input) => client.gradeTemplates.createGradeTemplate(input),
         onSuccess: () => {
             queryClient.invalidateQueries({
-                queryKey: exports.gradeTemplateKeys.list(),
+                queryKey: exports.gradeTemplateKeys.all,
             });
         },
     });
@@ -55,7 +55,7 @@ function useDeleteGradeTemplate() {
         mutationFn: (id) => client.gradeTemplates.deleteGradeTemplate(id),
         onSuccess: () => {
             queryClient.invalidateQueries({
-                queryKey: exports.gradeTemplateKeys.list(),
+                queryKey: exports.gradeTemplateKeys.all,
             });
         },
     });

package/dist/react/hooks/useMissionLibrary.d.ts

@@ -3,9 +3,9 @@ import type { TemplateMissionFilters, TemplateTaskFilters, CopyTemplateMissionIn
 export declare const missionLibraryKeys: {
     all: readonly ["missionLibrary"];
     missions: (filters?: TemplateMissionFilters) => readonly ["missionLibrary", "missions", TemplateMissionFilters | undefined];
-    missionsInfinite: (filters?: Omit<TemplateMissionFilters, "start" | "limit">) => readonly ["missionLibrary", "missions", "infinite", Omit<TemplateMissionFilters, "start" | "limit"> | undefined];
+    missionsInfinite: (filters?: Omit<TemplateMissionFilters, "start" | "limit">) => readonly ["missionLibrary", "missions", "infinite", Omit<TemplateMissionFilters, "limit" | "start"> | undefined];
     tasks: (filters?: TemplateTaskFilters) => readonly ["missionLibrary", "tasks", TemplateTaskFilters | undefined];
-    tasksInfinite: (filters?: Omit<TemplateTaskFilters, "start" | "limit">) => readonly ["missionLibrary", "tasks", "infinite", Omit<TemplateTaskFilters, "start" | "limit"> | undefined];
+    tasksInfinite: (filters?: Omit<TemplateTaskFilters, "start" | "limit">) => readonly ["missionLibrary", "tasks", "infinite", Omit<TemplateTaskFilters, "limit" | "start"> | undefined];
     missionDetail: (id: string) => readonly ["missionLibrary", "mission", string];
 };
 export declare function useTemplateMissions(filters?: TemplateMissionFilters, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("../../core/types").PaginatedResult<TemplateMission>, Error>;
@@ -43,8 +43,4 @@ export declare function useAssignBulkTask(): import("@tanstack/react-query").Use
     msg?: string;
 }, Error, AssignBulkTaskInput[], unknown>;
 export declare function useCreateFromPredefinedTasks(): import("@tanstack/react-query").UseMutationResult<TemplateTask[], Error, CreateFromPredefinedInput, unknown>;
-export declare function useTemplateMissionAddToRoadmap(): import("@tanstack/react-query").UseMutationResult<{
-    missionId: string;
-    isNew: boolean;
-    updated: boolean;
-}, Error, import("../../core/missionLibrary").AddTemplateMissionToRoadmapInput, unknown>;
+export declare function useTemplateMissionAddToRoadmap(): import("@tanstack/react-query").UseMutationResult<import("../../core/missionLibrary").AddTemplateMissionToRoadmapResponse, Error, import("../../core/missionLibrary").AddTemplateMissionToRoadmapInput, unknown>;

package/dist/react/hooks/useMissions.d.ts

@@ -5,7 +5,7 @@ export declare const missionKeys: {
     all: readonly ["missions"];
     lists: () => readonly ["missions", "list"];
     list: (userId: string) => readonly ["missions", "list", string];
-    infinite: (userId: string, filters?: Omit<MissionFilters, "start" | "limit">) => readonly ["missions", "infinite", string, Omit<MissionFilters, "start" | "limit"> | undefined];
+    infinite: (userId: string, filters?: Omit<MissionFilters, "start" | "limit">) => readonly ["missions", "infinite", string, Omit<MissionFilters, "limit" | "start"> | undefined];
     details: () => readonly ["missions", "detail"];
     detail: (id: string) => readonly ["missions", "detail", string];
 };

package/dist/react/hooks/useReflections.d.ts

@@ -0,0 +1,101 @@
+import { type UseQueryOptions, type UseMutationOptions } from "@tanstack/react-query";
+import type { Task } from "../../core/types";
+import type { CreateReflectionInput, UpdateReflectionInput, BatchUpdateReflectionsInput, ListReflectionsResponse, ReflectionComment, AddReflectionCommentInput } from "../../core/reflections";
+export declare const REFLECTION_KEYS: {
+    all: readonly ["reflections"];
+    list: (params: {
+        studentId: string;
+        roadmapId?: string;
+        status?: string[];
+        description?: string;
+        limit?: number;
+        start?: number;
+        perMissionLimit?: number;
+    }) => readonly ["reflections", "list", {
+        studentId: string;
+        roadmapId?: string;
+        status?: string[];
+        description?: string;
+        limit?: number;
+        start?: number;
+        perMissionLimit?: number;
+    }];
+    byMission: (missionId: string) => readonly ["reflections", "mission", string];
+    comments: (reflectionId: string) => readonly ["reflections", "comments", string];
+};
+export declare function useAllReflections(params: {
+    studentId: string;
+    roadmapId?: string;
+    status?: string[];
+    description?: string;
+    limit?: number;
+    start?: number;
+    perMissionLimit?: number;
+}, options?: Omit<UseQueryOptions<ListReflectionsResponse, Error, ListReflectionsResponse, readonly any[]>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<ListReflectionsResponse, Error>;
+export declare function useReflections(missionId: string, options?: Omit<UseQueryOptions<Task[], Error, Task[], readonly string[]>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<Task[], Error>;
+export declare function useCreateReflection(options?: Omit<UseMutationOptions<Task, Error, CreateReflectionInput>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<Task, Error, CreateReflectionInput, unknown>;
+export declare function useUpdateReflection(options?: Omit<UseMutationOptions<Task, Error, {
+    id: string;
+    missionId: string;
+} & UpdateReflectionInput>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<Task, Error, {
+    id: string;
+    missionId: string;
+} & UpdateReflectionInput, any>;
+export declare function useBatchUpdateReflections(options?: Omit<UseMutationOptions<{
+    success: boolean;
+}, Error, BatchUpdateReflectionsInput>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+}, Error, BatchUpdateReflectionsInput, unknown>;
+export declare function useDeleteReflection(options?: Omit<UseMutationOptions<void, Error, {
+    id: string;
+    missionId: string;
+}>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    id: string;
+    missionId: string;
+}, unknown>;
+/**
+ * Fetch all comments for a reflection (action item)
+ */
+export declare function useReflectionComments(reflectionId: string, options?: Omit<UseQueryOptions<ReflectionComment[], Error, ReflectionComment[], readonly string[]>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<ReflectionComment[], Error>;
+/**
+ * Add a comment to a reflection
+ */
+export declare function useAddReflectionComment(options?: Omit<UseMutationOptions<ReflectionComment, Error, {
+    reflectionId: string;
+} & AddReflectionCommentInput>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<ReflectionComment, Error, {
+    reflectionId: string;
+} & AddReflectionCommentInput, any>;
+/**
+ * Update a reflection comment
+ */
+export declare function useUpdateReflectionComment(options?: Omit<UseMutationOptions<ReflectionComment, Error, {
+    commentId: string;
+    reflectionId: string;
+    content: string;
+}>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<ReflectionComment, Error, {
+    commentId: string;
+    reflectionId: string;
+    content: string;
+}, unknown>;
+/**
+ * Delete a single reflection comment
+ */
+export declare function useDeleteReflectionComment(options?: Omit<UseMutationOptions<void, Error, {
+    commentId: string;
+    reflectionId: string;
+}>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    commentId: string;
+    reflectionId: string;
+}, unknown>;
+/**
+ * Batch delete all comments for a reflection
+ */
+export declare function useDeleteAllReflectionComments(options?: Omit<UseMutationOptions<{
+    success: boolean;
+}, Error, {
+    reflectionId: string;
+}>, "mutationFn">): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+}, Error, {
+    reflectionId: string;
+}, unknown>;

package/dist/react/hooks/useReflections.js

@@ -0,0 +1,278 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFLECTION_KEYS = void 0;
+exports.useAllReflections = useAllReflections;
+exports.useReflections = useReflections;
+exports.useCreateReflection = useCreateReflection;
+exports.useUpdateReflection = useUpdateReflection;
+exports.useBatchUpdateReflections = useBatchUpdateReflections;
+exports.useDeleteReflection = useDeleteReflection;
+exports.useReflectionComments = useReflectionComments;
+exports.useAddReflectionComment = useAddReflectionComment;
+exports.useUpdateReflectionComment = useUpdateReflectionComment;
+exports.useDeleteReflectionComment = useDeleteReflectionComment;
+exports.useDeleteAllReflectionComments = useDeleteAllReflectionComments;
+const react_query_1 = require("@tanstack/react-query");
+const provider_1 = require("../provider");
+exports.REFLECTION_KEYS = {
+    all: ["reflections"],
+    list: (params) => [...exports.REFLECTION_KEYS.all, "list", params],
+    byMission: (missionId) => [...exports.REFLECTION_KEYS.all, "mission", missionId],
+    comments: (reflectionId) => [...exports.REFLECTION_KEYS.all, "comments", reflectionId],
+};
+function useAllReflections(params, options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)(Object.assign({ queryKey: exports.REFLECTION_KEYS.list(params), queryFn: () => client.reflections.list(params), enabled: !!client && !!params.studentId && (options === null || options === void 0 ? void 0 : options.enabled) !== false }, options));
+}
+function useReflections(missionId, options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)(Object.assign({ queryKey: exports.REFLECTION_KEYS.byMission(missionId), queryFn: () => client.reflections.getByMission(missionId), enabled: !!client && !!missionId && (options === null || options === void 0 ? void 0 : options.enabled) !== false }, options));
+}
+function useCreateReflection(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: (data) => {
+            const { missionId } = data, rest = __rest(data, ["missionId"]);
+            return client.reflections.create(missionId, rest);
+        }, onSuccess: (data, variables, context) => {
+            queryClient.invalidateQueries({
+                queryKey: [...exports.REFLECTION_KEYS.all, "list"],
+            });
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.byMission(variables.missionId),
+            });
+            if (options === null || options === void 0 ? void 0 : options.onSuccess) {
+                options.onSuccess(data, variables, context, context);
+            }
+        } }, options));
+}
+function useUpdateReflection(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: (_a) => {
+            var { id } = _a, data = __rest(_a, ["id"]);
+            return client.reflections.update(id, data);
+        }, onMutate: (variables) => __awaiter(this, void 0, void 0, function* () {
+            // Cancel any outgoing refetches (so they don't overwrite our optimistic update)
+            yield queryClient.cancelQueries({ queryKey: exports.REFLECTION_KEYS.all });
+            const previousReflectionsMap = new Map();
+            // Snapshot the previous value
+            queryClient
+                .getQueriesData({ queryKey: exports.REFLECTION_KEYS.all })
+                .forEach(([key, old]) => {
+                previousReflectionsMap.set(JSON.stringify(key), old);
+                if (!old)
+                    return;
+                // Handle ListReflectionsResponse (list)
+                if (typeof old === "object" && "data" in old && Array.isArray(old.data)) {
+                    queryClient.setQueryData(key, (oldData) => {
+                        if (!oldData)
+                            return oldData;
+                        return Object.assign(Object.assign({}, oldData), { data: oldData.data.map((group) => (Object.assign(Object.assign({}, group), { reflections: group.reflections.map((reflection) => reflection.id === variables.id
+                                    ? Object.assign(Object.assign({}, reflection), variables) : reflection) }))) });
+                    });
+                }
+                // Handle Task[] (byMission)
+                else if (Array.isArray(old)) {
+                    queryClient.setQueryData(key, (oldData) => {
+                        return oldData === null || oldData === void 0 ? void 0 : oldData.map((reflection) => reflection.id === variables.id
+                            ? Object.assign(Object.assign({}, reflection), variables) : reflection);
+                    });
+                }
+            });
+            return { previousReflectionsMap };
+        }), onError: (err, variables, context) => {
+            if (context === null || context === void 0 ? void 0 : context.previousReflectionsMap) {
+                context.previousReflectionsMap.forEach((old, keyStr) => {
+                    queryClient.setQueryData(JSON.parse(keyStr), old);
+                });
+            }
+        }, onSettled: (_data, _error, variables) => {
+            queryClient.invalidateQueries({
+                queryKey: [...exports.REFLECTION_KEYS.all, "list"],
+            });
+            if (variables.missionId) {
+                queryClient.invalidateQueries({
+                    queryKey: exports.REFLECTION_KEYS.byMission(variables.missionId),
+                });
+            }
+        } }, options));
+}
+function useBatchUpdateReflections(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: (data) => {
+            const { missionId } = data, rest = __rest(data, ["missionId"]);
+            return client.reflections.batchUpdateByMission(missionId, rest);
+        }, onSuccess: (data, variables, context) => {
+            queryClient.invalidateQueries({
+                queryKey: [...exports.REFLECTION_KEYS.all, "list"],
+            });
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.byMission(variables.missionId),
+            });
+            if (options === null || options === void 0 ? void 0 : options.onSuccess) {
+                options.onSuccess(data, variables, context, context);
+            }
+        } }, options));
+}
+function useDeleteReflection(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: ({ id }) => client.reflections.delete(id), onSuccess: (data, variables, context) => {
+            queryClient.invalidateQueries({
+                queryKey: [...exports.REFLECTION_KEYS.all, "list"],
+            });
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.byMission(variables.missionId),
+            });
+            if (options === null || options === void 0 ? void 0 : options.onSuccess) {
+                options.onSuccess(data, variables, context, context);
+            }
+        } }, options));
+}
+/**
+ * Fetch all comments for a reflection (action item)
+ */
+function useReflectionComments(reflectionId, options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)(Object.assign({ queryKey: exports.REFLECTION_KEYS.comments(reflectionId), queryFn: () => client.reflections.getComments(reflectionId), enabled: !!client && !!reflectionId && (options === null || options === void 0 ? void 0 : options.enabled) !== false }, options));
+}
+/**
+ * Add a comment to a reflection
+ */
+function useAddReflectionComment(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: (_a) => {
+            var { reflectionId } = _a, data = __rest(_a, ["reflectionId"]);
+            return client.reflections.addComment(reflectionId, data);
+        }, onMutate: (variables) => __awaiter(this, void 0, void 0, function* () {
+            // Cancel outgoing refetches
+            yield queryClient.cancelQueries({ queryKey: exports.REFLECTION_KEYS.all });
+            const previousReflectionsMap = new Map();
+            // Snapshot the previous values
+            queryClient
+                .getQueriesData({ queryKey: exports.REFLECTION_KEYS.all })
+                .forEach(([key, old]) => {
+                previousReflectionsMap.set(JSON.stringify(key), old);
+                if (!old)
+                    return;
+                // Handle ReflectionComment[] (comments for specific reflection)
+                if (Array.isArray(old) && key.includes("comments") && key.includes(variables.reflectionId)) {
+                    const optimisticComment = {
+                        id: `temp-${Date.now()}`,
+                        content: variables.content,
+                        createdAt: new Date().toISOString(),
+                        creatorName: "You", // placeholder, will be updated by server
+                    };
+                    queryClient.setQueryData(key, (oldData) => {
+                        return oldData ? [...oldData, optimisticComment] : [optimisticComment];
+                    });
+                }
+                // Handle ListReflectionsResponse (updating latest comment summary in the list)
+                else if (typeof old === "object" && "data" in old && Array.isArray(old.data)) {
+                    queryClient.setQueryData(key, (oldData) => {
+                        if (!oldData)
+                            return oldData;
+                        const optimisticComment = {
+                            id: `temp-${Date.now()}`,
+                            content: variables.content,
+                            createdAt: new Date().toISOString(),
+                            creatorName: "You",
+                        };
+                        return Object.assign(Object.assign({}, oldData), { data: oldData.data.map((group) => (Object.assign(Object.assign({}, group), { reflections: group.reflections.map((reflection) => {
+                                    var _a, _b;
+                                    if (reflection.id === variables.reflectionId) {
+                                        const currentTotal = (_b = (_a = reflection.comments) === null || _a === void 0 ? void 0 : _a.total) !== null && _b !== void 0 ? _b : 0;
+                                        return Object.assign(Object.assign({}, reflection), { comments: {
+                                                total: currentTotal + 1,
+                                                latest: optimisticComment,
+                                            } });
+                                    }
+                                    return reflection;
+                                }) }))) });
+                    });
+                }
+            });
+            return { previousReflectionsMap };
+        }), onError: (err, variables, context) => {
+            if (context === null || context === void 0 ? void 0 : context.previousReflectionsMap) {
+                context.previousReflectionsMap.forEach((old, keyStr) => {
+                    queryClient.setQueryData(JSON.parse(keyStr), old);
+                });
+            }
+        }, onSettled: (_data, _error, variables) => {
+            queryClient.invalidateQueries({
+                queryKey: [...exports.REFLECTION_KEYS.all, "list"],
+            });
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.comments(variables.reflectionId),
+            });
+        } }, options));
+}
+/**
+ * Update a reflection comment
+ */
+function useUpdateReflectionComment(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: ({ commentId, content }) => client.reflections.updateComment(commentId, content), onSuccess: (data, variables, context) => {
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.comments(variables.reflectionId),
+            });
+            if (options === null || options === void 0 ? void 0 : options.onSuccess) {
+                options.onSuccess(data, variables, context, context);
+            }
+        } }, options));
+}
+/**
+ * Delete a single reflection comment
+ */
+function useDeleteReflectionComment(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: ({ commentId }) => client.reflections.deleteComment(commentId), onSuccess: (data, variables, context) => {
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.comments(variables.reflectionId),
+            });
+            if (options === null || options === void 0 ? void 0 : options.onSuccess) {
+                options.onSuccess(data, variables, context, context);
+            }
+        } }, options));
+}
+/**
+ * Batch delete all comments for a reflection
+ */
+function useDeleteAllReflectionComments(options) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)(Object.assign({ mutationFn: ({ reflectionId }) => client.reflections.deleteAllComments(reflectionId), onSuccess: (data, variables, context) => {
+            queryClient.invalidateQueries({
+                queryKey: exports.REFLECTION_KEYS.comments(variables.reflectionId),
+            });
+            if (options === null || options === void 0 ? void 0 : options.onSuccess) {
+                options.onSuccess(data, variables, context, context);
+            }
+        } }, options));
+}

package/dist/react/hooks/useTasks.d.ts

@@ -5,7 +5,7 @@ export declare const taskKeys: {
     all: readonly ["tasks"];
     lists: () => readonly ["tasks", "list"];
     list: (missionId: string) => readonly ["tasks", "list", string];
-    infinite: (roadmapId: string, userId: string, filters?: Omit<TaskFilters, "start" | "limit">) => readonly ["tasks", "infinite", string, string, Omit<TaskFilters, "start" | "limit"> | undefined];
+    infinite: (roadmapId: string, userId: string, filters?: Omit<TaskFilters, "start" | "limit">) => readonly ["tasks", "infinite", string, string, Omit<TaskFilters, "limit" | "start"> | undefined];
     details: () => readonly ["tasks", "detail"];
     detail: (id: string) => readonly ["tasks", "detail", string];
     creators: (roadmapId: string) => readonly ["tasks", "creators", string];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crimson-education/sdk",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Crimson SDK for accessing Crimson App APIs",
   "main": "dist/index.js",
   "module": "dist/index.js",