@stream-io/feeds-client 0.2.17 → 0.2.19

package/dist/{index-BZL77zNq.mjs → feeds-client-CFadXO-B.mjs}

@@ -871,8 +871,9 @@ decoders.MessageResponse = (input) => {
 decoders.ModerationCustomActionEvent = (input) => {
   const typeMappings = {
     created_at: { type: "DatetimeType", isSingle: true },
-    message: { type: "Message", isSingle: true },
-    user: { type: "User", isSingle: true }
+    review_queue_item: { type: "ReviewQueueItemResponse", isSingle: true },
+    received_at: { type: "DatetimeType", isSingle: true },
+    message: { type: "MessageResponse", isSingle: true }
   };
   return decode(typeMappings, input);
 };
@@ -895,8 +896,9 @@ decoders.ModerationFlaggedEvent = (input) => {
 decoders.ModerationMarkReviewedEvent = (input) => {
   const typeMappings = {
     created_at: { type: "DatetimeType", isSingle: true },
-    message: { type: "Message", isSingle: true },
-    user: { type: "User", isSingle: true }
+    item: { type: "ReviewQueueItemResponse", isSingle: true },
+    received_at: { type: "DatetimeType", isSingle: true },
+    message: { type: "MessageResponse", isSingle: true }
   };
   return decode(typeMappings, input);
 };
@@ -1250,6 +1252,7 @@ decoders.StoriesFeedUpdatedEvent = (input) => {
   const typeMappings = {
     created_at: { type: "DatetimeType", isSingle: true },
     received_at: { type: "DatetimeType", isSingle: true },
+    activities: { type: "ActivityResponse", isSingle: false },
     aggregated_activities: {
       type: "AggregatedActivityResponse",
       isSingle: false
@@ -1471,6 +1474,8 @@ class FeedsApi {
     const body = {
       name: request?.name,
       words: request?.words,
+      is_leet_check_enabled: request?.is_leet_check_enabled,
+      is_plural_check_enabled: request?.is_plural_check_enabled,
       team: request?.team,
       type: request?.type
     };
@@ -1506,6 +1511,8 @@ class FeedsApi {
       name: request?.name
     };
     const body = {
+      is_leet_check_enabled: request?.is_leet_check_enabled,
+      is_plural_check_enabled: request?.is_plural_check_enabled,
       team: request?.team,
       words: request?.words
     };
@@ -1702,7 +1709,8 @@ class FeedsApi {
       mute_user: request?.mute_user,
       reason: request?.reason,
       report: request?.report,
-      show_less: request?.show_less
+      show_less: request?.show_less,
+      show_more: request?.show_more
     };
     const response = await this.apiClient.sendRequest(
       "POST",
@@ -3722,7 +3730,7 @@ const getRateLimitFromResponseHeader = (response_headers) => {
   };
   return result;
 };
-const version = "0.2.17";
+const version = "0.2.19";
 class ApiClient {
   constructor(apiKey, tokenManager, connectionIdManager, options) {
     this.apiKey = apiKey;
@@ -5288,19 +5296,16 @@ function handleBookmarkUpdated(event) {
   }
 }
 function addActivitiesToState(newActivities, activities, position) {
-  let result;
   if (activities === void 0) {
-    activities = [];
-    result = {
-      changed: true,
-      activities
-    };
-  } else {
-    result = {
+    return {
       changed: false,
-      activities
+      activities: []
     };
   }
+  let result = {
+    changed: false,
+    activities
+  };
   const newActivitiesDeduplicated = [];
   newActivities.forEach((newActivityResponse) => {
     if (!this.hasActivity(newActivityResponse.id)) {
@@ -5322,10 +5327,15 @@ function handleActivityAdded(event) {
   const result = addActivitiesToState.bind(this)(
     [event.activity],
     currentActivities,
-    "start"
+    this.currentState.addNewActivitiesTo
   );
   if (result.changed) {
-    this.client.hydratePollCache([event.activity]);
+    const activity = event.activity;
+    this.client.hydratePollCache([activity]);
+    const currentFeed = activity.current_feed;
+    if (currentFeed) {
+      this.client.hydrateCapabilitiesCache([currentFeed]);
+    }
     this.state.partialNext({ activities: result.activities });
   }
 }
@@ -5378,22 +5388,23 @@ function handleActivityRemovedFromFeed(event) {
     }
   }
 }
-const sharedUpdateActivity$3 = ({
+const updateActivity = ({
   currentActivity,
-  event
+  newActivtiy
 }) => {
   return {
-    ...event.activity,
+    ...newActivtiy,
     own_reactions: currentActivity.own_reactions,
     own_bookmarks: currentActivity.own_bookmarks
   };
 };
+const sharedUpdateActivity$3 = updateActivity;
 const updateActivityInState = (event, activities) => updateEntityInArray({
   entities: activities,
   matcher: (activity) => activity.id === event.activity.id,
   updater: (matchedActivity) => sharedUpdateActivity$3({
     currentActivity: matchedActivity,
-    event
+    newActivtiy: event.activity
   })
 });
 const updatePinnedActivityInState = (event, pinnedActivities) => updateEntityInArray({
@@ -5402,7 +5413,7 @@ const updatePinnedActivityInState = (event, pinnedActivities) => updateEntityInA
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$3({
       currentActivity: matchedPinnedActivity.activity,
-      event
+      newActivtiy: event.activity
     });
     if (newActivity === matchedPinnedActivity.activity) {
       return matchedPinnedActivity;
@@ -5436,6 +5447,9 @@ function handleActivityUpdated(payload, fromWs) {
   ];
   if (result1?.changed || result2.changed) {
     this.client.hydratePollCache([payload.activity]);
+    if (payload.activity.current_feed) {
+      this.client.hydrateCapabilitiesCache([payload.activity.current_feed]);
+    }
     this.state.partialNext({
       activities: result1?.changed ? result1.entities : currentActivities,
       pinned_activities: result2.entities
@@ -5747,36 +5761,55 @@ const addAggregatedActivitiesToState = (newAggregatedActivities, aggregatedActiv
   if (newAggregatedActivities.length === 0) {
     result = {
       changed: false,
-      aggregated_activities: []
+      aggregated_activities: aggregatedActivities ?? []
     };
   } else {
     result = {
       changed: true,
       aggregated_activities: []
     };
-  }
-  switch (position) {
-    case "start":
-      result.aggregated_activities = uniqueArrayMerge(
-        newAggregatedActivities,
-        aggregatedActivities ?? [],
-        (a) => a.group
-      );
-      break;
-    case "end":
-      result.aggregated_activities = uniqueArrayMerge(
-        aggregatedActivities ?? [],
-        newAggregatedActivities,
-        (a) => a.group
+    newAggregatedActivities.forEach((newAggregatedActivity) => {
+      const existingAggregatedActivity = aggregatedActivities?.find(
+        (a) => a.group === newAggregatedActivity.group
       );
-      break;
-    case "replace":
-      result.aggregated_activities = replaceUniqueArrayMerge(
-        aggregatedActivities ?? [],
-        newAggregatedActivities,
-        (a) => a.group
-      );
-      break;
+      if (existingAggregatedActivity) {
+        for (let i = 0; i < newAggregatedActivity.activities.length; i++) {
+          const activity = newAggregatedActivity.activities[i];
+          const existingActivity = existingAggregatedActivity.activities.find(
+            (a) => a.id === activity.id
+          );
+          if (existingActivity) {
+            newAggregatedActivity.activities[i] = updateActivity({
+              currentActivity: existingActivity,
+              newActivtiy: activity
+            });
+          }
+        }
+      }
+    });
+    switch (position) {
+      case "start":
+        result.aggregated_activities = uniqueArrayMerge(
+          newAggregatedActivities,
+          aggregatedActivities ?? [],
+          (a) => a.group
+        );
+        break;
+      case "end":
+        result.aggregated_activities = uniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group
+        );
+        break;
+      case "replace":
+        result.aggregated_activities = replaceUniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group
+        );
+        break;
+    }
   }
   return result;
 };
@@ -5802,7 +5835,7 @@ const updateNotificationStatus = (newNotificationStatus, currentNotificationStat
 };
 const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, currentNotificationStatus) => {
   const updates = {};
-  if (event.notification_status && currentNotificationStatus) {
+  if (event.notification_status) {
     const notificationStatusResult = updateNotificationStatus(
       event.notification_status,
       currentNotificationStatus
@@ -5844,18 +5877,65 @@ function handleNotificationFeedUpdated(event) {
     });
   }
 }
-function updateStoriesFeedFromEvent(aggregatedActivities, event) {
-  if (!aggregatedActivities) {
+const updateActivities = (activitiesToUpsert, currentActivities) => {
+  if (!activitiesToUpsert || activitiesToUpsert.length === 0 || !currentActivities) {
+    return {
+      changed: false,
+      activities: currentActivities ?? []
+    };
+  }
+  const result = [];
+  for (let i = 0; i < currentActivities.length; i++) {
+    const activity = currentActivities[i];
+    const updatedActivity = activitiesToUpsert.find(
+      (a) => a.id === activity.id
+    );
+    if (updatedActivity) {
+      result.push(
+        updateActivity({
+          currentActivity: activity,
+          newActivtiy: updatedActivity
+        })
+      );
+    } else {
+      result.push(activity);
+    }
+  }
+  return {
+    changed: true,
+    activities: result
+  };
+};
+function updateStoriesFeedFromEvent(aggregatedActivities, activities, event) {
+  if (!aggregatedActivities && event.aggregated_activities && event.aggregated_activities?.length > 0 || !activities && event.activities && event.activities?.length > 0) {
     return {
       changed: false
     };
   }
+  const result = {
+    changed: true,
+    data: {
+      aggregated_activities: aggregatedActivities,
+      activities
+    }
+  };
   if (event.aggregated_activities) {
-    const result = addAggregatedActivitiesToState(
+    const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
       aggregatedActivities,
       "replace"
     );
+    if (aggregatedActivitiesResult.changed) {
+      result.data.aggregated_activities = aggregatedActivitiesResult.aggregated_activities;
+    }
+  }
+  if (event.activities) {
+    const activitiesResult = updateActivities(event.activities, activities);
+    if (activitiesResult.changed) {
+      result.data.activities = activitiesResult.activities;
+    }
+  }
+  if (event.aggregated_activities || event.activities) {
     return result;
   }
   return {
@@ -5865,11 +5945,13 @@ function updateStoriesFeedFromEvent(aggregatedActivities, event) {
 function handleStoriesFeedUpdated(event) {
   const result = updateStoriesFeedFromEvent(
     this.currentState.aggregated_activities,
+    this.currentState.activities,
     event
   );
   if (result.changed) {
     this.state.partialNext({
-      aggregated_activities: result.data?.aggregated_activities
+      aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities
     });
   }
 }
@@ -5880,7 +5962,7 @@ function handleWatchStopped() {
   this.state.partialNext({ watch: false });
 }
 const _Feed = class _Feed extends FeedApi {
-  constructor(client, groupId, id, data, watch = false) {
+  constructor(client, groupId, id, data, watch = false, addNewActivitiesTo = "start") {
     super(client, groupId, id);
     this.indexedActivityIds = /* @__PURE__ */ new Set();
     this.stateUpdateQueue = /* @__PURE__ */ new Set();
@@ -5948,7 +6030,8 @@ const _Feed = class _Feed extends FeedApi {
       is_loading: false,
       is_loading_activities: false,
       comments_by_entity_id: {},
-      watch
+      watch,
+      addNewActivitiesTo
     });
     this.client = client;
     this.state.subscribeWithSelector(
@@ -5969,6 +6052,9 @@ const _Feed = class _Feed extends FeedApi {
   get currentState() {
     return this.state.getLatestValue();
   }
+  set addNewActivitiesTo(value) {
+    this.state.partialNext({ addNewActivitiesTo: value });
+  }
   hasActivity(activityId) {
     return this.indexedActivityIds.has(activityId);
   }
@@ -5988,6 +6074,13 @@ const _Feed = class _Feed extends FeedApi {
     });
     try {
       const response = await super.getOrCreate(request);
+      const currentActivityFeeds = [];
+      for (const activity of response.activities) {
+        if (activity.current_feed) {
+          currentActivityFeeds.push(activity.current_feed);
+        }
+      }
+      this.client.hydrateCapabilitiesCache([response.feed, ...currentActivityFeeds]);
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
         const result = addActivitiesToState.bind(this)(
@@ -6397,11 +6490,16 @@ const _Feed = class _Feed extends FeedApi {
       limit: currentState.last_get_or_create_request_config?.limit ?? 20
     });
   }
-  addActivity(request) {
-    return this.feedsApi.addActivity({
+  async addActivity(request) {
+    const response = await this.client.addActivity({
       ...request,
       feeds: [this.feed]
     });
+    const currentFeed = response.activity.current_feed;
+    if (currentFeed) {
+      this.client.hydrateCapabilitiesCache([currentFeed]);
+    }
+    return response;
   }
   handleWSEvent(event) {
     const eventHandler = this.eventHandlers[event.type];
@@ -6435,6 +6533,7 @@ function handleUserUpdated(event) {
 }
 var UnhandledErrorType = /* @__PURE__ */ ((UnhandledErrorType2) => {
   UnhandledErrorType2["ReconnectionReconciliation"] = "reconnection-reconciliation";
+  UnhandledErrorType2["FetchingOwnCapabilitiesOnNewActivity"] = "fetching-own-capabilities-on-new-activity";
   return UnhandledErrorType2;
 })(UnhandledErrorType || {});
 function updateCommentCount({
@@ -6465,6 +6564,90 @@ function updateCommentCount({
     }, false);
   }
 }
+const throttle = (fn, timeout = 200, {
+  leading = true,
+  trailing = false
+} = {}) => {
+  let timer = null;
+  let storedArgs = null;
+  let storedThis = null;
+  let lastInvokeTime;
+  const invoke = (args, thisArg) => {
+    lastInvokeTime = Date.now();
+    fn.apply(thisArg, args);
+  };
+  const scheduleTrailing = (delay) => {
+    if (timer) return;
+    timer = setTimeout(() => {
+      timer = null;
+      if (trailing && storedArgs) {
+        invoke(storedArgs, storedThis);
+        storedArgs = null;
+        storedThis = null;
+      }
+    }, delay);
+  };
+  return {
+    throttledFn: function(...args) {
+      const now = Date.now();
+      const hasBeenInvoked = lastInvokeTime != null;
+      if (!hasBeenInvoked && !leading) lastInvokeTime = now;
+      const timeSinceLast = hasBeenInvoked ? now - lastInvokeTime : timeout;
+      const remaining = timeout - timeSinceLast;
+      if (trailing) {
+        storedArgs = args;
+        storedThis = this;
+      }
+      if (remaining <= 0) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        if (leading) {
+          if (trailing) {
+            if (storedArgs === args) {
+              storedArgs = null;
+              storedThis = null;
+            }
+          }
+          invoke(args, this);
+        } else {
+          if (trailing) scheduleTrailing(timeout);
+        }
+        return;
+      }
+      if (trailing && !timer) {
+        scheduleTrailing(remaining);
+      }
+    },
+    cancelTimer: () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+};
+const DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL = 2e3;
+const queuedFeeds = /* @__PURE__ */ new Set();
+function queueBatchedOwnCapabilities({ feeds }) {
+  for (const feed of feeds) {
+    queuedFeeds.add(feed);
+  }
+  if (queuedFeeds.size > 0) {
+    this.throttledGetBatchOwnCapabilities(
+      [...queuedFeeds],
+      (feedsToClear) => {
+        for (const feed of feedsToClear) {
+          queuedFeeds.delete(feed);
+        }
+      }
+    );
+  }
+}
+function clearQueuedFeeds() {
+  queuedFeeds.clear();
+}
 class FeedsClient extends FeedsApi {
   constructor(apiKey, options) {
     const tokenManager = new TokenManager();
@@ -6479,6 +6662,29 @@ class FeedsClient extends FeedsApi {
     this.eventDispatcher = new EventDispatcher();
     this.activeFeeds = {};
     this.healthyConnectionChangedEventCount = 0;
+    this.setGetBatchOwnCapabilitiesThrottlingInterval = (throttlingMs) => {
+      const {
+        throttledFn: throttledGetBatchOwnCapabilities,
+        cancelTimer: cancel
+      } = throttle(
+        (feeds, callback) => {
+          this.ownCapabilitiesBatch({
+            feeds
+          }).catch((error) => {
+            this.eventDispatcher.dispatch({
+              type: "errors.unhandled",
+              error_type: UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
+              error
+            });
+          });
+          callback(feeds);
+        },
+        throttlingMs,
+        { trailing: true }
+      );
+      this.throttledGetBatchOwnCapabilities = throttledGetBatchOwnCapabilities;
+      this.cancelGetBatchOwnCapabilitiesTimer = cancel;
+    };
     this.recoverOnReconnect = async () => {
       this.healthyConnectionChangedEventCount++;
       if (this.healthyConnectionChangedEventCount > 1) {
@@ -6502,6 +6708,9 @@ class FeedsClient extends FeedsApi {
         throw new Error(`Can't connect a new user, call "disconnectUser" first`);
       }
       this.tokenManager.setTokenOrProvider(tokenProvider);
+      this.setGetBatchOwnCapabilitiesThrottlingInterval(
+        this.query_batch_own_capabilties_throttling_interval
+      );
       try {
         addConnectionEventListeners(this.updateNetworkConnectionStatus);
         this.wsConnection = new StableWSConnection(
@@ -6668,15 +6877,25 @@ class FeedsClient extends FeedsApi {
       removeConnectionEventListeners(this.updateNetworkConnectionStatus);
       this.connectionIdManager.reset();
       this.tokenManager.reset();
+      this.polls_by_id.clear();
       this.state.partialNext({
         connected_user: void 0,
-        is_ws_connection_healthy: false
+        is_ws_connection_healthy: false,
+        own_capabilities_by_fid: {}
       });
+      this.cancelGetBatchOwnCapabilitiesTimer();
+      clearQueuedFeeds();
     };
     this.on = this.eventDispatcher.on;
     this.off = this.eventDispatcher.off;
-    this.feed = (groupId, id) => {
-      return this.getOrCreateActiveFeed(groupId, id);
+    this.feed = (groupId, id, options2) => {
+      return this.getOrCreateActiveFeed(
+        groupId,
+        id,
+        void 0,
+        void 0,
+        options2?.addNewActivitiesTo
+      );
     };
     this.updateNetworkConnectionStatus = (event) => {
       const networkEvent = {
@@ -6685,10 +6904,17 @@ class FeedsClient extends FeedsApi {
       };
       this.eventDispatcher.dispatch(networkEvent);
     };
-    this.getOrCreateActiveFeed = (group, id, data, watch) => {
+    this.getOrCreateActiveFeed = (group, id, data, watch, addNewActivitiesTo) => {
       const fid = `${group}:${id}`;
       if (!this.activeFeeds[fid]) {
-        this.activeFeeds[fid] = new Feed(this, group, id, data, watch);
+        this.activeFeeds[fid] = new Feed(
+          this,
+          group,
+          id,
+          data,
+          watch,
+          addNewActivitiesTo
+        );
       }
       const feed = this.activeFeeds[fid];
       if (!feed.currentState.watch) {
@@ -6699,12 +6925,14 @@ class FeedsClient extends FeedsApi {
     };
     this.state = new StateStore({
       connected_user: void 0,
-      is_ws_connection_healthy: false
+      is_ws_connection_healthy: false,
+      own_capabilities_by_fid: {}
     });
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
     this.polls_by_id = /* @__PURE__ */ new Map();
+    this.query_batch_own_capabilties_throttling_interval = options?.query_batch_own_capabilties_throttling_interval ?? DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL;
     configureLoggers(options?.configure_loggers_options);
     this.on("all", (event) => {
       const fid = event.fid;
@@ -6824,9 +7052,29 @@ class FeedsClient extends FeedsApi {
       }
     }
   }
+  hydrateCapabilitiesCache(feedResponses) {
+    let ownCapabilitiesCache = this.state.getLatestValue().own_capabilities_by_fid;
+    const capabilitiesToFetchQueue = [];
+    for (const feedResponse of feedResponses) {
+      const { feed, own_capabilities } = feedResponse;
+      if (!Object.prototype.hasOwnProperty.call(ownCapabilitiesCache, feed)) {
+        if (own_capabilities) {
+          ownCapabilitiesCache = {
+            ...ownCapabilitiesCache,
+            [feed]: own_capabilities
+          };
+        } else {
+          capabilitiesToFetchQueue.push(feed);
+        }
+      }
+    }
+    queueBatchedOwnCapabilities.bind(this)({ feeds: capabilitiesToFetchQueue });
+    this.state.partialNext({ own_capabilities_by_fid: ownCapabilitiesCache });
+  }
   async queryFeeds(request) {
     const response = await this._queryFeeds(request);
-    const feeds = response.feeds.map(
+    const feedResponses = response.feeds;
+    const feeds = feedResponses.map(
       (feedResponse) => this.getOrCreateActiveFeed(
         feedResponse.group_id,
         feedResponse.id,
@@ -6834,6 +7082,7 @@ class FeedsClient extends FeedsApi {
         request?.watch
       )
     );
+    this.hydrateCapabilitiesCache(feedResponses);
     return {
       feeds,
       next: response.next,
@@ -6842,6 +7091,17 @@ class FeedsClient extends FeedsApi {
       duration: response.duration
     };
   }
+  async ownCapabilitiesBatch(request) {
+    const response = await super.ownCapabilitiesBatch(request);
+    const feedResponses = Object.entries(response.capabilities).map(
+      ([feed, own_capabilities]) => ({
+        feed,
+        own_capabilities
+      })
+    );
+    this.hydrateCapabilitiesCache(feedResponses);
+    return response;
+  }
   async updateFollow(request) {
     const response = await super.updateFollow(request);
     [
@@ -6909,98 +7169,27 @@ class FeedsClient extends FeedsApi {
     );
   }
 }
-const ChannelOwnCapability = {
-  BAN_CHANNEL_MEMBERS: "ban-channel-members",
-  CAST_POLL_VOTE: "cast-poll-vote",
-  CONNECT_EVENTS: "connect-events",
-  CREATE_ATTACHMENT: "create-attachment",
-  DELETE_ANY_MESSAGE: "delete-any-message",
-  DELETE_CHANNEL: "delete-channel",
-  DELETE_OWN_MESSAGE: "delete-own-message",
-  FLAG_MESSAGE: "flag-message",
-  FREEZE_CHANNEL: "freeze-channel",
-  JOIN_CHANNEL: "join-channel",
-  LEAVE_CHANNEL: "leave-channel",
-  MUTE_CHANNEL: "mute-channel",
-  PIN_MESSAGE: "pin-message",
-  QUERY_POLL_VOTES: "query-poll-votes",
-  QUOTE_MESSAGE: "quote-message",
-  READ_EVENTS: "read-events",
-  SEARCH_MESSAGES: "search-messages",
-  SEND_CUSTOM_EVENTS: "send-custom-events",
-  SEND_LINKS: "send-links",
-  SEND_MESSAGE: "send-message",
-  SEND_POLL: "send-poll",
-  SEND_REACTION: "send-reaction",
-  SEND_REPLY: "send-reply",
-  SEND_RESTRICTED_VISIBILITY_MESSAGE: "send-restricted-visibility-message",
-  SEND_TYPING_EVENTS: "send-typing-events",
-  SET_CHANNEL_COOLDOWN: "set-channel-cooldown",
-  SHARE_LOCATION: "share-location",
-  SKIP_SLOW_MODE: "skip-slow-mode",
-  SLOW_MODE: "slow-mode",
-  TYPING_EVENTS: "typing-events",
-  UPDATE_ANY_MESSAGE: "update-any-message",
-  UPDATE_CHANNEL: "update-channel",
-  UPDATE_CHANNEL_MEMBERS: "update-channel-members",
-  UPDATE_OWN_MESSAGE: "update-own-message",
-  UPDATE_THREAD: "update-thread",
-  UPLOAD_FILE: "upload-file"
-};
-const FeedOwnCapability = {
-  ADD_ACTIVITY: "add-activity",
-  ADD_ACTIVITY_BOOKMARK: "add-activity-bookmark",
-  ADD_ACTIVITY_REACTION: "add-activity-reaction",
-  ADD_COMMENT: "add-comment",
-  ADD_COMMENT_REACTION: "add-comment-reaction",
-  CREATE_FEED: "create-feed",
-  DELETE_ANY_ACTIVITY: "delete-any-activity",
-  DELETE_ANY_COMMENT: "delete-any-comment",
-  DELETE_FEED: "delete-feed",
-  DELETE_OWN_ACTIVITY: "delete-own-activity",
-  DELETE_OWN_ACTIVITY_BOOKMARK: "delete-own-activity-bookmark",
-  DELETE_OWN_ACTIVITY_REACTION: "delete-own-activity-reaction",
-  DELETE_OWN_COMMENT: "delete-own-comment",
-  DELETE_OWN_COMMENT_REACTION: "delete-own-comment-reaction",
-  FOLLOW: "follow",
-  PIN_ACTIVITY: "pin-activity",
-  QUERY_FEED_MEMBERS: "query-feed-members",
-  QUERY_FOLLOWS: "query-follows",
-  READ_ACTIVITIES: "read-activities",
-  READ_FEED: "read-feed",
-  UNFOLLOW: "unfollow",
-  UPDATE_ANY_ACTIVITY: "update-any-activity",
-  UPDATE_ANY_COMMENT: "update-any-comment",
-  UPDATE_FEED: "update-feed",
-  UPDATE_FEED_FOLLOWERS: "update-feed-followers",
-  UPDATE_FEED_MEMBERS: "update-feed-members",
-  UPDATE_OWN_ACTIVITY: "update-own-activity",
-  UPDATE_OWN_ACTIVITY_BOOKMARK: "update-own-activity-bookmark",
-  UPDATE_OWN_COMMENT: "update-own-comment"
-};
 export {
-  ChannelOwnCapability as C,
+  Constants as C,
   FeedsClient as F,
   StreamApiError as S,
   Feed as a,
-  FeedOwnCapability as b,
-  StreamPoll as c,
+  StreamPoll as b,
+  checkHasAnotherPage as c,
   debounce as d,
-  checkHasAnotherPage as e,
-  Constants as f,
-  isFollowResponse as g,
-  isReactionResponse as h,
+  isFollowResponse as e,
+  isReactionResponse as f,
+  isCommentResponse as g,
+  isImageFile as h,
   isVoteAnswer as i,
-  isCommentResponse as j,
-  isImageFile as k,
-  isVideoFile as l,
-  getStateUpdateQueueId as m,
-  updateEntityInArray as n,
-  configureLoggers as o,
-  getLogger as p,
-  ensureExhausted as q,
+  isVideoFile as j,
+  getStateUpdateQueueId as k,
+  updateEntityInArray as l,
+  configureLoggers as m,
+  getLogger as n,
+  ensureExhausted as o,
   replaceUniqueArrayMerge as r,
   shouldUpdateState as s,
   uniqueArrayMerge as u
 };
-//# sourceMappingURL=index-BZL77zNq.mjs.map
+//# sourceMappingURL=feeds-client-CFadXO-B.mjs.map