@streamscloud/embeddable 14.0.0-rc.0 → 14.0.0

package/dist/media-center/media-center/handlers/media-center-content-handler.svelte.js

@@ -0,0 +1,144 @@
+export class MediaCenterContentHandler {
+    dataProvider;
+    postCreatedListeners = [];
+    postDeletedListeners = [];
+    postModifiedListeners = [];
+    streamModifiedListeners = [];
+    streamDeletedListeners = [];
+    streamPageDeletedListeners = [];
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        $effect(() => {
+            if (this.dataProvider.handlers?.contentManagementHandler) {
+                this.dataProvider.handlers.contentManagementHandler.onHandlerMounted({
+                    postCreated: (result) => {
+                        const { post, categories, isPublished } = result;
+                        this.postCreatedListeners.forEach((callback) => {
+                            callback({ post, categories, isPublished });
+                        });
+                    }
+                });
+            }
+        });
+    }
+    get editPost() {
+        const originalFn = this.dataProvider.handlers?.contentManagementHandler?.editPost;
+        if (!originalFn) {
+            return null;
+        }
+        return async (...args) => {
+            const result = await originalFn(...args);
+            if (result) {
+                this.postModifiedListeners.forEach((callback) => {
+                    callback({
+                        post: result.post,
+                        categories: result.categories,
+                        isPublished: result.isPublished
+                    });
+                });
+            }
+            return result;
+        };
+    }
+    get deletePost() {
+        const originalFn = this.dataProvider.handlers?.contentManagementHandler?.deletePost;
+        if (!originalFn) {
+            return null;
+        }
+        return async (...args) => {
+            const result = await originalFn(...args);
+            if (result) {
+                this.postDeletedListeners.forEach((callback) => {
+                    callback({ id: args[0] });
+                });
+            }
+            return result;
+        };
+    }
+    get editArticle() {
+        const originalFn = this.dataProvider.handlers?.contentManagementHandler?.editArticle;
+        if (!originalFn) {
+            return null;
+        }
+        return async (...args) => {
+            const result = await originalFn(...args);
+            if (result) {
+                this.postModifiedListeners.forEach((callback) => {
+                    callback({
+                        post: result.post,
+                        categories: result.categories,
+                        isPublished: result.isPublished
+                    });
+                });
+            }
+            return result;
+        };
+    }
+    get editStream() {
+        const originalFn = this.dataProvider.handlers?.contentManagementHandler?.editStream;
+        if (!originalFn) {
+            return null;
+        }
+        return async (...args) => {
+            const result = await originalFn(...args);
+            if (result) {
+                this.streamModifiedListeners.forEach((callback) => {
+                    callback({
+                        stream: result.stream,
+                        categories: result.categories,
+                        isPublished: result.isPublished
+                    });
+                });
+            }
+            return result;
+        };
+    }
+    get deleteStream() {
+        const originalFn = this.dataProvider.handlers?.contentManagementHandler?.deleteStream;
+        if (!originalFn) {
+            return null;
+        }
+        return async (...args) => {
+            const result = await originalFn(...args);
+            if (result) {
+                this.streamDeletedListeners.forEach((callback) => {
+                    callback({ id: args[0] });
+                });
+            }
+            return result;
+        };
+    }
+    get deleteStreamPage() {
+        const originalFn = this.dataProvider.handlers?.contentManagementHandler?.deleteStreamPage;
+        if (!originalFn) {
+            return null;
+        }
+        return async (...args) => {
+            const result = await originalFn(...args);
+            if (result) {
+                this.streamPageDeletedListeners.forEach((callback) => {
+                    callback({ id: args[0] });
+                });
+            }
+            return result;
+        };
+    }
+    addPostCreatedListener = (...callbacks) => {
+        this.postCreatedListeners.push(...callbacks);
+    };
+    addPostModifiedListener = (...callbacks) => {
+        this.postModifiedListeners.push(...callbacks);
+    };
+    addPostDeletedListener = (...callbacks) => {
+        this.postDeletedListeners.push(...callbacks);
+    };
+    addStreamModifiedListener = (...callbacks) => {
+        this.streamModifiedListeners.push(...callbacks);
+    };
+    addStreamDeletedListener = (...callbacks) => {
+        this.streamDeletedListeners.push(...callbacks);
+    };
+    addStreamPageDeletedListener = (...callbacks) => {
+        this.streamPageDeletedListeners.push(...callbacks);
+    };
+}

package/dist/media-center/media-center/header/media-center-header-mobile.svelte

@@ -20,13 +20,13 @@ const headerMounted = (node) => {
 </script>
 
 <div class="media-center-header-mobile" class:media-center-header-mobile--static={context.mediaCenterMode === 'discover'} use:headerMounted>
-  {#if context.closeOrchestrator.closeTriggerVisible}
-    <button type="button" class="media-center-header-mobile__button" onclick={context.closeOrchestrator.requestClose}>
-      <Icon src={IconDismiss} />
-    </button>
-  {:else}
-    <span><!--just a stub--></span>
-  {/if}
+  <button
+    type="button"
+    class="media-center-header-mobile__button"
+    class:media-center-header-mobile__button--hidden={!context.closeOrchestrator.closeTriggerVisible}
+    onclick={context.closeOrchestrator.requestClose}>
+    <Icon src={IconDismiss} />
+  </button>
   {#if context.mediaCenterMode === 'discover'}
     <div class="media-center-header-mobile__title">
       {localization.discoverLabel}
@@ -78,4 +78,7 @@ const headerMounted = (node) => {
   --icon--color: var(--sc-mc-color--icon-overlay);
   --icon--filter: var(--sc-mc-color--icon-overlay-shadow);
   line-height: 0;
+}
+.media-center-header-mobile__button--hidden {
+  visibility: hidden;
 }</style>

package/dist/media-center/media-center/header/media-center-header.svelte

@@ -146,7 +146,7 @@ const styles = $derived.by(() => {
           type="button"
           class="control-button"
           class:control-button--active={context.postsFeedHandler.activated || context.streamsFeedHandler.activated}
-          onclick={() => context.playRootFeed()}>
+          onclick={() => context.activateDefaultFeed()}>
           <span class="control-button__icon" class:control-button__icon--active={context.postsFeedHandler.activated || context.streamsFeedHandler.activated}>
             <Icon src={IconPhone} />
           </span>

package/dist/media-center/media-center/media-center-context.svelte.d.ts

@@ -2,7 +2,7 @@ import type { IMediaCenterDataProvider } from '../config/types';
 import type { MediaCenterState } from '../navigation';
 import type { ICloseOrchestrator } from '../../ui/player/close-orchestrator';
 import { DiscoverViewHandler } from './discover';
-import { CategoriesHandler, MediaCenterSettingsHandler } from './handlers';
+import { CategoriesHandler, MediaCenterContentHandler, MediaCenterSettingsHandler } from './handlers';
 import type { MediaCenterSettings } from './media-center-settings.svelte';
 import { PopularStreamsPanelHandler } from './menu';
 import { MomentsFeedHandler } from './moments';
@@ -23,6 +23,7 @@ export declare class MediaCenterContext {
     popularStreamsHandler: PopularStreamsPanelHandler;
     streamsInCategoryHandler: StreamsInCategoryPanelHandler;
     settingsHandler: MediaCenterSettingsHandler;
+    contentManagementHandler: MediaCenterContentHandler;
     closeOrchestrator: ICloseOrchestrator;
     private _dataProvider;
     private _currentState;
@@ -54,7 +55,7 @@ export declare class MediaCenterContext {
     playPostsFeed: (options: Parameters<PostsFeedHandler["activate"]>[0]) => Promise<void>;
     playStreamsFeed: (options: Parameters<StreamsFeedHandler["activate"]>[0]) => Promise<void>;
     playMoments: (options?: Parameters<MomentsFeedHandler["activate"]>[0]) => Promise<void>;
-    playRootFeed: () => Promise<void>;
+    activateDefaultFeed: () => Promise<void>;
     tryActivateStreamsInCategory: (categoryId: string) => Promise<void>;
     restoreState: (state: MediaCenterState) => Promise<void>;
     handleNavigationStateChanged: (state: MediaCenterState) => void;

package/dist/media-center/media-center/media-center-context.svelte.js

@@ -1,6 +1,6 @@
 import { Utils } from '../../core/utils';
 import { DiscoverViewHandler } from './discover';
-import { CategoriesHandler, MediaCenterSettingsHandler } from './handlers';
+import { CategoriesHandler, MediaCenterContentHandler, MediaCenterSettingsHandler } from './handlers';
 import { PopularStreamsPanelHandler } from './menu';
 import { MomentsFeedHandler } from './moments';
 import { PostsFeedHandler } from './posts-feed';
@@ -34,6 +34,7 @@ export class MediaCenterContext {
     popularStreamsHandler;
     streamsInCategoryHandler;
     settingsHandler;
+    contentManagementHandler;
     closeOrchestrator;
     _dataProvider;
     _currentState = null;
@@ -43,15 +44,18 @@ export class MediaCenterContext {
         this.closeOrchestrator = closeOrchestrator;
         this.closeOrchestrator.setCloseTriggerAttached(true);
         this.settingsHandler = new MediaCenterSettingsHandler({ settings, dataProvider });
+        this.contentManagementHandler = new MediaCenterContentHandler(dataProvider);
         this.postsFeedHandler = new PostsFeedHandler({
             dataProvider,
             mediaCenterSettingsHandler: this.settingsHandler,
+            mediaCenterContentHandler: this.contentManagementHandler,
             closeOrchestrator,
             on: { playerReachedEnd: this.backToDiscover, navigationStateChanged: this.handleNavigationStateChanged }
         });
         this.streamsFeedHandler = new StreamsFeedHandler({
             dataProvider,
             mediaCenterSettingsHandler: this.settingsHandler,
+            mediaCenterContentHandler: this.contentManagementHandler,
             closeOrchestrator,
             on: { playerReachedEnd: this.backToDiscover, navigationStateChanged: this.handleNavigationStateChanged }
         });
@@ -62,9 +66,16 @@ export class MediaCenterContext {
         this.momentsFeedHandler = new MomentsFeedHandler({
             dataProvider,
             mediaCenterSettingsHandler: this.settingsHandler,
+            mediaCenterContentHandler: this.contentManagementHandler,
             closeOrchestrator,
             on: { playerReachedEnd: this.backToDiscover, navigationStateChanged: this.handleNavigationStateChanged }
         });
+        this.contentManagementHandler.addPostCreatedListener(this.discoverHandler.onPostCreated, this.postsFeedHandler.onPostCreated, this.momentsFeedHandler.onPostCreated);
+        this.contentManagementHandler.addPostModifiedListener(this.discoverHandler.onPostModified, this.postsFeedHandler.onPostModified, this.momentsFeedHandler.onPostModified);
+        this.contentManagementHandler.addPostDeletedListener(this.discoverHandler.onPostDeleted, this.postsFeedHandler.onPostDeleted, this.momentsFeedHandler.onPostDeleted);
+        this.contentManagementHandler.addStreamModifiedListener(this.discoverHandler.onStreamModified, this.streamsFeedHandler.onStreamModified, this.popularStreamsHandler.onStreamModified);
+        this.contentManagementHandler.addStreamDeletedListener(this.discoverHandler.onStreamDeleted, this.popularStreamsHandler.onStreamDeleted);
+        this.contentManagementHandler.addStreamPageDeletedListener(this.streamsFeedHandler.onStreamPageDeleted);
         $effect(() => {
             if (this.initialized) {
                 void settings.state;
@@ -130,13 +141,21 @@ export class MediaCenterContext {
     };
     backToDiscover = () => this.activateDiscover({ categoryId: this.categoriesHandler.selectedCategoryId });
     playPostsFeed = async (options) => {
+        const categoryId = options.filter?.categoryId ?? null;
+        if (categoryId === this.categoriesHandler.selectedCategoryId && !this.postsFeedHandler.canReload) {
+            return;
+        }
         this.deactivateAllBut('posts-feed');
-        this.categoriesHandler.selectedCategoryId = options.filter?.categoryId ?? null;
+        this.categoriesHandler.selectedCategoryId = categoryId;
         this.postsFeedHandler.activate(options);
     };
     playStreamsFeed = async (options) => {
+        const categoryId = options.filter?.categoryId ?? null;
+        if (categoryId === this.categoriesHandler.selectedCategoryId && !this.streamsFeedHandler.canReload) {
+            return;
+        }
         this.deactivateAllBut('streams-feed');
-        this.categoriesHandler.selectedCategoryId = options.filter?.categoryId ?? null;
+        this.categoriesHandler.selectedCategoryId = categoryId;
         this.streamsFeedHandler.activate(options);
     };
     playMoments = async (options) => {
@@ -146,14 +165,13 @@ export class MediaCenterContext {
         this.deactivateAllBut('moments');
         this.momentsFeedHandler.activate(options);
     };
-    playRootFeed = async () => {
+    activateDefaultFeed = async () => {
         this.categoriesHandler.selectedCategoryId = null;
-        if (this.streamsFeedHandler.active) {
-            this.streamsFeedHandler.activate({});
+        if (this.mediaCenterMode === 'streams-feed') {
+            this.playStreamsFeed({ filter: { categoryId: null } });
         }
         else {
-            this.deactivateAllBut('posts-feed');
-            this.postsFeedHandler.activate({});
+            this.playPostsFeed({ filter: { categoryId: null } });
         }
     };
     tryActivateStreamsInCategory = async (categoryId) => {
@@ -169,19 +187,20 @@ export class MediaCenterContext {
         this._currentState = state;
         switch (state.mode) {
             case 'posts-feed':
-                await this.playPostsFeed({ filter: { categoryId: state.categoryId }, init: { initialPostId: state.postId } });
+                await this.playPostsFeed({ filter: { categoryId: state.categoryId }, init: { initialPostId: state.postId }, tryRestoreState: true });
                 break;
             case 'streams-feed':
                 await this.playStreamsFeed({
                     filter: { categoryId: state.categoryId },
-                    init: { initialStreamId: state.streamId, initialStreamPageId: state.streamPageId }
+                    init: { initialStreamId: state.streamId, initialStreamPageId: state.streamPageId },
+                    tryRestoreState: true
                 });
                 break;
             case 'discover':
                 await this.activateDiscover({ categoryId: state.categoryId });
                 break;
             case 'moments':
-                await this.playMoments({ initialMomentId: state.momentId });
+                await this.playMoments({ initialMomentId: state.momentId, tryRestoreState: true });
                 break;
         }
     };

package/dist/media-center/media-center/media-center-view.svelte

@@ -27,9 +27,6 @@ const selectCategory = (categoryId) => __awaiter(void 0, void 0, void 0, functio
     }
     switch (context.mediaCenterMode) {
         case 'posts-feed':
-            if (!context.postsFeedHandler.feedPlayerProps) {
-                return;
-            }
             if (context.categoriesHandler.selectedCategoryId === categoryId) {
                 return;
             }
@@ -48,11 +45,26 @@ const selectCategory = (categoryId) => __awaiter(void 0, void 0, void 0, functio
             Utils.assertUnreachable(context.mediaCenterMode);
     }
 });
-const activateSelectedShortVideoPlayer = (shortVideo) => {
-    context.playPostsFeed({ init: { prefetchedItems: [shortVideo] } });
+const resetMediaCenterMode = () => {
+    if (!context.mediaCenterMode) {
+        return;
+    }
+    switch (context.mediaCenterMode) {
+        case 'streams-feed':
+            context.playStreamsFeed({ filter: { categoryId: null } });
+            break;
+        case 'discover':
+            context.activateDiscover({ categoryId: null });
+            break;
+        default:
+            context.playPostsFeed({ filter: { categoryId: null } });
+    }
 };
-const activateSelectedStreamPlayer = (stream) => {
-    context.playStreamsFeed({ init: { prefetchedStreams: [stream] } });
+const activateSelectedShortVideoPlayer = (shortVideo, categoryId) => {
+    context.playPostsFeed({ init: { prefetchedItems: [shortVideo] }, filter: { categoryId } });
+};
+const activateSelectedStreamPlayer = (stream, categoryId) => {
+    context.playStreamsFeed({ init: { prefetchedStreams: [stream] }, filter: { categoryId } });
 };
 const activateSelectedStreamOfCategoryPlayer = (id, prefetchedStreams, categoryId) => {
     context.playStreamsFeed({ filter: { categoryId }, init: { prefetchedStreams, initialStreamId: id } });
@@ -138,24 +150,24 @@ const swipeToOpen = (node) => {
     <div class="media-center__content-container" use:swipeToOpen>
       {#if context.mediaCenterMode === 'posts-feed' && context.postsFeedHandler.feedPlayerProps}
         <div class="media-center__content" class:media-center__content--faded={context.overlayIsActive} transition:fade={{ duration: 300 }}>
-          <PostsPlayerView {...context.postsFeedHandler.feedPlayerProps} />
+          <PostsPlayerView {...context.postsFeedHandler.feedPlayerProps} managementActions={context.postsFeedHandler.managementActions} />
         </div>
       {:else if context.mediaCenterMode === 'streams-feed' && context.streamsFeedHandler.feedPlayerProps}
         <div class="media-center__content" class:media-center__content--faded={context.overlayIsActive} transition:fade={{ duration: 300 }}>
-          <StreamsPlayerView {...context.streamsFeedHandler.feedPlayerProps} />
+          <StreamsPlayerView {...context.streamsFeedHandler.feedPlayerProps} managementActions={context.streamsFeedHandler.managementActions} />
         </div>
       {:else if context.mediaCenterMode === 'discover'}
         <div class="media-center__content" transition:fade={{ duration: 300 }}>
           <DiscoverPanel
             context={context}
             on={{
-              shortVideoSelected: (shortVideo) => activateSelectedShortVideoPlayer(shortVideo),
-              streamSelected: (stream) => activateSelectedStreamPlayer(stream)
+              shortVideoSelected: activateSelectedShortVideoPlayer,
+              streamSelected: activateSelectedStreamPlayer
             }} />
         </div>
       {:else if context.mediaCenterMode === 'moments' && context.momentsFeedHandler.momentsPlayerProps}
         <div class="media-center__content" class:media-center__content--faded={context.overlayIsActive} transition:fade={{ duration: 300 }}>
-          <PostsPlayerView {...context.momentsFeedHandler.momentsPlayerProps} />
+          <PostsPlayerView {...context.momentsFeedHandler.momentsPlayerProps} managementActions={context.momentsFeedHandler.managementActions} />
         </div>
       {/if}
     </div>
@@ -163,7 +175,13 @@ const swipeToOpen = (node) => {
     {#if context.menuActive}
       <div class="menu-overlay" class:menu-overlay--mobile={isMobileView} onclick={context.hideMenu} onkeydown={() => {}} role="none">
         <div class="menu-overlay__panel">
-          <Menu context={context} on={{ categorySelected: selectCategory, streamSelected: activateSelectedStreamPlayer }} />
+          <Menu
+            context={context}
+            on={{
+              categorySelected: selectCategory,
+              streamSelected: (stream) => activateSelectedStreamPlayer(stream, null),
+              resetModeRequested: resetMediaCenterMode
+            }} />
         </div>
       </div>
     {/if}

package/dist/media-center/media-center/menu/menu.svelte

@@ -71,7 +71,7 @@ const styles = $derived.by(() => {
     <div class="media-center-menu__tree">
       <div class="media-center-menu__tree-item">
         <div class="menu-item" class:menu-item--active={!context.categoriesHandler.selectedCategoryId}>
-          <div class="menu-item__content" onclick={() => context.playRootFeed()} onkeydown={() => {}} role="button" tabindex="0">
+          <div class="menu-item__content" onclick={() => on.resetModeRequested()} onkeydown={() => {}} role="button" tabindex="0">
             <div class="menu-item__text" class:menu-item__text--active={!context.categoriesHandler.selectedCategoryId}>
               {context.mediaCenterMode === 'discover' ? localization.discoverLabel : localization.feedLabel}
             </div>
@@ -94,7 +94,9 @@ const styles = $derived.by(() => {
             </div>
             {#if category.value.tag}
               <div class="menu-item__tag" style="background-color: {category.value.tag.backgroundColor}; color: {category.value.tag.fontColor};">
-                {category.value.tag.text}
+                <div class="menu-item__tag-text">
+                  {category.value.tag.text}
+                </div>
               </div>
             {/if}
           </div>
@@ -239,16 +241,14 @@ const styles = $derived.by(() => {
   display: flex;
   -webkit-user-drag: none;
   user-select: none;
-}
-.menu-item :global([contenteditable]) {
-  user-select: text;
-}
-.menu-item {
   height: 2.25rem;
   padding-left: var(--_media-center-menu--items--padding-inline);
   --_menu-item--text--font-size: 0.9375rem;
   --_menu-item--image--size: 1.5rem;
 }
+.menu-item :global([contenteditable]) {
+  user-select: text;
+}
 .menu-item--active {
   background-color: hsl(from var(--_media-center-menu--background-color) h s calc(l + 5)/alpha);
   border-radius: 0.25rem;
@@ -298,10 +298,19 @@ const styles = $derived.by(() => {
   border-radius: 0.25rem;
   padding: 0.3125rem 0.375rem;
   font-size: 0.5rem;
+  line-height: 1.2;
   font-weight: 600;
   margin-top: -1rem;
   margin-left: 0.25rem;
 }
+.menu-item__tag-text {
+  display: -webkit-box;
+  line-clamp: 2;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
 .menu-item__collapser {
   --icon--color: var(--sc-mc-color--text-primary);
   --icon--size: 1rem;

package/dist/media-center/media-center/menu/menu.svelte.d.ts

@@ -5,6 +5,7 @@ type Props = {
     on: {
         categorySelected: (categoryId: string) => void;
         streamSelected: (stream: StreamPlayerModel) => void;
+        resetModeRequested: () => void;
     };
 };
 declare const Menu: import("svelte").Component<Props, {}, "">;

package/dist/media-center/media-center/menu/popular-streams-panel-handler.svelte.d.ts

@@ -7,4 +7,11 @@ export declare class PopularStreamsPanelHandler {
     constructor(dataProvider: IMediaCenterDataProvider);
     get streamSectionItems(): StreamPlayerModel[];
     init: () => Promise<void>;
+    onStreamModified: (data: {
+        stream: StreamPlayerModel;
+    }) => void;
+    onStreamDeleted: (data: {
+        id: string;
+    }) => void;
+    private loadStreams;
 }

package/dist/media-center/media-center/menu/popular-streams-panel-handler.svelte.js

@@ -10,14 +10,29 @@ export class PopularStreamsPanelHandler {
     }
     init = async () => {
         if (this._state === 'not-initialized') {
-            this._state = 'loading';
-            try {
-                const streamsResponse = await this.dataProvider.streamPlayer.getStreamsCursor({ filter: {}, limit: 2 });
-                this._streams = streamsResponse.items;
-            }
-            finally {
-                this._state = 'ready';
-            }
+            await this.loadStreams();
+        }
+    };
+    onStreamModified = (data) => {
+        const { stream } = data;
+        if (this._streams.some((s) => s.id === stream.id)) {
+            this.loadStreams();
+        }
+    };
+    onStreamDeleted = (data) => {
+        const { id } = data;
+        if (this._streams.some((s) => s.id === id)) {
+            this.loadStreams();
+        }
+    };
+    loadStreams = async () => {
+        this._state = 'loading';
+        try {
+            const streamsResponse = await this.dataProvider.streamPlayer.getStreamsCursor({ filter: {}, limit: 2 });
+            this._streams = streamsResponse.items;
+        }
+        finally {
+            this._state = 'ready';
         }
     };
 }

package/dist/media-center/media-center/moments/moments-feed-handler.svelte.d.ts

@@ -1,20 +1,23 @@
 import type { IMediaCenterDataProvider } from '../../config/types';
 import type { MediaCenterState } from '../../navigation';
-import type { PostsPlayerProps } from '../../../posts/posts-player/types';
+import type { PostPlayerModel, PostsPlayerProps, PostManagementActions } from '../../../posts/posts-player/types';
 import type { ICloseOrchestrator } from '../../../ui/player/close-orchestrator';
+import type { IPlayerBuffer } from '../../../ui/player/providers';
 import { MomentsState } from './moments-state.svelte';
-import { MediaCenterSettingsHandler } from '../handlers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 export declare class MomentsFeedHandler {
     momentsState: MomentsState;
     private _active;
     private _momentsPlayerProps;
     private _dataProvider;
     private _mediaCenterSettingsHandler;
+    private _mediaCenterContentHandler;
     private _closeOrchestrator;
     private _callbacks;
     constructor(data: {
         dataProvider: IMediaCenterDataProvider;
         mediaCenterSettingsHandler: MediaCenterSettingsHandler;
+        mediaCenterContentHandler: MediaCenterContentHandler;
         closeOrchestrator: ICloseOrchestrator;
         on: Callbacks;
     });
@@ -22,10 +25,24 @@ export declare class MomentsFeedHandler {
     get momentsPlayerProps(): PostsPlayerProps | null;
     get hasUnwatchedMoments(): boolean;
     get hasMoments(): boolean;
+    get feedBuffer(): IPlayerBuffer<PostPlayerModel> | null;
+    get managementActions(): PostManagementActions;
     deactivate: () => void;
     activate: (data?: {
         initialMomentId?: string | null;
+        tryRestoreState?: boolean;
     }) => Promise<void>;
+    onPostCreated: (data: {
+        post: PostPlayerModel;
+        isPublished: boolean;
+    }) => void;
+    onPostModified: (data: {
+        post: PostPlayerModel;
+        isPublished: boolean;
+    }) => false | undefined;
+    onPostDeleted: (data: {
+        id: string;
+    }) => void;
     private tryRestoreState;
 }
 type Callbacks = {