@signageos/front-applet 8.1.1 → 8.1.3

package/docs/sos/stream.md

@@ -4,39 +4,33 @@ sidebar_position: 0
 
 # stream
 
-The `sos.video` API groups together methods for streaming videos.
+The `sos.stream` API groups together methods for streaming videos from different sources. There are various methods for preparing, playing, stopping, pausing, and resuming streams.
 
-:::warning
+Streams are identified by their URI and their position on the screen (x, y, width, height).
+
+This API allows you to play video stream from:
+- URL (e.g., HTTP, RTSP, RTP, UDP, RTMP)
+- HDMI (e.g., Picture-in-Picture, Internal ports) streams
 
+:::warning
 Are you using **Samsung Tizen** to play streams? Read more about limitation and
 [Tizen-specific details](https://docs.signageos.io/hc/en-us/articles/4405387373458).
-
 :::
 
 :::danger
-
 Be aware version of JS API (v6.0.0+) changed how stream functions `play()` and `prepare()` work. For using an options object you need to
 our latest core app versions. If you are using older core app versions, you need to use deprecated format.
-
 :::
 
 ## Methods
 
 ### getTracks()
 
-The `getTracks()` method returns a track list of a stream.
+The `getTracks()` method returns a list of subtitles, video, and audio tracks of a stream.
 
 ```ts expandable
 getTracks(videoId: IVideoProperties): Promise<ITrackInfo[]>;
 // show-more
-interface IVideoProperties {
-    uri: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-
 type ITrackInfo = ITrackVideoInfo | ITrackAudioInfo | ITrackTextInfo;
 
 interface ITrackVideoInfo extends ITrack<'VIDEO'> {
@@ -46,26 +40,90 @@ interface ITrackVideoInfo extends ITrack<'VIDEO'> {
     };
 }
 
+/**
+ * Interface representing stream track information.
+ */
 interface ITrack<T extends TrackType> {
+    /**
+     * Type of the track, e.g., "VIDEO", "AUDIO", "TEXT".
+     */
     trackType: T;
+    /**
+     * MIME type of the track, e.g., "video/mp4", "audio/mp3", "text/vtt".
+     */
     mimeType: string;
+    /**
+     * Unique identifier for the track group.
+     * This is used to group tracks of the same type (e.g., multiple audio tracks).
+     */
     groupId: string;
+    /**
+     * Unique identifier for the track.
+     */
     trackIndex: number;
+    /**
+     * If the track is selected for playback.
+     */
     selected: boolean;
+    /**
+     * Selected language of subtitles or captions.
+     */
     language: string | null;
+    /**
+     * If the track is supported by the device.
+     */
     supported: boolean;
 }
 
+/**
+ * Available track types for media streams.
+ */
 type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
 
 interface ITrackAudioInfo extends ITrack<'AUDIO'> {
+    /**
+     * Number of audio channels.
+     */
     channelCount: number;
 }
 
 interface ITrackTextInfo extends ITrack<'TEXT'> {
+    /**
+     * Selected subtitles or captions.
+     */
     selection: string[];
 }
 
+/**
+ * Video properties interface for defining the properties of a played video.
+ */
+interface IVideoProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+```
+
+#### Params
+
+| Name      | Type               | Description                                           |
+|-----------|--------------------|-------------------------------------------------------|
+| `videoId` | `IVideoProperties` | The video properties of the stream to get tracks for. |
+
+#### Return value
+
+Returns array of object with information about subtitles, video, and audio tracks.
+
+#### Example
+
+```ts
+// Example of getting tracks for a stream
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+const tracks = await sos.stream.getTracks(streamId);
+console.log(tracks); // Outputs an array of track information
 ```
 
 <Separator />
@@ -77,13 +135,31 @@ The `onConnected()` method sets up a listener, which is called whenever a stream
 ```ts expandable
 onConnected(listener: (event: IStreamEvent<'connected'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -92,25 +168,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -129,9 +237,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -144,22 +261,61 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                         | Description                                               |
+|------------|----------------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"connected">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the connected event
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onConnected((event) => {
+  console.log('Stream connected:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onDisconnected()
 
 The `onDisconnected()` method sets up a listener, which is called whenever a stream gets disconnected.
+Usually when source URI is not available anymore or when the stream is stopped.
 
 ```ts expandable
 onDisconnected(listener: (event: IStreamEvent<'disconnected'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -168,25 +324,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -205,9 +393,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -220,26 +417,70 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                            | Description                                               |
+|------------|-------------------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"disconnected">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the disconnected event
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onDisconnected((event) => {
+    console.log('Stream disconnected:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onError()
 
-The `onTracksChanged()` method sets up a listener, which is called whenever an unexpected error occurs during a stream.
+The `onError()` method sets up a listener, which is called whenever an unexpected error occurs during a stream.
 
 ```ts expandable
 onError(listener: (event: IStreamErrorEvent) => void): void;
 // show-more
+/**
+ * Stream Error Event, which is emitted when an error occurs during stream operations.
+ */
 interface IStreamErrorEvent extends IStreamEvent<'error'> {
+    /**
+     * Additional info about the error that occurred, if any info is available.
+     */
     errorMessage?: string | undefined;
 }
 
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -248,25 +489,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -285,9 +558,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -300,22 +582,60 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                 | Description                                               |
+|------------|--------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamErrorEvent) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the error event
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onError((event) => {
+    console.error('Stream error:', event.errorMessage);
+});
+```
+
 <Separator />
 
 ### onPause()
 
-The `onStop()` method sets up a listener, which is called whenever a stream is paused.
+The `onPause()` method sets up a listener, which is called whenever a stream is paused.
 
 ```ts expandable
 onPause(listener: (event: IStreamEvent<'pause'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -324,25 +644,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -361,9 +713,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -376,6 +737,26 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                     | Description                                               |
+|------------|------------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"pause">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the pause event
+await sos.stream.pause('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onPause((event) => {
+    console.log('Stream paused:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onPlay()
@@ -385,13 +766,31 @@ The `onPlay()` method sets up a listener, which is called whenever a stream star
 ```ts expandable
 onPlay(listener: (event: IStreamEvent<'play'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -400,25 +799,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -437,9 +868,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -452,6 +892,26 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                    | Description                                               |
+|------------|-----------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"play">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the play event
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onPlay((event) => {
+    console.log('Stream started playing:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onPrepare()
@@ -461,13 +921,31 @@ The `onPrepare()` method sets up a listener, which is called whenever a stream g
 ```ts expandable
 onPrepare(listener: (event: IStreamEvent<'prepare'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -476,25 +954,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -513,9 +1023,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -528,22 +1047,60 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                       | Description                                               |
+|------------|--------------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"prepare">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the prepare event
+await sos.stream.prepare('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onPrepare((event) => {
+    console.log('Stream prepared:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onResume()
 
-The `onStop()` method sets up a listener, which is called whenever a stream is resumed.
+The `onResume()` method sets up a listener, which is called whenever a stream is resumed.
 
 ```ts expandable
 onResume(listener: (event: IStreamEvent<'resume'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -552,25 +1109,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -589,9 +1178,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -604,6 +1202,28 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                      | Description                                               |
+|------------|-------------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"resume">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the resume event
+await sos.stream.pause('http://example.com/stream', 0, 0, 1920, 1080); // Pause the stream
+// ... after some time
+await sos.stream.resume('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onResume((event) => {
+    console.log('Stream resumed:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onStop()
@@ -613,13 +1233,31 @@ The `onStop()` method sets up a listener, which is called whenever a stream stop
 ```ts expandable
 onStop(listener: (event: IStreamEvent<'stop'>) => void): void;
 // show-more
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -628,25 +1266,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -665,9 +1335,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -680,16 +1359,43 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                    | Description                                               |
+|------------|-----------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamEvent<"stop">) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener for the stop event
+await sos.stream.stop('http://example.com/stream', 0, 0, 1920, 1080);
+sos.stream.onStop((event) => {
+    console.log('Stream stopped:', event.srcArguments.uri);
+});
+```
+
 <Separator />
 
 ### onTracksChanged()
 
-The `onTracksChanged()` method sets up a listener, which is called whenever a track is changed.
+The `onTracksChanged()` method sets up a listener, which is called whenever a track is changed
+from functions `selectTrack()` or `resetTrack()`.
 
 ```ts expandable
 onTracksChanged(listener: (event: IStreamTracksChangedEvent) => void): void;
 // show-more
+/**
+ * Stream Tracks Changed Event which is emitted when new track is selected or active track resets.
+ */
 interface IStreamTracksChangedEvent extends IStreamEvent<'tracks_changed'> {
+    /**
+     * Additional info about the track which has occurred the event.
+     */
     tracks: ITrackInfo[] | undefined;
 }
 
@@ -702,33 +1408,85 @@ interface ITrackVideoInfo extends ITrack<'VIDEO'> {
     };
 }
 
+/**
+ * Interface representing stream track information.
+ */
 interface ITrack<T extends TrackType> {
+    /**
+     * Type of the track, e.g., "VIDEO", "AUDIO", "TEXT".
+     */
     trackType: T;
+    /**
+     * MIME type of the track, e.g., "video/mp4", "audio/mp3", "text/vtt".
+     */
     mimeType: string;
+    /**
+     * Unique identifier for the track group.
+     * This is used to group tracks of the same type (e.g., multiple audio tracks).
+     */
     groupId: string;
+    /**
+     * Unique identifier for the track.
+     */
     trackIndex: number;
+    /**
+     * If the track is selected for playback.
+     */
     selected: boolean;
+    /**
+     * Selected language of subtitles or captions.
+     */
     language: string | null;
+    /**
+     * If the track is supported by the device.
+     */
     supported: boolean;
 }
 
+/**
+ * Available track types for media streams.
+ */
 type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
 
 interface ITrackAudioInfo extends ITrack<'AUDIO'> {
+    /**
+     * Number of audio channels.
+     */
     channelCount: number;
 }
 
 interface ITrackTextInfo extends ITrack<'TEXT'> {
+    /**
+     * Selected subtitles or captions.
+     */
     selection: string[];
 }
 
+/**
+ * Generic interface for stream events.
+ */
 interface IStreamEvent<T extends StreamEventType> {
+    /**
+     * Type of the event.
+     * @see {@link StreamEventType}
+     */
     type: T;
+    /**
+     * Additional stream properties that are relevant to the event.
+     * If there is more than one stream active, this will contain the properties of the stream that emitted the event.
+     */
     srcArguments: IStreamEventProperties;
 }
 
+/**
+ * List of all possible stream event types.
+ */
 type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
 
+/**
+ * Returned properties of stream events that occur on stream events:
+ * connected, disconnected, error, stop, tracks_changed
+ */
 interface IStreamEventProperties {
     uri: string;
     x: number;
@@ -737,25 +1495,57 @@ interface IStreamEventProperties {
     height: number;
     protocol?: keyof typeof StreamProtocol | string;
     /**
-     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     * @deprecated Events should not return options objects. Instead, they should return protocol {@link protocol}
      */
     options?: IStreamOptions | IStreamPrepareOptions;
 }
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -774,9 +1564,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -789,56 +1588,193 @@ type AnyString = string & {};
 
 ```
 
+#### Params
+
+| Name       | Type                                         | Description                                               |
+|------------|----------------------------------------------|-----------------------------------------------------------|
+| `listener` | `(event: IStreamTracksChangedEvent) => void` | The listener function to be called when the event occurs. |
+
+#### Return value
+
+Resolves when the listener is successfully set up.
+
+#### Example
+
+```ts
+// Example of setting up a listener with starting a stream and selecting a track
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+await sos.stream.selectTrack(videoId, 'AUDIO', 'audioGroup1', 0);
+
+// Create the listener for tracks changed event
+sos.stream.onTracksChanged((event) => {
+    console.log('Track type:', event.tracks[0].trackType); // AUDIO
+    console.log('Track group ID:', event.tracks[0].groupId); // audioGroup1
+    console.log('Track index:', event.tracks[0].trackIndex); // 0
+});
+```
+
 <Separator />
 
 ### pause()
 
-The `pause()` method pauses the stream, it can be resumed with `resume()`.
+The `pause()` method pauses the active stream, it can be resumed with `resume()`.
 
 ```ts expandable
 pause(uri: string, x: number, y: number, width: number, height: number): Promise<void>;
 ```
 
+#### Params
+
+| Name     | Type     | Description                                    |
+|----------|----------|------------------------------------------------|
+| `uri`    | `string` | Network address where the stream is available. |
+| `x`      | `number` | Stream x-position on the screen                |
+| `y`      | `number` | Stream y-position on the screen                |
+| `width`  | `number` | Stream width on the screen                     |
+| `height` | `number` | Stream height on the screen                    |
+
+#### Return value
+
+Returns a promise that resolves when the stream is paused.
+
+#### Possible errors
+
+Error If parameters are invalid.
+
+#### Example
+
+```ts
+// Example of pausing an active stream
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080); // Start
+// ... after some time
+await sos.stream.pause('http://example.com/stream', 0, 0, 1920, 1080); // Pause
+```
+
 <Separator />
 
 ### play()
 
-The `play()` method starts the streaming of a streaming previously prepared by `prepare()` method.
+The `play()` method starts the video stream based by uri or stream which was prepared by `prepare()` method.
+
+:::note Internal ports
+This method use same functionality, instead of URL (for stream), specify a URI of the port to display.
+
+| Port URI value | Description |
+|-----------------|-------------|
+| `internal://hdmi<number>` | HDMI |
+| `internal://dp` | DisplayPort |
+| `internal://dvi` | DVI |
+| `internal://pc` | PC or VGA |
+
+`<number>` has to be a value between 1 - 4, depending on which of the available HDMI ports you want to use.
+:::
 
 ```ts expandable
 play(uri: string, x: number, y: number, width: number, height: number, options?: IStreamOptions | keyof typeof StreamProtocol): Promise<void>;
 // show-more
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
 ```
 
+#### Params
+
+| Name                   | Type                                                                      | Description                                    |
+|------------------------|---------------------------------------------------------------------------|------------------------------------------------|
+| `uri`                  | `string`                                                                  | Network address where the stream is available. |
+| `x`                    | `number`                                                                  | Stream x-position on the screen                |
+| `y`                    | `number`                                                                  | Stream y-position on the screen                |
+| `width`                | `number`                                                                  | Stream width on the screen                     |
+| `height`               | `number`                                                                  | Stream height on the screen                    |
+| `options` *(optional)* | `IStreamOptions \| "HLS" \| "RTP" \| "HTTP" \| "UDP" \| "RTMP" \| "RTSP"` | Additional options for the stream              |
+
+#### Return value
+
+Returns a promise that resolves when the stream is successfully started.
+
+#### Possible errors
+
+
+- AppletStreamError If the protocol is not a string or if the parameters are invalid.
+- Error If parameters are invalid.
+- Error If the device fails to prepare the stream.
+
+#### Example
+
+```ts
+// Example with specific protocol type
+await sos.stream.play(uri, x, y, width, height, { protocol: 'HTTP' });
+
+// Example with options - reconnect stream when it disconnects after 60 seconds
+await sos.stream.play(uri, x, y, width, height, { protocol: 'HTTP', autoReconnect: true, autoReconnectInterval: 60000 });
+
+// Example for playing HDMI port
+await sos.stream.play('internal://hdmi1', 0, 0, 1920, 1080, { protocol: 'RTP' });
+```
+
+:::note[GitHub Example]
+
+- [ How to create video Applet with for URL streams](https://github.com/signageos/applet-examples/tree/master/examples/content-js-api/stream)
+- [ How to create video Applet with HDMI port](https://github.com/signageos/applet-examples/tree/master/examples/content-js-api/stream-hdmi-port)
+
+:::
+
 <Separator />
 
 ### prepare()
 
-The `prepare()` method prepares the stream in the background.
+Calls the internal player and prepares a video stream in memory, so it can later start playing instantaneously.
 
 :::info
-
 If you want to play a video stream in full screen mode, use x = y = 0 and width = document.documentElement.clientWidth and height = document.documentElement.clientHeight as setup parameters.
-
 :::
 
 ```ts expandable
 prepare(uri: string, x: number, y: number, width: number, height: number, options?: IStreamPrepareOptions | keyof typeof StreamProtocol): Promise<void>;
 // show-more
+/**
+ * Available options for stream function `prepare()`.
+ */
 interface IStreamPrepareOptions extends IStreamOptions {
+    /**
+     * Track selection for subtitles, audio, and video.
+     */
     trackSelection?: {
         /** Maximum number of audio channels to play */
         maxAudioChannelCount?: number;
@@ -857,9 +1793,18 @@ interface IStreamPrepareOptions extends IStreamOptions {
         /** Preferred text languages to play */
         preferredTextLanguages?: string[];
     };
+    /**
+     * DRM (Digital Rights Management) options for the stream.
+     */
     drm?: {
         scheme: DrmScheme;
+        /**
+         * URI to the license server.
+         */
         licenseUri: string;
+        /**
+         * Additional headers to include in the license request.
+         */
         licenseRequestHeaders: {
             [key: string]: string;
         };
@@ -870,24 +1815,85 @@ type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyStrin
 
 type AnyString = string & {};
 
+/**
+ * Available options for stream function `play()`.
+ */
 interface IStreamOptions extends IOptions {
+    /**
+     * Protocol that the stream is using.
+     *
+     * Note: Not all protocols are supported by all devices.
+     *
+     * Allowed values are: HLS, RTP, HTTP, UDP, RTMP, RTSP
+     */
     protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * Automatically reconnect stream when it disconnects.
+     * @default false
+     */
     autoReconnect?: boolean;
+    /**
+     * Interval in milliseconds between reconnect attempts.
+     * @default 30000
+     */
     autoReconnectInterval?: number;
 }
 
 interface IOptions {
     /** @deprecated */
     '4k'?: boolean;
+    /**
+     * Prepare stream or video in background.
+     * @default false
+     */
     background?: boolean;
+    /**
+     * Initial volume value of the stream.
+     * @default 100
+     */
     volume?: number;
 }
 
 ```
 
+#### Params
+
+| Name                   | Type                                                                             | Description                                    |
+|------------------------|----------------------------------------------------------------------------------|------------------------------------------------|
+| `uri`                  | `string`                                                                         | Network address where the stream is available. |
+| `x`                    | `number`                                                                         | Stream x-position on the screen                |
+| `y`                    | `number`                                                                         | Stream y-position on the screen                |
+| `width`                | `number`                                                                         | Stream width on the screen                     |
+| `height`               | `number`                                                                         | Stream height on the screen                    |
+| `options` *(optional)* | `IStreamPrepareOptions \| "HLS" \| "RTP" \| "HTTP" \| "UDP" \| "RTMP" \| "RTSP"` | Additional options for the stream              |
+
+#### Return value
+
+Returns a promise that resolves when the stream is prepared.
+
+#### Possible errors
+
+
+- AppletStreamError If the protocol is not a string or if the parameters are invalid.
+- Error If parameters are invalid.
+- Error If device fail to prepare the stream.
+
+#### Example
+
+```ts
+// Example with specific protocol type
+await sos.stream.prepare(uri, x, y, width, height, { protocol: 'HTTP' });
+
+// Example with options - prepare stream in the background
+await sos.stream.prepare(uri, x, y, width, height, { protocol: 'HTTP', background: true });
+
+// Deprecated format
+await sos.stream.prepare(uri, x, y, width, height, 'HTTP');
+```
+
 :::note[GitHub Example]
 
-- [object Object]://github.com/signageos/applet-examples/tree/master/examples/content-js-api/stream
+- [ How to create video Applet with for streams](https://github.com/signageos/applet-examples/tree/master/examples/content-js-api/stream)
 
 :::
 
@@ -905,11 +1911,14 @@ removeEventListeners(): void;
 
 ### resetTrack()
 
-The `resetTrack()` method resets a track of a stream.
+The `resetTrack()` method resets a selected track of a stream.
 
 ```ts expandable
 resetTrack(videoId: IVideoProperties, trackType: TrackType, groupId?: string): Promise<void>;
 // show-more
+/**
+ * Video properties interface for defining the properties of a played video.
+ */
 interface IVideoProperties {
     uri: string;
     x: number;
@@ -918,29 +1927,88 @@ interface IVideoProperties {
     height: number;
 }
 
+/**
+ * Available track types for media streams.
+ */
 type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
 
 ```
 
+#### Params
+
+| Name                   | Type               | Description                                                                                      |
+|------------------------|--------------------|--------------------------------------------------------------------------------------------------|
+| `videoId`              | `IVideoProperties` | The video properties of the stream to reset track for.                                           |
+| `trackType`            | `TrackType`        | The type of the track to reset (e.g., 'TEXT', 'AUDIO', 'VIDEO').                                 |
+| `groupId` *(optional)* | `string`           | The group ID of the track to reset. If not provided, the first track in the group will be reset. |
+
+#### Return value
+
+Resolves when the track is successfully reset.
+
+#### Possible errors
+
+Error If parameters are invalid or if the track type is not supported.
+
+#### Example
+
+```ts
+// Example of resetting a track for a stream
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+// Reset the audio track in the group with ID 'audioGroup1'
+await sos.stream.resetTrack(videoId, 'AUDIO', 'audioGroup1');
+```
+
 <Separator />
 
 ### resume()
 
-The `resume()` method resumes the stream paused by `pause()`.
+The `resume()` method resumes the paused stream by `pause()` function.
 
 ```ts expandable
 resume(uri: string, x: number, y: number, width: number, height: number): Promise<void>;
 ```
 
+#### Params
+
+| Name     | Type     | Description                                    |
+|----------|----------|------------------------------------------------|
+| `uri`    | `string` | Network address where the stream is available. |
+| `x`      | `number` | Stream x-position on the screen                |
+| `y`      | `number` | Stream y-position on the screen                |
+| `width`  | `number` | Stream width on the screen                     |
+| `height` | `number` | Stream height on the screen                    |
+
+#### Return value
+
+Returns a promise that resolves when the stream is successfully resumed.
+
+#### Possible errors
+
+Error If parameters are invalid.
+
+#### Example
+
+```ts
+// Example of resuming a paused stream
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080); // Start
+await sos.stream.pause('http://example.com/stream', 0, 0, 1920, 1080); // Pause
+// ... after some time
+await sos.stream.resume('http://example.com/stream', 0, 0, 1920, 1080); // Resume
+```
+
 <Separator />
 
 ### selectTrack()
 
-The `selectTrack()` method selects a track of a stream.
+The `selectTrack()` method selects a text (subtitles), video or audio track of a stream.
 
 ```ts expandable
 selectTrack(videoId: IVideoProperties, trackType: TrackType, groupId: string, trackIndex: number): Promise<void>;
 // show-more
+/**
+ * Video properties interface for defining the properties of a played video.
+ */
 interface IVideoProperties {
     uri: string;
     x: number;
@@ -949,16 +2017,83 @@ interface IVideoProperties {
     height: number;
 }
 
+/**
+ * Available track types for media streams.
+ */
 type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
 
 ```
 
+#### Params
+
+| Name         | Type               | Description                                                       |
+|--------------|--------------------|-------------------------------------------------------------------|
+| `videoId`    | `IVideoProperties` | The video properties of the stream to select track for.           |
+| `trackType`  | `TrackType`        | The type of the track to select (e.g., 'TEXT', 'AUDIO', 'VIDEO'). |
+| `groupId`    | `string`           | The group ID of the track to select.                              |
+| `trackIndex` | `number`           | The index of the track to select within the group.                |
+
+#### Return value
+
+Resolves when the track is successfully selected.
+
+#### Possible errors
+
+Error If parameters are invalid or if the track type is not supported.
+
+#### Example
+
+```ts
+// Example of selecting a track for a stream
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080);
+
+// Select the first audio track in the group with ID 'audioGroup1'
+await sos.stream.selectTrack(videoId, 'AUDIO', 'audioGroup1', 0);
+// Select the first text track in the group with ID 'subtitlesGroup1'
+await sos.stream.selectTrack(videoId, 'TEXT', 'subtitlesGroup1', 0);
+// Select the first video track in the group with ID 'videoGroup1'
+await sos.stream.selectTrack(videoId, 'VIDEO', 'videoGroup1', 0);
+```
+
+:::note[GitHub Example]
+
+- [ How to set subtitles for a stream](https://github.com/signageos/applet-examples/tree/master/examples/content-js-api/stream-subtitles)
+
+:::
+
 <Separator />
 
 ### stop()
 
-The `stop()` method stops the stream, it can't be resumed with `resume()`.
+The `stop()` method stops the active stream, it can't be later resumed with `resume()`.
 
 ```ts expandable
 stop(uri: string, x: number, y: number, width: number, height: number): Promise<void>;
+```
+
+#### Params
+
+| Name     | Type     | Description                                    |
+|----------|----------|------------------------------------------------|
+| `uri`    | `string` | Network address where the stream is available. |
+| `x`      | `number` | Stream x-position on the screen                |
+| `y`      | `number` | Stream y-position on the screen                |
+| `width`  | `number` | Stream width on the screen                     |
+| `height` | `number` | Stream height on the screen                    |
+
+#### Return value
+
+Returns a promise that resolves when the stream is stopped.
+
+#### Possible errors
+
+Error If parameters are invalid.
+
+#### Example
+
+```ts
+// Example of stopping an active stream
+await sos.stream.play('http://example.com/stream', 0, 0, 1920, 1080); // Start
+// ... after some time
+await sos.stream.stop('http://example.com/stream', 0, 0, 1920, 1080); // Stop
 ```