@jugarhoy/api 1.1.20 → 1.1.21

package/apis/SportEventsApi.ts

@@ -15,26 +15,26 @@
 
 import * as runtime from '../runtime';
 import type {
-  ApiAppTeamsTeamIdEventsGet200Response,
-  ApiAppTeamsTeamIdEventsPostRequest,
+  CreateSportEventRequest,
+  GetAvailableSportEvents200Response,
   TeamFeedItemResponse,
 } from '../models/index';
 import {
-    ApiAppTeamsTeamIdEventsGet200ResponseFromJSON,
-    ApiAppTeamsTeamIdEventsGet200ResponseToJSON,
-    ApiAppTeamsTeamIdEventsPostRequestFromJSON,
-    ApiAppTeamsTeamIdEventsPostRequestToJSON,
+    CreateSportEventRequestFromJSON,
+    CreateSportEventRequestToJSON,
+    GetAvailableSportEvents200ResponseFromJSON,
+    GetAvailableSportEvents200ResponseToJSON,
     TeamFeedItemResponseFromJSON,
     TeamFeedItemResponseToJSON,
 } from '../models/index';
 
-export interface ApiAppTeamsTeamIdEventsGetRequest {
+export interface CreateSportEventOperationRequest {
     teamId: string;
+    createSportEventRequest: CreateSportEventRequest;
 }
 
-export interface ApiAppTeamsTeamIdEventsPostOperationRequest {
+export interface GetAvailableSportEventsRequest {
     teamId: string;
-    apiAppTeamsTeamIdEventsPostRequest: ApiAppTeamsTeamIdEventsPostRequest;
 }
 
 /**
@@ -43,13 +43,20 @@ export interface ApiAppTeamsTeamIdEventsPostOperationRequest {
 export class SportEventsApi extends runtime.BaseAPI {
 
     /**
-     * Get available sport events for team\'s sport
+     * Create a sport event in team feed
      */
-    async apiAppTeamsTeamIdEventsGetRaw(requestParameters: ApiAppTeamsTeamIdEventsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiAppTeamsTeamIdEventsGet200Response>> {
+    async createSportEventRaw(requestParameters: CreateSportEventOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdEventsGet().'
+                'Required parameter "teamId" was null or undefined when calling createSportEvent().'
+            );
+        }
+
+        if (requestParameters['createSportEventRequest'] == null) {
+            throw new runtime.RequiredError(
+                'createSportEventRequest',
+                'Required parameter "createSportEventRequest" was null or undefined when calling createSportEvent().'
             );
         }
 
@@ -57,6 +64,8 @@ export class SportEventsApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -67,37 +76,31 @@ export class SportEventsApi extends runtime.BaseAPI {
         }
         const response = await this.request({
             path: `/api/app/teams/{teamId}/events`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))),
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: CreateSportEventRequestToJSON(requestParameters['createSportEventRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiAppTeamsTeamIdEventsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get available sport events for team\'s sport
+     * Create a sport event in team feed
      */
-    async apiAppTeamsTeamIdEventsGet(requestParameters: ApiAppTeamsTeamIdEventsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiAppTeamsTeamIdEventsGet200Response> {
-        const response = await this.apiAppTeamsTeamIdEventsGetRaw(requestParameters, initOverrides);
+    async createSportEvent(requestParameters: CreateSportEventOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
+        const response = await this.createSportEventRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a sport event in team feed
+     * Get available sport events for team\'s sport
      */
-    async apiAppTeamsTeamIdEventsPostRaw(requestParameters: ApiAppTeamsTeamIdEventsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
+    async getAvailableSportEventsRaw(requestParameters: GetAvailableSportEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetAvailableSportEvents200Response>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdEventsPost().'
-            );
-        }
-
-        if (requestParameters['apiAppTeamsTeamIdEventsPostRequest'] == null) {
-            throw new runtime.RequiredError(
-                'apiAppTeamsTeamIdEventsPostRequest',
-                'Required parameter "apiAppTeamsTeamIdEventsPostRequest" was null or undefined when calling apiAppTeamsTeamIdEventsPost().'
+                'Required parameter "teamId" was null or undefined when calling getAvailableSportEvents().'
             );
         }
 
@@ -105,8 +108,6 @@ export class SportEventsApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -117,20 +118,19 @@ export class SportEventsApi extends runtime.BaseAPI {
         }
         const response = await this.request({
             path: `/api/app/teams/{teamId}/events`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))),
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiAppTeamsTeamIdEventsPostRequestToJSON(requestParameters['apiAppTeamsTeamIdEventsPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetAvailableSportEvents200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create a sport event in team feed
+     * Get available sport events for team\'s sport
      */
-    async apiAppTeamsTeamIdEventsPost(requestParameters: ApiAppTeamsTeamIdEventsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
-        const response = await this.apiAppTeamsTeamIdEventsPostRaw(requestParameters, initOverrides);
+    async getAvailableSportEvents(requestParameters: GetAvailableSportEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAvailableSportEvents200Response> {
+        const response = await this.getAvailableSportEventsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 

package/apis/TeamFeedApi.ts

@@ -15,59 +15,59 @@
 
 import * as runtime from '../runtime';
 import type {
-  ApiAppTeamsTeamIdFeedFeedItemIdPatchRequest,
-  ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest,
-  ApiAppTeamsTeamIdFeedSummaryGet200Response,
   CreateTeamFeedRequest,
+  EditTeamFeedPostRequest,
+  GetTeamFeedSummary200Response,
   TeamFeedItemResponse,
   TeamFeedListResponse,
+  UpdateFeedItemReactionsRequest,
 } from '../models/index';
 import {
-    ApiAppTeamsTeamIdFeedFeedItemIdPatchRequestFromJSON,
-    ApiAppTeamsTeamIdFeedFeedItemIdPatchRequestToJSON,
-    ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequestFromJSON,
-    ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequestToJSON,
-    ApiAppTeamsTeamIdFeedSummaryGet200ResponseFromJSON,
-    ApiAppTeamsTeamIdFeedSummaryGet200ResponseToJSON,
     CreateTeamFeedRequestFromJSON,
     CreateTeamFeedRequestToJSON,
+    EditTeamFeedPostRequestFromJSON,
+    EditTeamFeedPostRequestToJSON,
+    GetTeamFeedSummary200ResponseFromJSON,
+    GetTeamFeedSummary200ResponseToJSON,
     TeamFeedItemResponseFromJSON,
     TeamFeedItemResponseToJSON,
     TeamFeedListResponseFromJSON,
     TeamFeedListResponseToJSON,
+    UpdateFeedItemReactionsRequestFromJSON,
+    UpdateFeedItemReactionsRequestToJSON,
 } from '../models/index';
 
-export interface ApiAppTeamsTeamIdFeedFeedItemIdDeleteRequest {
+export interface CreateTeamFeedPostRequest {
     teamId: string;
-    feedItemId: string;
+    createTeamFeedRequest: CreateTeamFeedRequest;
 }
 
-export interface ApiAppTeamsTeamIdFeedFeedItemIdPatchOperationRequest {
+export interface DeleteTeamFeedPostRequest {
     teamId: string;
     feedItemId: string;
-    apiAppTeamsTeamIdFeedFeedItemIdPatchRequest: ApiAppTeamsTeamIdFeedFeedItemIdPatchRequest;
 }
 
-export interface ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchOperationRequest {
+export interface EditTeamFeedPostOperationRequest {
     teamId: string;
     feedItemId: string;
-    apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest: ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest;
+    editTeamFeedPostRequest: EditTeamFeedPostRequest;
 }
 
-export interface ApiAppTeamsTeamIdFeedGetRequest {
+export interface GetTeamFeedRequest {
     teamId: string;
     limit?: number;
     cursor?: string;
     authorId?: string;
 }
 
-export interface ApiAppTeamsTeamIdFeedPostRequest {
+export interface GetTeamFeedSummaryRequest {
     teamId: string;
-    createTeamFeedRequest: CreateTeamFeedRequest;
 }
 
-export interface ApiAppTeamsTeamIdFeedSummaryGetRequest {
+export interface UpdateFeedItemReactionsOperationRequest {
     teamId: string;
+    feedItemId: string;
+    updateFeedItemReactionsRequest: UpdateFeedItemReactionsRequest;
 }
 
 /**
@@ -76,20 +76,20 @@ export interface ApiAppTeamsTeamIdFeedSummaryGetRequest {
 export class TeamFeedApi extends runtime.BaseAPI {
 
     /**
-     * Delete a team feed post (author only)
+     * Create a new team feed post
      */
-    async apiAppTeamsTeamIdFeedFeedItemIdDeleteRaw(requestParameters: ApiAppTeamsTeamIdFeedFeedItemIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async createTeamFeedPostRaw(requestParameters: CreateTeamFeedPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdDelete().'
+                'Required parameter "teamId" was null or undefined when calling createTeamFeedPost().'
             );
         }
 
-        if (requestParameters['feedItemId'] == null) {
+        if (requestParameters['createTeamFeedRequest'] == null) {
             throw new runtime.RequiredError(
-                'feedItemId',
-                'Required parameter "feedItemId" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdDelete().'
+                'createTeamFeedRequest',
+                'Required parameter "createTeamFeedRequest" was null or undefined when calling createTeamFeedPost().'
             );
         }
 
@@ -97,6 +97,8 @@ export class TeamFeedApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -106,44 +108,39 @@ export class TeamFeedApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/api/app/teams/{teamId}/feed/{feedItemId}`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))).replace(`{${"feedItemId"}}`, encodeURIComponent(String(requestParameters['feedItemId']))),
-            method: 'DELETE',
+            path: `/api/app/teams/{teamId}/feed`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))),
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: CreateTeamFeedRequestToJSON(requestParameters['createTeamFeedRequest']),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
     }
 
     /**
-     * Delete a team feed post (author only)
+     * Create a new team feed post
      */
-    async apiAppTeamsTeamIdFeedFeedItemIdDelete(requestParameters: ApiAppTeamsTeamIdFeedFeedItemIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiAppTeamsTeamIdFeedFeedItemIdDeleteRaw(requestParameters, initOverrides);
+    async createTeamFeedPost(requestParameters: CreateTeamFeedPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
+        const response = await this.createTeamFeedPostRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Edit a team feed post (user posts only)
+     * Delete a team feed post (author only)
      */
-    async apiAppTeamsTeamIdFeedFeedItemIdPatchRaw(requestParameters: ApiAppTeamsTeamIdFeedFeedItemIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
+    async deleteTeamFeedPostRaw(requestParameters: DeleteTeamFeedPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdPatch().'
+                'Required parameter "teamId" was null or undefined when calling deleteTeamFeedPost().'
             );
         }
 
         if (requestParameters['feedItemId'] == null) {
             throw new runtime.RequiredError(
                 'feedItemId',
-                'Required parameter "feedItemId" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdPatch().'
-            );
-        }
-
-        if (requestParameters['apiAppTeamsTeamIdFeedFeedItemIdPatchRequest'] == null) {
-            throw new runtime.RequiredError(
-                'apiAppTeamsTeamIdFeedFeedItemIdPatchRequest',
-                'Required parameter "apiAppTeamsTeamIdFeedFeedItemIdPatchRequest" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdPatch().'
+                'Required parameter "feedItemId" was null or undefined when calling deleteTeamFeedPost().'
             );
         }
 
@@ -151,8 +148,6 @@ export class TeamFeedApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -163,45 +158,43 @@ export class TeamFeedApi extends runtime.BaseAPI {
         }
         const response = await this.request({
             path: `/api/app/teams/{teamId}/feed/{feedItemId}`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))).replace(`{${"feedItemId"}}`, encodeURIComponent(String(requestParameters['feedItemId']))),
-            method: 'PATCH',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiAppTeamsTeamIdFeedFeedItemIdPatchRequestToJSON(requestParameters['apiAppTeamsTeamIdFeedFeedItemIdPatchRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Edit a team feed post (user posts only)
+     * Delete a team feed post (author only)
      */
-    async apiAppTeamsTeamIdFeedFeedItemIdPatch(requestParameters: ApiAppTeamsTeamIdFeedFeedItemIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
-        const response = await this.apiAppTeamsTeamIdFeedFeedItemIdPatchRaw(requestParameters, initOverrides);
-        return await response.value();
+    async deleteTeamFeedPost(requestParameters: DeleteTeamFeedPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteTeamFeedPostRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Update reactions on a feed item
+     * Edit a team feed post (user posts only)
      */
-    async apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRaw(requestParameters: ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
+    async editTeamFeedPostRaw(requestParameters: EditTeamFeedPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdReactionsPatch().'
+                'Required parameter "teamId" was null or undefined when calling editTeamFeedPost().'
             );
         }
 
         if (requestParameters['feedItemId'] == null) {
             throw new runtime.RequiredError(
                 'feedItemId',
-                'Required parameter "feedItemId" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdReactionsPatch().'
+                'Required parameter "feedItemId" was null or undefined when calling editTeamFeedPost().'
             );
         }
 
-        if (requestParameters['apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest'] == null) {
+        if (requestParameters['editTeamFeedPostRequest'] == null) {
             throw new runtime.RequiredError(
-                'apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest',
-                'Required parameter "apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest" was null or undefined when calling apiAppTeamsTeamIdFeedFeedItemIdReactionsPatch().'
+                'editTeamFeedPostRequest',
+                'Required parameter "editTeamFeedPostRequest" was null or undefined when calling editTeamFeedPost().'
             );
         }
 
@@ -220,32 +213,32 @@ export class TeamFeedApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/api/app/teams/{teamId}/feed/{feedItemId}/reactions`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))).replace(`{${"feedItemId"}}`, encodeURIComponent(String(requestParameters['feedItemId']))),
+            path: `/api/app/teams/{teamId}/feed/{feedItemId}`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))).replace(`{${"feedItemId"}}`, encodeURIComponent(String(requestParameters['feedItemId']))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequestToJSON(requestParameters['apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRequest']),
+            body: EditTeamFeedPostRequestToJSON(requestParameters['editTeamFeedPostRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
     }
 
     /**
-     * Update reactions on a feed item
+     * Edit a team feed post (user posts only)
      */
-    async apiAppTeamsTeamIdFeedFeedItemIdReactionsPatch(requestParameters: ApiAppTeamsTeamIdFeedFeedItemIdReactionsPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
-        const response = await this.apiAppTeamsTeamIdFeedFeedItemIdReactionsPatchRaw(requestParameters, initOverrides);
+    async editTeamFeedPost(requestParameters: EditTeamFeedPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
+        const response = await this.editTeamFeedPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get team feed with cursor-based pagination (infinite scroll)
      */
-    async apiAppTeamsTeamIdFeedGetRaw(requestParameters: ApiAppTeamsTeamIdFeedGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedListResponse>> {
+    async getTeamFeedRaw(requestParameters: GetTeamFeedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedListResponse>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdFeedGet().'
+                'Required parameter "teamId" was null or undefined when calling getTeamFeed().'
             );
         }
 
@@ -286,26 +279,20 @@ export class TeamFeedApi extends runtime.BaseAPI {
     /**
      * Get team feed with cursor-based pagination (infinite scroll)
      */
-    async apiAppTeamsTeamIdFeedGet(requestParameters: ApiAppTeamsTeamIdFeedGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedListResponse> {
-        const response = await this.apiAppTeamsTeamIdFeedGetRaw(requestParameters, initOverrides);
+    async getTeamFeed(requestParameters: GetTeamFeedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedListResponse> {
+        const response = await this.getTeamFeedRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a new team feed post
+     * Returns a fun, engaging summary of the last 10 team messages using Gemini AI (cached for 6 hours)
+     * Get AI-generated summary of recent team feed activity
      */
-    async apiAppTeamsTeamIdFeedPostRaw(requestParameters: ApiAppTeamsTeamIdFeedPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
+    async getTeamFeedSummaryRaw(requestParameters: GetTeamFeedSummaryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetTeamFeedSummary200Response>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdFeedPost().'
-            );
-        }
-
-        if (requestParameters['createTeamFeedRequest'] == null) {
-            throw new runtime.RequiredError(
-                'createTeamFeedRequest',
-                'Required parameter "createTeamFeedRequest" was null or undefined when calling apiAppTeamsTeamIdFeedPost().'
+                'Required parameter "teamId" was null or undefined when calling getTeamFeedSummary().'
             );
         }
 
@@ -313,8 +300,6 @@ export class TeamFeedApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -324,33 +309,46 @@ export class TeamFeedApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/api/app/teams/{teamId}/feed`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))),
-            method: 'POST',
+            path: `/api/app/teams/{teamId}/feed/summary`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: CreateTeamFeedRequestToJSON(requestParameters['createTeamFeedRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetTeamFeedSummary200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create a new team feed post
+     * Returns a fun, engaging summary of the last 10 team messages using Gemini AI (cached for 6 hours)
+     * Get AI-generated summary of recent team feed activity
      */
-    async apiAppTeamsTeamIdFeedPost(requestParameters: ApiAppTeamsTeamIdFeedPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
-        const response = await this.apiAppTeamsTeamIdFeedPostRaw(requestParameters, initOverrides);
+    async getTeamFeedSummary(requestParameters: GetTeamFeedSummaryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetTeamFeedSummary200Response> {
+        const response = await this.getTeamFeedSummaryRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Returns a fun, engaging summary of the last 10 team messages using Gemini AI (cached for 6 hours)
-     * Get AI-generated summary of recent team feed activity
+     * Update reactions on a feed item
      */
-    async apiAppTeamsTeamIdFeedSummaryGetRaw(requestParameters: ApiAppTeamsTeamIdFeedSummaryGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiAppTeamsTeamIdFeedSummaryGet200Response>> {
+    async updateFeedItemReactionsRaw(requestParameters: UpdateFeedItemReactionsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TeamFeedItemResponse>> {
         if (requestParameters['teamId'] == null) {
             throw new runtime.RequiredError(
                 'teamId',
-                'Required parameter "teamId" was null or undefined when calling apiAppTeamsTeamIdFeedSummaryGet().'
+                'Required parameter "teamId" was null or undefined when calling updateFeedItemReactions().'
+            );
+        }
+
+        if (requestParameters['feedItemId'] == null) {
+            throw new runtime.RequiredError(
+                'feedItemId',
+                'Required parameter "feedItemId" was null or undefined when calling updateFeedItemReactions().'
+            );
+        }
+
+        if (requestParameters['updateFeedItemReactionsRequest'] == null) {
+            throw new runtime.RequiredError(
+                'updateFeedItemReactionsRequest',
+                'Required parameter "updateFeedItemReactionsRequest" was null or undefined when calling updateFeedItemReactions().'
             );
         }
 
@@ -358,6 +356,8 @@ export class TeamFeedApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -367,21 +367,21 @@ export class TeamFeedApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/api/app/teams/{teamId}/feed/summary`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))),
-            method: 'GET',
+            path: `/api/app/teams/{teamId}/feed/{feedItemId}/reactions`.replace(`{${"teamId"}}`, encodeURIComponent(String(requestParameters['teamId']))).replace(`{${"feedItemId"}}`, encodeURIComponent(String(requestParameters['feedItemId']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: UpdateFeedItemReactionsRequestToJSON(requestParameters['updateFeedItemReactionsRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiAppTeamsTeamIdFeedSummaryGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => TeamFeedItemResponseFromJSON(jsonValue));
     }
 
     /**
-     * Returns a fun, engaging summary of the last 10 team messages using Gemini AI (cached for 6 hours)
-     * Get AI-generated summary of recent team feed activity
+     * Update reactions on a feed item
      */
-    async apiAppTeamsTeamIdFeedSummaryGet(requestParameters: ApiAppTeamsTeamIdFeedSummaryGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiAppTeamsTeamIdFeedSummaryGet200Response> {
-        const response = await this.apiAppTeamsTeamIdFeedSummaryGetRaw(requestParameters, initOverrides);
+    async updateFeedItemReactions(requestParameters: UpdateFeedItemReactionsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TeamFeedItemResponse> {
+        const response = await this.updateFeedItemReactionsRaw(requestParameters, initOverrides);
         return await response.value();
     }