@stream-io/feeds-client 0.3.16 → 0.3.17

package/src/feeds-client/feeds-client.ts

@@ -14,13 +14,15 @@ import type {
   FileUploadRequest,
   FollowBatchRequest,
   FollowRequest,
+  FollowResponse,
   GetOrCreateFeedRequest,
   ImageUploadRequest,
-  OwnCapabilitiesBatchRequest,
+  OwnBatchRequest,
   PollResponse,
   PollVotesResponse,
   QueryFeedsRequest,
   QueryPollVotesRequest,
+  UnfollowBatchRequest,
   UpdateActivityRequest,
   UpdateActivityResponse,
   UpdateCommentRequest,
@@ -93,7 +95,6 @@ import { getFeed } from '../activity-with-state-updates/get-feed';
 
 export type FeedsClientState = {
   connected_user: ConnectedUser | undefined;
-  is_anonymous: boolean;
   is_ws_connection_healthy: boolean;
   own_capabilities_by_fid: Record<string, FeedResponse['own_capabilities']>;
 };
@@ -137,7 +138,6 @@ export class FeedsClient extends FeedsApi {
     super(apiClient);
     this.state = new StateStore<FeedsClientState>({
       connected_user: undefined,
-      is_anonymous: false,
       is_ws_connection_healthy: false,
       own_capabilities_by_fid: {},
     });
@@ -286,7 +286,7 @@ export class FeedsClient extends FeedsApi {
       cancelTimer: cancel,
     } = throttle<GetBatchedOwnCapabilitiesThrottledCallback>(
       (feeds, callback) => {
-        this.ownCapabilitiesBatch({
+        this.ownBatch({
           feeds,
         }).catch((error) => {
           this.eventDispatcher.dispatch({
@@ -393,25 +393,7 @@ export class FeedsClient extends FeedsApi {
     this.state.partialNext({ own_capabilities_by_fid: ownCapabilitiesCache });
   }
 
-  connectAnonymous = () => {
-    this.connectionIdManager.resolveConnectionidPromise();
-    this.tokenManager.setTokenOrProvider(undefined);
-    this.setGetBatchOwnCapabilitiesThrottlingInterval(
-      this.query_batch_own_capabilties_throttling_interval,
-    );
-    this.state.partialNext({
-      connected_user: undefined,
-      is_anonymous: true,
-      is_ws_connection_healthy: false,
-    });
-
-    return Promise.resolve();
-  };
-
-  connectUser = async (
-    user: UserRequest | { id: '!anon' },
-    tokenProvider?: TokenOrProvider,
-  ) => {
+  connectUser = async (user: UserRequest, tokenProvider?: TokenOrProvider) => {
     if (
       this.state.getLatestValue().connected_user !== undefined ||
       this.wsConnection
@@ -745,12 +727,12 @@ export class FeedsClient extends FeedsApi {
     };
   }
 
-  async ownCapabilitiesBatch(request: OwnCapabilitiesBatchRequest) {
-    const response = await super.ownCapabilitiesBatch(request);
-    const feedResponses = Object.entries(response.capabilities).map(
-      ([feed, own_capabilities]) => ({
+  async ownBatch(request: OwnBatchRequest) {
+    const response = await super.ownBatch(request);
+    const feedResponses = Object.entries(response.data).map(
+      ([feed, ownFields]) => ({
         feed,
-        own_capabilities,
+        own_capabilities: ownFields.own_capabilities,
       }),
     );
     this.hydrateCapabilitiesCache(feedResponses);
@@ -784,36 +766,41 @@ export class FeedsClient extends FeedsApi {
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
   async follow(request: FollowRequest) {
     const response = await super.follow(request);
-
-    [
-      response.follow.source_feed.feed,
-      response.follow.target_feed.feed,
-    ].forEach((fid) => {
-      const feeds = this.findAllActiveFeedsByFid(fid);
-      feeds.forEach((f) => handleFollowCreated.bind(f)(response, false));
-    });
+    this.updateStateFromFollows([response.follow]);
 
     return response;
   }
 
+  /**
+   * @deprecated Use getOrCreateFollows instead
+   * @param request
+   * @returns
+   */
   async followBatch(request: FollowBatchRequest) {
     const response = await super.followBatch(request);
+    this.updateStateFromFollows(response.follows);
 
-    response.follows.forEach((follow) => {
-      const feeds = this.findAllActiveFeedsByFid(follow.source_feed.feed);
-      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
-    });
+    return response;
+  }
+
+  async getOrCreateFollows(request: FollowBatchRequest) {
+    const response = await super.getOrCreateFollows(request);
+
+    this.updateStateFromFollows(response.created);
 
     return response;
   }
 
-  async unfollow(request: FollowRequest) {
+  async unfollow(request: { source: string; target: string }) {
     const response = await super.unfollow(request);
+    this.updateStateFromUnfollows([response.follow]);
 
-    [request.source, request.target].forEach((fid) => {
-      const feeds = this.findAllActiveFeedsByFid(fid);
-      feeds.forEach((f) => handleFollowDeleted.bind(f)(response, false));
-    });
+    return response;
+  }
+
+  async getOrCreateUnfollows(request: UnfollowBatchRequest) {
+    const response = await super.getOrCreateUnfollows(request);
+    this.updateStateFromUnfollows(response.follows);
 
     return response;
   }
@@ -942,4 +929,24 @@ export class FeedsClient extends FeedsApi {
         .map((a) => getFeed.call(a)!),
     ];
   }
+
+  private updateStateFromFollows(follows: FollowResponse[]) {
+    follows.forEach((follow) => {
+      const feeds = [
+        ...this.findAllActiveFeedsByFid(follow.source_feed.feed),
+        ...this.findAllActiveFeedsByFid(follow.target_feed.feed),
+      ];
+      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
+    });
+  }
+
+  private updateStateFromUnfollows(follows: FollowResponse[]) {
+    follows.forEach((follow) => {
+      const feeds = [
+        ...this.findAllActiveFeedsByFid(follow.source_feed.feed),
+        ...this.findAllActiveFeedsByFid(follow.target_feed.feed),
+      ];
+      feeds.forEach((f) => handleFollowDeleted.bind(f)({ follow }, false));
+    });
+  }
 }

package/src/gen/feeds/FeedsApi.ts

@@ -62,8 +62,8 @@ import type {
   ListBlockListResponse,
   ListDevicesResponse,
   MarkActivityRequest,
-  OwnCapabilitiesBatchRequest,
-  OwnCapabilitiesBatchResponse,
+  OwnBatchRequest,
+  OwnBatchResponse,
   PinActivityRequest,
   PinActivityResponse,
   PollOptionResponse,
@@ -104,6 +104,8 @@ import type {
   SingleFollowResponse,
   UnblockUsersRequest,
   UnblockUsersResponse,
+  UnfollowBatchRequest,
+  UnfollowBatchResponse,
   UnfollowResponse,
   UnpinActivityResponse,
   UpdateActivityPartialRequest,
@@ -979,14 +981,14 @@ export class FeedsApi {
   }
 
   async addComment(
-    request: AddCommentRequest,
+    request?: AddCommentRequest,
   ): Promise<StreamResponse<AddCommentResponse>> {
     const body = {
-      object_id: request?.object_id,
-      object_type: request?.object_type,
       comment: request?.comment,
       create_notification_activity: request?.create_notification_activity,
       id: request?.id,
+      object_id: request?.object_id,
+      object_type: request?.object_type,
       parent_id: request?.parent_id,
       skip_enrich_url: request?.skip_enrich_url,
       skip_push: request?.skip_push,
@@ -1621,28 +1623,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async ownCapabilitiesBatch(
-    request: OwnCapabilitiesBatchRequest & { connection_id?: string },
-  ): Promise<StreamResponse<OwnCapabilitiesBatchResponse>> {
+  async ownBatch(
+    request: OwnBatchRequest & { connection_id?: string },
+  ): Promise<StreamResponse<OwnBatchResponse>> {
     const queryParams = {
       connection_id: request?.connection_id,
     };
     const body = {
       feeds: request?.feeds,
+      fields: request?.fields,
     };
 
     const response = await this.apiClient.sendRequest<
-      StreamResponse<OwnCapabilitiesBatchResponse>
+      StreamResponse<OwnBatchResponse>
     >(
       'POST',
-      '/api/v2/feeds/feeds/own_capabilities/batch',
+      '/api/v2/feeds/feeds/own/batch',
       undefined,
       queryParams,
       body,
       'application/json',
     );
 
-    decoders.OwnCapabilitiesBatchResponse?.(response.body);
+    decoders.OwnBatchResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
   }
@@ -1783,6 +1786,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async getOrCreateFollows(
+    request: FollowBatchRequest,
+  ): Promise<StreamResponse<FollowBatchResponse>> {
+    const body = {
+      follows: request?.follows,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<FollowBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows/batch/upsert',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.FollowBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryFollows(
     request?: QueryFollowsRequest,
   ): Promise<StreamResponse<QueryFollowsResponse>> {
@@ -1857,6 +1883,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async getOrCreateUnfollows(
+    request: UnfollowBatchRequest,
+  ): Promise<StreamResponse<UnfollowBatchResponse>> {
+    const body = {
+      follows: request?.follows,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnfollowBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/unfollow/batch/upsert',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UnfollowBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async createGuest(
     request: CreateGuestRequest,
   ): Promise<StreamResponse<CreateGuestResponse>> {

package/src/gen/model-decoders/decoders.ts

@@ -68,8 +68,6 @@ decoders.ActivityAddedEvent = (input?: Record<string, any>) => {
     activity: { type: 'ActivityResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -81,8 +79,6 @@ decoders.ActivityDeletedEvent = (input?: Record<string, any>) => {
     activity: { type: 'ActivityResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -92,8 +88,6 @@ decoders.ActivityFeedbackEvent = (input?: Record<string, any>) => {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -103,8 +97,6 @@ decoders.ActivityMarkEvent = (input?: Record<string, any>) => {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -129,8 +121,6 @@ decoders.ActivityPinnedEvent = (input?: Record<string, any>) => {
     pinned_activity: { type: 'PinActivityResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -144,8 +134,6 @@ decoders.ActivityReactionAddedEvent = (input?: Record<string, any>) => {
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -159,8 +147,6 @@ decoders.ActivityReactionDeletedEvent = (input?: Record<string, any>) => {
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -174,8 +160,6 @@ decoders.ActivityReactionUpdatedEvent = (input?: Record<string, any>) => {
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -187,8 +171,6 @@ decoders.ActivityRemovedFromFeedEvent = (input?: Record<string, any>) => {
     activity: { type: 'ActivityResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -237,8 +219,6 @@ decoders.ActivityUnpinnedEvent = (input?: Record<string, any>) => {
     pinned_activity: { type: 'PinActivityResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -250,8 +230,6 @@ decoders.ActivityUpdatedEvent = (input?: Record<string, any>) => {
     activity: { type: 'ActivityResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -371,8 +349,6 @@ decoders.BookmarkAddedEvent = (input?: Record<string, any>) => {
     bookmark: { type: 'BookmarkResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -384,8 +360,6 @@ decoders.BookmarkDeletedEvent = (input?: Record<string, any>) => {
     bookmark: { type: 'BookmarkResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -397,8 +371,6 @@ decoders.BookmarkFolderDeletedEvent = (input?: Record<string, any>) => {
     bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -409,7 +381,7 @@ decoders.BookmarkFolderResponse = (input?: Record<string, any>) => {
 
     updated_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponseCommonFields', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -421,8 +393,6 @@ decoders.BookmarkFolderUpdatedEvent = (input?: Record<string, any>) => {
     bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -435,7 +405,7 @@ decoders.BookmarkResponse = (input?: Record<string, any>) => {
 
     activity: { type: 'ActivityResponse', isSingle: true },
 
-    user: { type: 'UserResponseCommonFields', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
 
     folder: { type: 'BookmarkFolderResponse', isSingle: true },
   };
@@ -449,8 +419,6 @@ decoders.BookmarkUpdatedEvent = (input?: Record<string, any>) => {
     bookmark: { type: 'BookmarkResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -679,8 +647,6 @@ decoders.CommentAddedEvent = (input?: Record<string, any>) => {
     comment: { type: 'CommentResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -692,8 +658,6 @@ decoders.CommentDeletedEvent = (input?: Record<string, any>) => {
     comment: { type: 'CommentResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -709,8 +673,6 @@ decoders.CommentReactionAddedEvent = (input?: Record<string, any>) => {
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -739,8 +701,6 @@ decoders.CommentReactionUpdatedEvent = (input?: Record<string, any>) => {
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -773,8 +733,6 @@ decoders.CommentUpdatedEvent = (input?: Record<string, any>) => {
     comment: { type: 'CommentResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -927,8 +885,6 @@ decoders.FeedCreatedEvent = (input?: Record<string, any>) => {
 
     feed: { type: 'FeedResponse', isSingle: true },
 
-    user: { type: 'UserResponseCommonFields', isSingle: true },
-
     received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
@@ -939,8 +895,6 @@ decoders.FeedDeletedEvent = (input?: Record<string, any>) => {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -950,8 +904,6 @@ decoders.FeedGroupChangedEvent = (input?: Record<string, any>) => {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -972,8 +924,6 @@ decoders.FeedMemberAddedEvent = (input?: Record<string, any>) => {
     member: { type: 'FeedMemberResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -983,8 +933,6 @@ decoders.FeedMemberRemovedEvent = (input?: Record<string, any>) => {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1013,8 +961,15 @@ decoders.FeedMemberUpdatedEvent = (input?: Record<string, any>) => {
     member: { type: 'FeedMemberResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.FeedOwnData = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    own_follows: { type: 'FollowResponse', isSingle: false },
 
-    user: { type: 'UserResponseCommonFields', isSingle: true },
+    own_membership: { type: 'FeedMemberResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1060,8 +1015,6 @@ decoders.FeedUpdatedEvent = (input?: Record<string, any>) => {
     feed: { type: 'FeedResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1079,6 +1032,8 @@ decoders.FeedsReactionResponse = (input?: Record<string, any>) => {
 
 decoders.FollowBatchResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
+    created: { type: 'FollowResponse', isSingle: false },
+
     follows: { type: 'FollowResponse', isSingle: false },
   };
   return decode(typeMappings, input);
@@ -1434,8 +1389,6 @@ decoders.NotificationFeedUpdatedEvent = (input?: Record<string, any>) => {
     },
 
     notification_status: { type: 'NotificationStatusResponse', isSingle: true },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1449,6 +1402,13 @@ decoders.NotificationStatusResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.OwnBatchResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    data: { type: 'FeedOwnData', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.OwnUser = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1899,8 +1859,6 @@ decoders.StoriesFeedUpdatedEvent = (input?: Record<string, any>) => {
       type: 'AggregatedActivityResponse',
       isSingle: false,
     },
-
-    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1935,6 +1893,13 @@ decoders.ThreadedCommentResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UnfollowBatchResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follows: { type: 'FollowResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UnfollowResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     follow: { type: 'FollowResponse', isSingle: true },
@@ -2159,23 +2124,6 @@ decoders.UserResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.UserResponseCommonFields = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    deactivated_at: { type: 'DatetimeType', isSingle: true },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_active: { type: 'DatetimeType', isSingle: true },
-
-    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.UserUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },