lamp-core-lst 2026.1.21 → 2026.2.4

package/dist/service/Activity.service.d.ts

@@ -134,6 +134,12 @@ export declare class ActivityService {
      * @param binId
      */
     deleteActivityBin(parentId: Identifier, binId: Identifier, isGlobalDelete?: boolean, isEdit?: boolean): Promise<Identifier>;
+    /**
+     * Edit Global bin.
+     */
+    editBin(studyId: Identifier, binId: Identifier, body: {
+        label: string;
+    }): Promise<Identifier>;
 }
 /**
  * Result of activity export

package/dist/service/Activity.service.js

@@ -999,6 +999,24 @@ var ActivityService = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Edit Global bin.
+     */
+    ActivityService.prototype.editBin = function (studyId, binId, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (studyId === null || studyId === undefined)
+                            throw new Error("Required parameter studyId was null or undefined.");
+                        if (binId === null || binId === undefined)
+                            throw new Error("Required parameter binId was null or undefined.");
+                        return [4 /*yield*/, Fetch_1.Fetch.put("/activity/bin/" + studyId + "/" + binId, body, this.configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     return ActivityService;
 }());
 exports.ActivityService = ActivityService;

package/dist/service/SurveyResponse.service.d.ts

@@ -7,7 +7,6 @@ export interface QuestionAnswer {
     questionText?: string;
 }
 export interface SurveyResponse {
-    date: number;
     timestamp: number;
     displayableAnswers: QuestionAnswer[];
     isPinned?: boolean;
@@ -28,7 +27,15 @@ export interface GroupedSurveyResponse {
     groups: SurveyGroup[];
     ungroupedSurveys: SurveyItem[];
 }
+export interface SingleActivitySurveyResponse {
+    id: string;
+    title: string;
+    binName?: string;
+    description?: string;
+    responses: SurveyResponse[];
+}
 export declare type FilterType = "weekly" | "daily" | "monthly" | "all" | "pinned";
+export declare type SurveyFilter = "pinned" | "all";
 export interface FilterParams {
     filterType: FilterType;
     date?: number;
@@ -37,6 +44,8 @@ export interface FilterParams {
     month?: number;
     year?: number;
     limit?: number;
+    activityId?: string;
+    surveyFilter?: SurveyFilter;
 }
 export interface PinSurveyResponseParams {
     activity_id: string;
@@ -57,13 +66,17 @@ export interface PinSurveyResponseResult {
     success: boolean;
     message: string;
 }
+export interface PinnedSurveyActivitiesResult {
+    activityIds: string[];
+}
 export declare class SurveyResponseService {
     configuration?: Configuration;
     /**
      * Get survey responses for a participant grouped by survey groups from researcher settings
+     * If activityId is provided, returns only that activity's data in a simplified format (SingleActivitySurveyResponse)
      * @param participantId - The participant ID
      * @param filterParams - Filter parameters for the query
-     * @returns Promise<GroupedSurveyResponse>
+     * @returns Promise<GroupedSurveyResponse | SingleActivitySurveyResponse>
      *
      * @example
      * // Get weekly responses (last 7 days)
@@ -103,8 +116,37 @@ export declare class SurveyResponseService {
      * @example
      * // Get latest 5 responses per survey
      * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', limit: 5 });
+     *
+     * @example
+     * // Get responses for a specific activity only (returns SingleActivitySurveyResponse)
+     * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', activityId: 'activity_id' });
+     *
+     * @example
+     * // Get only pinned surveys
+     * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', surveyFilter: 'pinned' });
+     *
+     * @example
+     * // Get all surveys (default)
+     * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', surveyFilter: 'all' });
+     */
+    getSurveyResponses(participantId: Identifier, filterParams?: FilterParams): Promise<GroupedSurveyResponse | SingleActivitySurveyResponse>;
+    /**
+     * Get survey responses for a specific activity only
+     * Returns simplified format without groups structure
+     * @param participantId - The participant ID
+     * @param activityId - The activity ID to filter by
+     * @param filterParams - Optional additional filter parameters (excluding activityId)
+     * @returns Promise<SingleActivitySurveyResponse>
+     *
+     * @example
+     * // Get all responses for a specific survey
+     * const result = await LAMP.SurveyResponse.getActivitySurveyResponses('participant_id', 'activity_id');
+     *
+     * @example
+     * // Get latest 5 responses for a specific survey
+     * const result = await LAMP.SurveyResponse.getActivitySurveyResponses('participant_id', 'activity_id', { filterType: 'all', limit: 5 });
      */
-    getSurveyResponses(participantId: Identifier, filterParams?: FilterParams): Promise<GroupedSurveyResponse>;
+    getActivitySurveyResponses(participantId: Identifier, activityId: string, filterParams?: Omit<FilterParams, 'activityId'>): Promise<SingleActivitySurveyResponse>;
     /**
      * Get weekly survey responses for a participant (last 7 days including today)
      * @param participantId - The participant ID
@@ -186,4 +228,45 @@ export declare class SurveyResponseService {
      * const result = await LAMP.SurveyResponse.unpinSurveyResponse('participant_id', 'activity_id', 1700000000000);
      */
     unpinSurveyResponse(participantId: Identifier, activityId: string, timestamp: number): Promise<PinSurveyResponseResult>;
+    /**
+     * Pin a survey activity for a study
+     * @param studyId - The study ID
+     * @param activityId - The survey activity ID to pin
+     * @returns Promise<PinSurveyResponseResult>
+     *
+     * @example
+     * const result = await LAMP.SurveyResponse.pinSurveyActivity('study_id', 'activity_id');
+     */
+    pinSurveyActivity(studyId: Identifier, activityId: string): Promise<PinSurveyResponseResult>;
+    /**
+     * Unpin a survey activity for a study
+     * @param studyId - The study ID
+     * @param activityId - The survey activity ID to unpin
+     * @returns Promise<PinSurveyResponseResult>
+     *
+     * @example
+     * const result = await LAMP.SurveyResponse.unpinSurveyActivity('study_id', 'activity_id');
+     */
+    unpinSurveyActivity(studyId: Identifier, activityId: string): Promise<PinSurveyResponseResult>;
+    /**
+     * Get all pinned survey activities for a study
+     * @param studyId - The study ID
+     * @returns Promise<PinnedSurveyActivitiesResult>
+     *
+     * @example
+     * const result = await LAMP.SurveyResponse.getPinnedSurveyActivities('study_id');
+     * console.log(result.activityIds); // ['activity_id_1', 'activity_id_2']
+     */
+    getPinnedSurveyActivities(studyId: Identifier): Promise<PinnedSurveyActivitiesResult>;
+    /**
+     * Get only pinned survey responses for pinned surveys only
+     * Combines surveyFilter: 'pinned' with filterType: 'all'
+     * @param participantId - The participant ID
+     * @returns Promise<GroupedSurveyResponse>
+     *
+     * @example
+     * // Get responses only from pinned surveys
+     * const result = await LAMP.SurveyResponse.getPinnedSurveysResponses('participant_id');
+     */
+    getPinnedSurveysResponses(participantId: Identifier): Promise<GroupedSurveyResponse>;
 }

package/dist/service/SurveyResponse.service.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -43,9 +54,10 @@ var SurveyResponseService = /** @class */ (function () {
     }
     /**
      * Get survey responses for a participant grouped by survey groups from researcher settings
+     * If activityId is provided, returns only that activity's data in a simplified format (SingleActivitySurveyResponse)
      * @param participantId - The participant ID
      * @param filterParams - Filter parameters for the query
-     * @returns Promise<GroupedSurveyResponse>
+     * @returns Promise<GroupedSurveyResponse | SingleActivitySurveyResponse>
      *
      * @example
      * // Get weekly responses (last 7 days)
@@ -85,6 +97,18 @@ var SurveyResponseService = /** @class */ (function () {
      * @example
      * // Get latest 5 responses per survey
      * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', limit: 5 });
+     *
+     * @example
+     * // Get responses for a specific activity only (returns SingleActivitySurveyResponse)
+     * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', activityId: 'activity_id' });
+     *
+     * @example
+     * // Get only pinned surveys
+     * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', surveyFilter: 'pinned' });
+     *
+     * @example
+     * // Get all surveys (default)
+     * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', surveyFilter: 'all' });
      */
     SurveyResponseService.prototype.getSurveyResponses = function (participantId, filterParams) {
         var _a;
@@ -99,6 +123,15 @@ var SurveyResponseService = /** @class */ (function () {
                         }
                         if (((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.base) === "https://demo.lamp.digital") {
                             // DEMO - return empty structure for demo mode
+                            if (filterParams.activityId) {
+                                return [2 /*return*/, Promise.resolve({
+                                        id: filterParams.activityId,
+                                        title: "",
+                                        binName: undefined,
+                                        description: undefined,
+                                        responses: [],
+                                    })];
+                            }
                             return [2 /*return*/, Promise.resolve({
                                     groups: [],
                                     ungroupedSurveys: [],
@@ -124,14 +157,69 @@ var SurveyResponseService = /** @class */ (function () {
                         if (filterParams.limit !== undefined) {
                             queryParams.set("limit", String(filterParams.limit));
                         }
-                        return [4 /*yield*/, Fetch_1.Fetch.get("/participant/" + participantId + "/survey_responses?" + queryParams.toString(), this.configuration)];
+                        if (filterParams.activityId !== undefined) {
+                            queryParams.set("activityId", filterParams.activityId);
+                        }
+                        if (filterParams.surveyFilter !== undefined) {
+                            queryParams.set("surveyFilter", filterParams.surveyFilter);
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.get("/participant/" + participantId + "/survey_responses?" + queryParams.toString(), this.configuration)
+                            // Return appropriate default based on whether activityId was provided
+                        ];
                     case 1:
                         result = _b.sent();
+                        // Return appropriate default based on whether activityId was provided
+                        if (filterParams.activityId) {
+                            return [2 /*return*/, result.data || {
+                                    id: filterParams.activityId,
+                                    title: "",
+                                    binName: undefined,
+                                    description: undefined,
+                                    responses: []
+                                }];
+                        }
                         return [2 /*return*/, result.data || { groups: [], ungroupedSurveys: [] }];
                 }
             });
         });
     };
+    /**
+     * Get survey responses for a specific activity only
+     * Returns simplified format without groups structure
+     * @param participantId - The participant ID
+     * @param activityId - The activity ID to filter by
+     * @param filterParams - Optional additional filter parameters (excluding activityId)
+     * @returns Promise<SingleActivitySurveyResponse>
+     *
+     * @example
+     * // Get all responses for a specific survey
+     * const result = await LAMP.SurveyResponse.getActivitySurveyResponses('participant_id', 'activity_id');
+     *
+     * @example
+     * // Get latest 5 responses for a specific survey
+     * const result = await LAMP.SurveyResponse.getActivitySurveyResponses('participant_id', 'activity_id', { filterType: 'all', limit: 5 });
+     */
+    SurveyResponseService.prototype.getActivitySurveyResponses = function (participantId, activityId, filterParams) {
+        if (filterParams === void 0) { filterParams = { filterType: "all" }; }
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (participantId === null || participantId === undefined) {
+                            throw new Error("Required parameter participantId was null or undefined when calling getActivitySurveyResponses.");
+                        }
+                        if (!activityId) {
+                            throw new Error("Required parameter activityId was null or undefined when calling getActivitySurveyResponses.");
+                        }
+                        return [4 /*yield*/, this.getSurveyResponses(participantId, __assign(__assign({}, filterParams), { activityId: activityId }))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
     /**
      * Get weekly survey responses for a participant (last 7 days including today)
      * @param participantId - The participant ID
@@ -366,6 +454,130 @@ var SurveyResponseService = /** @class */ (function () {
             });
         });
     };
+    // ==================== SURVEY ACTIVITY PIN METHODS ====================
+    /**
+     * Pin a survey activity for a study
+     * @param studyId - The study ID
+     * @param activityId - The survey activity ID to pin
+     * @returns Promise<PinSurveyResponseResult>
+     *
+     * @example
+     * const result = await LAMP.SurveyResponse.pinSurveyActivity('study_id', 'activity_id');
+     */
+    SurveyResponseService.prototype.pinSurveyActivity = function (studyId, activityId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (studyId === null || studyId === undefined) {
+                            throw new Error("Required parameter studyId was null or undefined when calling pinSurveyActivity.");
+                        }
+                        if (!activityId) {
+                            throw new Error("Required parameter activityId was null or undefined when calling pinSurveyActivity.");
+                        }
+                        if (((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.base) === "https://demo.lamp.digital") {
+                            // DEMO
+                            return [2 /*return*/, Promise.resolve({ error: "500.demo-restriction" })];
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.post("/study/" + studyId + "/survey_activities/pin", {
+                                activity_id: activityId,
+                            }, this.configuration)];
+                    case 1:
+                        result = _b.sent();
+                        return [2 /*return*/, result.data || { success: false, message: "Unknown error" }];
+                }
+            });
+        });
+    };
+    /**
+     * Unpin a survey activity for a study
+     * @param studyId - The study ID
+     * @param activityId - The survey activity ID to unpin
+     * @returns Promise<PinSurveyResponseResult>
+     *
+     * @example
+     * const result = await LAMP.SurveyResponse.unpinSurveyActivity('study_id', 'activity_id');
+     */
+    SurveyResponseService.prototype.unpinSurveyActivity = function (studyId, activityId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (studyId === null || studyId === undefined) {
+                            throw new Error("Required parameter studyId was null or undefined when calling unpinSurveyActivity.");
+                        }
+                        if (!activityId) {
+                            throw new Error("Required parameter activityId was null or undefined when calling unpinSurveyActivity.");
+                        }
+                        if (((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.base) === "https://demo.lamp.digital") {
+                            // DEMO
+                            return [2 /*return*/, Promise.resolve({ error: "500.demo-restriction" })];
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.delete("/study/" + studyId + "/survey_activities/pin", this.configuration, {
+                                activity_id: activityId,
+                            })];
+                    case 1:
+                        result = _b.sent();
+                        return [2 /*return*/, result.data || { success: false, message: "Unknown error" }];
+                }
+            });
+        });
+    };
+    /**
+     * Get all pinned survey activities for a study
+     * @param studyId - The study ID
+     * @returns Promise<PinnedSurveyActivitiesResult>
+     *
+     * @example
+     * const result = await LAMP.SurveyResponse.getPinnedSurveyActivities('study_id');
+     * console.log(result.activityIds); // ['activity_id_1', 'activity_id_2']
+     */
+    SurveyResponseService.prototype.getPinnedSurveyActivities = function (studyId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (studyId === null || studyId === undefined) {
+                            throw new Error("Required parameter studyId was null or undefined when calling getPinnedSurveyActivities.");
+                        }
+                        if (((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.base) === "https://demo.lamp.digital") {
+                            // DEMO
+                            return [2 /*return*/, Promise.resolve({ activityIds: [] })];
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.get("/study/" + studyId + "/survey_activities/pinned", this.configuration)];
+                    case 1:
+                        result = _b.sent();
+                        return [2 /*return*/, result.data || { activityIds: [] }];
+                }
+            });
+        });
+    };
+    /**
+     * Get only pinned survey responses for pinned surveys only
+     * Combines surveyFilter: 'pinned' with filterType: 'all'
+     * @param participantId - The participant ID
+     * @returns Promise<GroupedSurveyResponse>
+     *
+     * @example
+     * // Get responses only from pinned surveys
+     * const result = await LAMP.SurveyResponse.getPinnedSurveysResponses('participant_id');
+     */
+    SurveyResponseService.prototype.getPinnedSurveysResponses = function (participantId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getSurveyResponses(participantId, {
+                        filterType: "all",
+                        surveyFilter: "pinned",
+                    })];
+            });
+        });
+    };
     return SurveyResponseService;
 }());
 exports.SurveyResponseService = SurveyResponseService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lamp-core-lst",
-  "version": "2026.1.21",
+  "version": "2026.2.4",
   "author": "BIDMC Division of Digital Psychiatry <team@digitalpsych.org>",
   "description": "The JavaScript and TypeScript API client for the LAMP Platform.",
   "homepage": "https://docs.lamp.digital/",

package/src/service/Activity.service.ts

@@ -22,7 +22,7 @@ export class ActivityService {
       return Promise.resolve(output)
     }
     return (await Fetch.get<{ data: any[] }>(`/activity`, this.configuration)).data?.map((x) =>
-      Object.assign(new Activity(), x)
+      Object.assign(new Activity(), x),
     )
   }
 
@@ -35,7 +35,7 @@ export class ActivityService {
     transform?: string,
     ignore_binary?: boolean,
     limit?: number,
-    offset?: number
+    offset?: number,
   ): Promise<{ data: Activity[]; total: number }> {
     if (participantId === null || participantId === undefined)
       throw new Error("Required parameter participantId was null or undefined when calling activityAllByParticipant.")
@@ -51,7 +51,7 @@ export class ActivityService {
         let output = Demo.Activity.filter((x) =>
           Demo.Participant.filter((y) => y["id"] === participantId)
             ?.map((y) => y["#parent"])
-            .includes(x["#parent"])
+            .includes(x["#parent"]),
         )?.map((x) => Object.assign(new Activity(), x))
         output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
         // For demo, return all data with total count
@@ -74,7 +74,7 @@ export class ActivityService {
     const queryString = params.toString()
     const result: any = await Fetch.get<{ data: Activity[]; total?: number }>(
       `/participant/${participantId}/activity?${queryString}`,
-      this.configuration
+      this.configuration,
     )
 
     // Handle the response structure based on _select function behavior:
@@ -125,7 +125,7 @@ export class ActivityService {
         let output = Demo.Activity.filter((x) =>
           Demo.Study.filter((y) => y["#parent"] === researcherId)
             ?.map((y) => y["id"])
-            .includes(x["#parent"])
+            .includes(x["#parent"]),
         )?.map((x) => Object.assign(new Activity(), x))
         output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
         return Promise.resolve(output)
@@ -134,7 +134,7 @@ export class ActivityService {
       }
     }
     return (await Fetch.get<{ data: any[] }>(`/researcher/${researcherId}/activity`, this.configuration)).data?.map(
-      (x) => Object.assign(new Activity(), x)
+      (x) => Object.assign(new Activity(), x),
     )
   }
 
@@ -151,7 +151,7 @@ export class ActivityService {
     transform?: string,
     ignore_binary?: boolean,
     limit?: number,
-    offset?: number
+    offset?: number,
   ): Promise<Activity[] | { data: Activity[]; total: number }> {
     if (studyId === null || studyId === undefined)
       throw new Error("Required parameter studyId was null or undefined when calling activityAllByStudy.")
@@ -192,7 +192,7 @@ export class ActivityService {
 
     const result: any = await Fetch.get<{ data: Activity[]; total?: number }>(
       `/study/${studyId}/activity?${queryString}`,
-      this.configuration
+      this.configuration,
     )
 
     // Handle the response structure based on _select function behavior:
@@ -227,7 +227,7 @@ export class ActivityService {
     tab?: string,
     transform?: string,
     limit?: number,
-    offset?: number
+    offset?: number,
   ): Promise<{ data: any; total: number }> {
     if (participantId === null || participantId === undefined)
       throw new Error("Required parameter participantId was null or undefined when calling listActivities.")
@@ -241,7 +241,7 @@ export class ActivityService {
 
       if (Demo.Participant.filter((x) => x["id"] === participantId).length > 0) {
         let output = Demo.Activity.filter((x) => x["#parent"] === participantId)?.map((x) =>
-          Object.assign(new Activity(), x)
+          Object.assign(new Activity(), x),
         )
         output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
         return Promise.resolve({ data: output, total: output.length } as any)
@@ -259,7 +259,7 @@ export class ActivityService {
 
     const result: any = await Fetch.get<{ data: any; total: number }>(
       `/activity/${participantId}/activity${queryString ? `?${queryString}` : ""}`,
-      this.configuration
+      this.configuration,
     )
 
     // Handle different response structures
@@ -400,7 +400,7 @@ export class ActivityService {
     }
     const result: any = await Fetch.get<{ data: Activity }>(
       `/activity/${activityId}?ignore_binary=${ignore_binary}`,
-      this.configuration
+      this.configuration,
     )
     // API returns { data: Activity } (single object, not array)
     if (result && result.data) {
@@ -418,7 +418,7 @@ export class ActivityService {
     moduleId: Identifier,
     participantId: Identifier,
     startTime?: number,
-    endTime?: number
+    endTime?: number,
   ): Promise<any[]> {
     if (participantId === null || participantId === undefined)
       throw new Error("Required parameter participantId was null or undefined when calling moduleByParticipant.")
@@ -434,7 +434,7 @@ export class ActivityService {
 
       if (Demo.Activity.filter((x) => x["id"] === moduleId).length > 0) {
         let output = Demo.Activity.filter((x) => x["#parent"] === moduleId)?.map((x) =>
-          Object.assign(new Activity(), x)
+          Object.assign(new Activity(), x),
         )
 
         return Promise.resolve(output)
@@ -452,7 +452,7 @@ export class ActivityService {
     const queryString = params.toString()
     const url = `/module/${moduleId}/${participantId}${queryString ? `?${queryString}` : ""}`
     return (await Fetch.get<{ data: any[] }>(url, this.configuration)).data?.map((x) =>
-      Object.assign(new Activity(), x)
+      Object.assign(new Activity(), x),
     )
   }
 
@@ -463,7 +463,7 @@ export class ActivityService {
   public async scheduledActivities(
     participantId: Identifier,
     transform?: string,
-    ignore_binary?: boolean
+    ignore_binary?: boolean,
   ): Promise<Activity[]> {
     if (participantId === null || participantId === undefined)
       throw new Error("Required parameter participantId was null or undefined when calling activityAllByParticipant.")
@@ -479,7 +479,7 @@ export class ActivityService {
         let output = Demo.Activity.filter((x) =>
           Demo.Participant.filter((y) => y["id"] === participantId)
             ?.map((y) => y["#parent"])
-            .includes(x["#parent"])
+            .includes(x["#parent"]),
         )?.map((x) => Object.assign(new Activity(), x))
         output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
         return Promise.resolve(output)
@@ -490,7 +490,7 @@ export class ActivityService {
 
     const result = (await Fetch.get<{ data: any[] }>(
       `/participant/${participantId}/activitySchedule?ignore_binary=${ignore_binary}`,
-      this.configuration
+      this.configuration,
     )) as any
     return result
   }
@@ -513,7 +513,7 @@ export class ActivityService {
         let output = Demo.Activity.filter((x) =>
           Demo.Participant.filter((y) => y["id"] === participantId)
             ?.map((y) => y["#parent"])
-            .includes(x["#parent"])
+            .includes(x["#parent"]),
         )?.map((x) => Object.assign(new Activity(), x))
         output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
         return Promise.resolve(output)
@@ -524,7 +524,7 @@ export class ActivityService {
 
     const result = (await Fetch.get<{ data: any[] }>(
       `/participant/${participantId}/emptyTab`,
-      this.configuration
+      this.configuration,
     )) as any
     return result
   }
@@ -553,7 +553,7 @@ export class ActivityService {
 
       // Map "me" to the credential's origin if present
       const resolvedActivities = activities.map((id) =>
-        id === "me" && credential[0]["origin"] ? credential[0]["origin"] : id
+        id === "me" && credential[0]["origin"] ? credential[0]["origin"] : id,
       )
 
       // Track deleted and not-found IDs (for debugging or reporting)
@@ -604,7 +604,7 @@ export class ActivityService {
         let output = Demo.Activity.filter((x) =>
           Demo.Participant.filter((y) => y["id"] === participantId)
             ?.map((y) => y["#parent"])
-            .includes(x["#parent"])
+            .includes(x["#parent"]),
         )?.map((x) => Object.assign(new Activity(), x))
 
         return Promise.resolve(output)
@@ -613,7 +613,7 @@ export class ActivityService {
       }
     }
     return (await Fetch.post<{ data: any[] }>(`/feed/module/${participantId}`, this.configuration)).data?.map((x) =>
-      Object.assign(new Activity(), x)
+      Object.assign(new Activity(), x),
     )
   }
 
@@ -647,7 +647,7 @@ export class ActivityService {
 
     const result = await Fetch.get<{ data: string[] }>(
       `/participant/${participantId}/favorite_activities`,
-      this.configuration
+      this.configuration,
     )
     let output = result.data || []
     output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
@@ -730,7 +730,7 @@ export class ActivityService {
     const result = await Fetch.post<{ data: ActivityExportResult[] }>(
       `/activity/export`,
       activityIds,
-      this.configuration
+      this.configuration,
     )
     return result.data || []
   }
@@ -746,7 +746,7 @@ export class ActivityService {
   public async importActivities(
     studyId: Identifier,
     activitiesWithAttachments: ActivityExportResult[],
-    options?: ActivityImportOptions
+    options?: ActivityImportOptions,
   ): Promise<ActivityImportResult> {
     if (studyId === null || studyId === undefined) {
       throw new Error("Required parameter studyId was null or undefined when calling importActivities.")
@@ -773,8 +773,8 @@ export class ActivityService {
         const name = options?.namePrefix
           ? `${options.namePrefix}${item.activity.name}`
           : options?.nameSuffix
-          ? `${item.activity.name}${options.nameSuffix}`
-          : item.activity.name
+            ? `${item.activity.name}${options.nameSuffix}`
+            : item.activity.name
 
         Demo.Activity.push({
           "#type": "Activity",
@@ -808,7 +808,7 @@ export class ActivityService {
     const result = await Fetch.post<{ data: ActivityImportResult }>(
       `/study/${studyId}/activity/import`,
       { activities: activitiesWithAttachments, options },
-      this.configuration
+      this.configuration,
     )
     return (
       result.data || {
@@ -829,7 +829,7 @@ export class ActivityService {
     parentId: Identifier,
     binId: Identifier,
     isGlobalDelete: boolean = false,
-    isEdit: boolean = false
+    isEdit: boolean = false,
   ): Promise<Identifier> {
     if (parentId === null || parentId === undefined)
       throw new Error("Required parameter parentId was null or undefined.")
@@ -884,6 +884,15 @@ export class ActivityService {
       : `/activity/bin/${parentId}/${binId}`
     return await Fetch.delete(route, this.configuration)
   }
+
+  /**
+   * Edit Global bin.
+   */
+  public async editBin(studyId: Identifier, binId: Identifier, body: { label: string }): Promise<Identifier> {
+    if (studyId === null || studyId === undefined) throw new Error("Required parameter studyId was null or undefined.")
+    if (binId === null || binId === undefined) throw new Error("Required parameter binId was null or undefined.")
+    return await Fetch.put(`/activity/bin/${studyId}/${binId}`, body, this.configuration)
+  }
 }
 
 /**

package/src/service/SurveyResponse.service.ts

@@ -10,7 +10,6 @@ export interface QuestionAnswer {
 }
 
 export interface SurveyResponse {
-  date: number
   timestamp: number
   displayableAnswers: QuestionAnswer[] // Only answers from questions with displayInSurveyResponses: true
   isPinned?: boolean
@@ -35,9 +34,21 @@ export interface GroupedSurveyResponse {
   ungroupedSurveys: SurveyItem[]
 }
 
+// Single activity response when activityId filter is provided
+export interface SingleActivitySurveyResponse {
+  id: string
+  title: string
+  binName?: string
+  description?: string
+  responses: SurveyResponse[]
+}
+
 // Filter types for survey responses
 export type FilterType = "weekly" | "daily" | "monthly" | "all" | "pinned"
 
+// Filter for survey activities (pinned vs all)
+export type SurveyFilter = "pinned" | "all"
+
 export interface FilterParams {
   filterType: FilterType
   date?: number // For daily filter - specific date timestamp
@@ -46,6 +57,8 @@ export interface FilterParams {
   month?: number // For monthly filter (1-12)
   year?: number // For monthly filter
   limit?: number // Limit number of responses per survey (e.g., 5 for latest 5)
+  activityId?: string // Filter by specific survey activity ID
+  surveyFilter?: SurveyFilter // Filter surveys by pinned status (default: "all")
 }
 
 export interface PinSurveyResponseParams {
@@ -72,14 +85,19 @@ export interface PinSurveyResponseResult {
   message: string
 }
 
+export interface PinnedSurveyActivitiesResult {
+  activityIds: string[]
+}
+
 export class SurveyResponseService {
   public configuration?: Configuration
 
   /**
    * Get survey responses for a participant grouped by survey groups from researcher settings
+   * If activityId is provided, returns only that activity's data in a simplified format (SingleActivitySurveyResponse)
    * @param participantId - The participant ID
    * @param filterParams - Filter parameters for the query
-   * @returns Promise<GroupedSurveyResponse>
+   * @returns Promise<GroupedSurveyResponse | SingleActivitySurveyResponse>
    * 
    * @example
    * // Get weekly responses (last 7 days)
@@ -119,11 +137,23 @@ export class SurveyResponseService {
    * @example
    * // Get latest 5 responses per survey
    * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', limit: 5 });
+   * 
+   * @example
+   * // Get responses for a specific activity only (returns SingleActivitySurveyResponse)
+   * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', activityId: 'activity_id' });
+   * 
+   * @example
+   * // Get only pinned surveys
+   * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', surveyFilter: 'pinned' });
+   * 
+   * @example
+   * // Get all surveys (default)
+   * const result = await LAMP.SurveyResponse.getSurveyResponses('participant_id', { filterType: 'all', surveyFilter: 'all' });
    */
   public async getSurveyResponses(
     participantId: Identifier,
     filterParams: FilterParams = { filterType: "weekly" }
-  ): Promise<GroupedSurveyResponse> {
+  ): Promise<GroupedSurveyResponse | SingleActivitySurveyResponse> {
     if (participantId === null || participantId === undefined) {
       throw new Error(
         "Required parameter participantId was null or undefined when calling getSurveyResponses."
@@ -132,6 +162,15 @@ export class SurveyResponseService {
 
     if (this.configuration?.base === "https://demo.lamp.digital") {
       // DEMO - return empty structure for demo mode
+      if (filterParams.activityId) {
+        return Promise.resolve({
+          id: filterParams.activityId,
+          title: "",
+          binName: undefined,
+          description: undefined,
+          responses: [],
+        })
+      }
       return Promise.resolve({
         groups: [],
         ungroupedSurveys: [],
@@ -160,15 +199,71 @@ export class SurveyResponseService {
     if (filterParams.limit !== undefined) {
       queryParams.set("limit", String(filterParams.limit))
     }
+    if (filterParams.activityId !== undefined) {
+      queryParams.set("activityId", filterParams.activityId)
+    }
+    if (filterParams.surveyFilter !== undefined) {
+      queryParams.set("surveyFilter", filterParams.surveyFilter)
+    }
 
-    const result = await Fetch.get<{ data: GroupedSurveyResponse }>(
+    const result = await Fetch.get<{ data: GroupedSurveyResponse | SingleActivitySurveyResponse }>(
       `/participant/${participantId}/survey_responses?${queryParams.toString()}`,
       this.configuration
     )
 
+    // Return appropriate default based on whether activityId was provided
+    if (filterParams.activityId) {
+      return result.data || { 
+        id: filterParams.activityId, 
+        title: "", 
+        binName: undefined,
+        description: undefined,
+        responses: [] 
+      }
+    }
     return result.data || { groups: [], ungroupedSurveys: [] }
   }
 
+  /**
+   * Get survey responses for a specific activity only
+   * Returns simplified format without groups structure
+   * @param participantId - The participant ID
+   * @param activityId - The activity ID to filter by
+   * @param filterParams - Optional additional filter parameters (excluding activityId)
+   * @returns Promise<SingleActivitySurveyResponse>
+   * 
+   * @example
+   * // Get all responses for a specific survey
+   * const result = await LAMP.SurveyResponse.getActivitySurveyResponses('participant_id', 'activity_id');
+   * 
+   * @example
+   * // Get latest 5 responses for a specific survey
+   * const result = await LAMP.SurveyResponse.getActivitySurveyResponses('participant_id', 'activity_id', { filterType: 'all', limit: 5 });
+   */
+  public async getActivitySurveyResponses(
+    participantId: Identifier,
+    activityId: string,
+    filterParams: Omit<FilterParams, 'activityId'> = { filterType: "all" }
+  ): Promise<SingleActivitySurveyResponse> {
+    if (participantId === null || participantId === undefined) {
+      throw new Error(
+        "Required parameter participantId was null or undefined when calling getActivitySurveyResponses."
+      )
+    }
+    if (!activityId) {
+      throw new Error(
+        "Required parameter activityId was null or undefined when calling getActivitySurveyResponses."
+      )
+    }
+
+    const result = await this.getSurveyResponses(participantId, {
+      ...filterParams,
+      activityId,
+    })
+
+    return result as SingleActivitySurveyResponse
+  }
+
   /**
    * Get weekly survey responses for a participant (last 7 days including today)
    * @param participantId - The participant ID
@@ -185,7 +280,7 @@ export class SurveyResponseService {
       filterType: "weekly",
       fromDate,
       toDate,
-    })
+    }) as Promise<GroupedSurveyResponse>
   }
 
   /**
@@ -201,7 +296,7 @@ export class SurveyResponseService {
     return this.getSurveyResponses(participantId, {
       filterType: "daily",
       date,
-    })
+    }) as Promise<GroupedSurveyResponse>
   }
 
   /**
@@ -220,7 +315,7 @@ export class SurveyResponseService {
       filterType: "monthly",
       month,
       year,
-    })
+    }) as Promise<GroupedSurveyResponse>
   }
 
   /**
@@ -231,7 +326,7 @@ export class SurveyResponseService {
   public async getAllSurveyResponses(participantId: Identifier): Promise<GroupedSurveyResponse> {
     return this.getSurveyResponses(participantId, {
       filterType: "all",
-    })
+    }) as Promise<GroupedSurveyResponse>
   }
 
   /**
@@ -242,7 +337,7 @@ export class SurveyResponseService {
   public async getPinnedSurveyResponses(participantId: Identifier): Promise<GroupedSurveyResponse> {
     return this.getSurveyResponses(participantId, {
       filterType: "pinned",
-    })
+    }) as Promise<GroupedSurveyResponse>
   }
 
   /**
@@ -262,7 +357,7 @@ export class SurveyResponseService {
     return this.getSurveyResponses(participantId, {
       filterType: "all",
       limit,
-    })
+    }) as Promise<GroupedSurveyResponse>
   }
 
   /**
@@ -410,5 +505,131 @@ export class SurveyResponseService {
 
     return result.data || { success: false, message: "Unknown error" }
   }
+
+  // ==================== SURVEY ACTIVITY PIN METHODS ====================
+
+  /**
+   * Pin a survey activity for a study
+   * @param studyId - The study ID
+   * @param activityId - The survey activity ID to pin
+   * @returns Promise<PinSurveyResponseResult>
+   * 
+   * @example
+   * const result = await LAMP.SurveyResponse.pinSurveyActivity('study_id', 'activity_id');
+   */
+  public async pinSurveyActivity(
+    studyId: Identifier,
+    activityId: string
+  ): Promise<PinSurveyResponseResult> {
+    if (studyId === null || studyId === undefined) {
+      throw new Error(
+        "Required parameter studyId was null or undefined when calling pinSurveyActivity."
+      )
+    }
+    if (!activityId) {
+      throw new Error("Required parameter activityId was null or undefined when calling pinSurveyActivity.")
+    }
+
+    if (this.configuration?.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+
+    const result = await Fetch.post<{ data: PinSurveyResponseResult }>(
+      `/study/${studyId}/survey_activities/pin`,
+      {
+        activity_id: activityId,
+      },
+      this.configuration
+    )
+
+    return result.data || { success: false, message: "Unknown error" }
+  }
+
+  /**
+   * Unpin a survey activity for a study
+   * @param studyId - The study ID
+   * @param activityId - The survey activity ID to unpin
+   * @returns Promise<PinSurveyResponseResult>
+   * 
+   * @example
+   * const result = await LAMP.SurveyResponse.unpinSurveyActivity('study_id', 'activity_id');
+   */
+  public async unpinSurveyActivity(
+    studyId: Identifier,
+    activityId: string
+  ): Promise<PinSurveyResponseResult> {
+    if (studyId === null || studyId === undefined) {
+      throw new Error(
+        "Required parameter studyId was null or undefined when calling unpinSurveyActivity."
+      )
+    }
+    if (!activityId) {
+      throw new Error("Required parameter activityId was null or undefined when calling unpinSurveyActivity.")
+    }
+
+    if (this.configuration?.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+
+    const result = await Fetch.delete<{ data: PinSurveyResponseResult }>(
+      `/study/${studyId}/survey_activities/pin`,
+      this.configuration,
+      {
+        activity_id: activityId,
+      }
+    )
+
+    return result.data || { success: false, message: "Unknown error" }
+  }
+
+  /**
+   * Get all pinned survey activities for a study
+   * @param studyId - The study ID
+   * @returns Promise<PinnedSurveyActivitiesResult>
+   * 
+   * @example
+   * const result = await LAMP.SurveyResponse.getPinnedSurveyActivities('study_id');
+   * console.log(result.activityIds); // ['activity_id_1', 'activity_id_2']
+   */
+  public async getPinnedSurveyActivities(
+    studyId: Identifier
+  ): Promise<PinnedSurveyActivitiesResult> {
+    if (studyId === null || studyId === undefined) {
+      throw new Error(
+        "Required parameter studyId was null or undefined when calling getPinnedSurveyActivities."
+      )
+    }
+
+    if (this.configuration?.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ activityIds: [] })
+    }
+
+    const result = await Fetch.get<{ data: PinnedSurveyActivitiesResult }>(
+      `/study/${studyId}/survey_activities/pinned`,
+      this.configuration
+    )
+
+    return result.data || { activityIds: [] }
+  }
+
+  /**
+   * Get only pinned survey responses for pinned surveys only
+   * Combines surveyFilter: 'pinned' with filterType: 'all'
+   * @param participantId - The participant ID
+   * @returns Promise<GroupedSurveyResponse>
+   * 
+   * @example
+   * // Get responses only from pinned surveys
+   * const result = await LAMP.SurveyResponse.getPinnedSurveysResponses('participant_id');
+   */
+  public async getPinnedSurveysResponses(participantId: Identifier): Promise<GroupedSurveyResponse> {
+    return this.getSurveyResponses(participantId, {
+      filterType: "all",
+      surveyFilter: "pinned",
+    }) as Promise<GroupedSurveyResponse>
+  }
 }