Misc shim refactoring

ext/src/global.d.ts

@@ -3,6 +3,7 @@ declare const MIRRORING_APP_ID: string;
 declare const APPLICATION_NAME: string;
 declare const APPLICATION_VERSION: string;
 
+declare type Nullable<T> = T | null;
 
 declare interface Object {
     // eslint-disable-next-line @typescript-eslint/ban-types

ext/src/shim/cast/Session.ts

@@ -143,12 +143,12 @@ export default class Session {
         }
     })
 
-    public media: Media[];
-    public namespaces: Array<{ name: string }>;
-    public senderApps: SenderApplication[];
-    public status: SessionStatus;
-    public statusText: string | null;
-    public transportId: string;
+    media: Media[];
+    namespaces: Array<{ name: string }>;
+    senderApps: SenderApplication[];
+    status: SessionStatus;
+    statusText: Nullable<string>;
+    transportId: string;
 
     constructor(
             public sessionId: string
@@ -182,11 +182,11 @@ export default class Session {
     }
 
 
-    public addMediaListener(_mediaListener: MediaListener) {
+    addMediaListener(_mediaListener: MediaListener) {
         logger.info("STUB :: Session#addMediaListener");
     }
 
-    public addMessageListener(
+    addMessageListener(
             namespace: string
           , listener: MessageListener) {
 
@@ -205,18 +205,18 @@ export default class Session {
         });
     }
 
-    public addUpdateListener(listener: UpdateListener) {
+    addUpdateListener(listener: UpdateListener) {
         this.#updateListeners.add(listener);
     }
 
-    public leave(
+    leave(
             _successCallback?: SuccessCallback
           , _errorCallback?: ErrorCallback): void {
 
         logger.info("STUB :: Session#leave");
     }
 
-    public loadMedia(
+    loadMedia(
             loadRequest: LoadRequest
           , successCallback?: LoadSuccessCallback
           , errorCallback?: ErrorCallback): void {
@@ -274,7 +274,7 @@ export default class Session {
         });
     }
 
-    public queueLoad(
+    queueLoad(
             _queueLoadRequest: QueueLoadRequest
           , _successCallback?: LoadSuccessCallback
           , _errorCallback?: ErrorCallback): void {
@@ -282,25 +282,25 @@ export default class Session {
         logger.info("STUB :: Session#queueLoad");
     }
 
-    public removeMediaListener(_mediaListener: MediaListener): void {
+    removeMediaListener(_mediaListener: MediaListener): void {
         logger.info("STUB :: Session#removeMediaListener");
     }
 
-    public removeMessageListener(
+    removeMessageListener(
             namespace: string
           , listener: MessageListener): void {
 
         this.#messageListeners.get(namespace)?.delete(listener);
     }
 
-    public removeUpdateListener(
+    removeUpdateListener(
             _namespace: string
           , listener: UpdateListener): void {
 
         this.#updateListeners.delete(listener);
     }
 
-    public sendMessage(
+    sendMessage(
             namespace: string
           , message: {} | string
           , successCallback?: SuccessCallback
@@ -324,7 +324,7 @@ export default class Session {
         ]);
     }
 
-    public setReceiverMuted(
+    setReceiverMuted(
             muted: boolean
           , successCallback?: SuccessCallback
           , errorCallback?: ErrorCallback) {
@@ -336,7 +336,7 @@ export default class Session {
             .catch(errorCallback);
     }
 
-    public setReceiverVolumeLevel(
+    setReceiverVolumeLevel(
             newLevel: number
           , successCallback?: SuccessCallback
           , errorCallback?: ErrorCallback): void {
@@ -348,7 +348,7 @@ export default class Session {
             .catch(errorCallback);
     }
 
-    public stop(
+    stop(
             successCallback?: SuccessCallback
           , errorCallback?: ErrorCallback): void {
 

ext/src/shim/cast/dataClasses.ts

@@ -32,41 +32,41 @@ export class CredentialsData {
 export class DialRequest {
     constructor(
             public appName: string
-          , public launchParameter: (string | null) = null) {}
+          , public launchParameter: Nullable<string> = null) {}
 }
 
 
 export class Error {
     constructor(
             public code: string
-          , public description: (string | null) = null
+          , public description: Nullable<string> = null
           , public details: any = null) {}
 }
 
 
 export class Image {
-    public width: (number | null) = null;
-    public height: (number | null) = null;
+    width: Nullable<number> = null;
+    height: Nullable<number> = null;
 
     constructor(public url: string) {}
 }
 
 
 export class Receiver {
-    public displayStatus: (ReceiverDisplayStatus | null) = null;
-    public isActiveInput: (boolean | null) = null;
-    public receiverType: string = ReceiverType.CAST;
+    displayStatus: Nullable<ReceiverDisplayStatus> = null;
+    isActiveInput: Nullable<boolean> = null;
+    receiverType: string = ReceiverType.CAST;
 
     constructor(
             public label: string
           , public friendlyName: string
           , public capabilities: Capability[] = []
-          , public volume: (Volume | null) = null) {}
+          , public volume: Nullable<Volume> = null) {}
 }
 
 
 export class ReceiverDisplayStatus {
-    public showStop: (boolean | null) = null;
+    showStop: Nullable<boolean> = null;
 
     constructor(
             public statusText: string
@@ -75,15 +75,15 @@ export class ReceiverDisplayStatus {
 
 
 export class SenderApplication {
-    public packageId: (string | null) = null;
-    public url: (string | null) = null;
+    packageId: Nullable<string> = null;
+    url: Nullable<string> = null;
 
     constructor(public platform: string) {}
 }
 
 
 export class SessionRequest {
-    public language: (string | null) = null;
+    language: Nullable<string> = null;
 
     constructor(
             public appId: string
@@ -91,24 +91,24 @@ export class SessionRequest {
                                   , Capability.AUDIO_OUT ]
           , public requestSessionTimeout = (new Timeout()).requestSession
           , public androidReceiverCompatible = false
-          , public credentialsData: (CredentialsData | null) = null) {}
+          , public credentialsData: Nullable<CredentialsData> = null) {}
 }
 
 
 export class Timeout {
-    public leaveSession = 3000;
-    public requestSession = 60000;
-    public sendCustomMessage = 3000;
-    public setReceiverVolume = 3000;
-    public stopSession = 3000;
+    leaveSession = 3000;
+    requestSession = 60000;
+    sendCustomMessage = 3000;
+    setReceiverVolume = 3000;
+    stopSession = 3000;
 }
 
 
 export class Volume {
-    public controlType?: VolumeControlType;
-    public stepInterval?: number;
+    controlType?: VolumeControlType;
+    stepInterval?: number;
 
     constructor(
-            public level: (number | null) = null
-          , public muted: (boolean | null) = null) {}
+            public level: Nullable<number> = null
+          , public muted: Nullable<boolean> = null) {}
 }

ext/src/shim/cast/media/Media.ts

@@ -103,24 +103,24 @@ export default class Media {
         }
     });
 
-    public activeTrackIds: (number[] | null) = null;
-    public breakStatus?: BreakStatus;
-    public currentItemId: (number | null) = null;
-    public customData: any = null;
-    public currentTime = 0;
-    public idleReason: (string | null) = null;
-    public items: (QueueItem[] | null) = null;
-    public liveSeekableRange?: LiveSeekableRange;
-    public loadingItemId: (number | null) = null;
-    public media: (MediaInfo | null) = null;
-    public playbackRate = 1;
-    public playerState: string = PlayerState.IDLE;
-    public preloadedItemId: (number | null) = null;
-    public queueData?: QueueData;
-    public repeatMode: string = RepeatMode.OFF;
-    public supportedMediaCommands: string[] = [];
-    public videoInfo?: VideoInformation;
-    public volume: Volume = new Volume();
+    activeTrackIds: Nullable<number[]> = null;
+    breakStatus?: BreakStatus;
+    currentItemId: Nullable<number> = null;
+    customData: any = null;
+    currentTime = 0;
+    idleReason: Nullable<string> = null;
+    items: Nullable<QueueItem[]> = null;
+    liveSeekableRange?: LiveSeekableRange;
+    loadingItemId: Nullable<number> = null;
+    media: Nullable<MediaInfo> = null;
+    playbackRate = 1;
+    playerState: string = PlayerState.IDLE;
+    preloadedItemId: Nullable<number> = null;
+    queueData?: QueueData;
+    repeatMode: string = RepeatMode.OFF;
+    supportedMediaCommands: string[] = [];
+    videoInfo?: VideoInformation;
+    volume: Volume = new Volume();
 
 
     constructor(
@@ -139,14 +139,14 @@ export default class Media {
         });
     }
 
-    public addUpdateListener(listener: UpdateListener): void {
+    addUpdateListener(listener: UpdateListener) {
         this.#updateListeners.add(listener);
     }
 
-    public editTracksInfo(
+    editTracksInfo(
             editTracksInfoRequest: EditTracksInfoRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(
                 { type: "EDIT_TRACKS_INFO", ...editTracksInfoRequest })
@@ -154,26 +154,32 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public getEstimatedBreakClipTime() {
+    getEstimatedBreakClipTime() {
         logger.info("STUB :: Media#getEstimatedBreakClipTime");
     }
-    public getEstimatedBreakTime() {
+    getEstimatedBreakTime() {
         logger.info("STUB :: Media#getEstimatedBreakTime");
     }
-    public getEstimatedLiveSeekableRange() {
+    getEstimatedLiveSeekableRange() {
         logger.info("STUB :: Media#getEstimatedLiveSeekableRange");
     }
 
-    public getEstimatedTime(): number {
+    /**
+     * Estimate the current playback position based on the last
+     * time reported by the receiver and the current playback
+     * rate.
+     */
+    getEstimatedTime(): number {
         if (this.playerState === PlayerState.PLAYING) {
             let estimatedTime = this.currentTime + (this.playbackRate * (
                     Date.now() - this.#lastCurrentTime) / 1000);
 
             // Enforce valid range
-            if (this.media?.duration && estimatedTime > this.media.duration) {
-                estimatedTime = this.media.duration;
-            } else if (estimatedTime < 0) {
+            if (estimatedTime < 0) {
                 estimatedTime = 0;
+            } else if (this.media?.duration &&
+                    estimatedTime > this.media.duration) {
+                estimatedTime = this.media.duration;
             }
 
             return estimatedTime;
@@ -182,14 +188,14 @@ export default class Media {
         return this.currentTime;
     }
 
-    public getStatus(
-            getStatusRequest?: GetStatusRequest
+    /**
+     * Request media status from the receiver application. This
+     * will also trigger any added media update listeners.
+     */
+    getStatus(
+            getStatusRequest = new GetStatusRequest()
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
-        
-        if (!getStatusRequest) {
-            getStatusRequest = new GetStatusRequest();
-        }
+          , errorCallback?: ErrorCallback) {
         
         this.#sendMediaMessage(
                 { type: "MEDIA_GET_STATUS", ...getStatusRequest })
@@ -197,14 +203,10 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public pause(
-            pauseRequest?: PauseRequest
+    pause(  
+            pauseRequest = new PauseRequest()
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
-
-        if (!pauseRequest) {
-            pauseRequest = new PauseRequest();
-        }
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(
                 { type: "PAUSE", ...pauseRequest })
@@ -212,14 +214,10 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public play(
-            playRequest?: PlayRequest
+    play(   
+            playRequest = new PlayRequest()
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
-
-        if (!playRequest) {
-            playRequest = new PlayRequest();
-        }
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(
                 { type: "PLAY", ...playRequest })
@@ -227,20 +225,20 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public queueAppendItem(
+    queueAppendItem(
             item: QueueItem
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
         
         this.#sendMediaMessage(new QueueInsertItemsRequest([ item ]))
             .then(successCallback)
             .catch(errorCallback);
     }
 
-    public queueInsertItems(
+    queueInsertItems(
             queueInsertItemsRequest: QueueInsertItemsRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(queueInsertItemsRequest)
             .then(successCallback)
@@ -248,10 +246,10 @@ export default class Media {
         
     }
 
-    public queueJumpToItem(
+    queueJumpToItem(
             itemId: number
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         if (this.items?.find(item => item.itemId === itemId)) {
             const jumpRequest = new QueueJumpRequest();
@@ -263,12 +261,13 @@ export default class Media {
         }
     }
 
-    public queueMoveItemToNewIndex(
+    queueMoveItemToNewIndex(
             itemId: number
           , newIndex: number
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
+        // Return early if not in queue
         if (!this.items) {
             return;
         }
@@ -302,9 +301,9 @@ export default class Media {
         }
     }
 
-    public queueNext(
+    queueNext(
             successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         const jumpRequest = new QueueJumpRequest();
         jumpRequest.jump = 1;
@@ -314,9 +313,9 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public queuePrev(
+    queuePrev(
             successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         const jumpRequest = new QueueJumpRequest();
         jumpRequest.jump = -1;
@@ -326,46 +325,43 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public queueRemoveItem(
+    queueRemoveItem(
             itemId: number
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
         
         const item = this.items?.find(item => item.itemId === itemId);
         if (item) {
-            const queueRemoveItemsRequest =
-                    new QueueRemoveItemsRequest([ itemId ]);
-
-            this.#sendMediaMessage(queueRemoveItemsRequest)
-                    .then(successCallback)
-                    .catch(errorCallback);
+            this.queueRemoveItems(
+                    new QueueRemoveItemsRequest([ itemId ])
+                  , successCallback, errorCallback);
         }
     }
 
-    public queueRemoveItems(
+    queueRemoveItems(
             queueRemoveItemsRequest: QueueRemoveItemsRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
         
-            this.#sendMediaMessage(queueRemoveItemsRequest)
-                .then(successCallback)
-                .catch(errorCallback);
+        this.#sendMediaMessage(queueRemoveItemsRequest)
+            .then(successCallback)
+            .catch(errorCallback);
     }
 
-    public queueReorderItems(
+    queueReorderItems(
             queueReorderItemsRequest: QueueReorderItemsRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(queueReorderItemsRequest)
             .then(successCallback)
             .catch(errorCallback);
     }
 
-    public queueSetRepeatMode(
+    queueSetRepeatMode(
             repeatMode: string
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
         
         const setPropertiesRequest = new QueueSetPropertiesRequest();
         setPropertiesRequest.repeatMode = repeatMode;
@@ -375,24 +371,24 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public queueUpdateItems(
+    queueUpdateItems(
             queueUpdateItemsRequest: QueueUpdateItemsRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(queueUpdateItemsRequest)
             .then(successCallback)
             .catch(errorCallback);
     }
 
-    public removeUpdateListener(listener: UpdateListener) {
+    removeUpdateListener(listener: UpdateListener) {
         this.#updateListeners.delete(listener);
     }
 
-    public seek(
+    seek(
             seekRequest: SeekRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         this.#sendMediaMessage(
                 { type: "SEEK", ...seekRequest })
@@ -400,10 +396,10 @@ export default class Media {
             .catch(errorCallback);
     }
 
-    public setVolume(
+    setVolume(
             volumeRequest: VolumeRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
         
             this.#sendMediaMessage(
                     { type: "MEDIA_SET_VOLUME", ...volumeRequest })
@@ -411,10 +407,10 @@ export default class Media {
                 .catch(errorCallback);
     }
 
-    public stop(
+    stop(
             stopRequest?: StopRequest
           , successCallback?: SuccessCallback
-          , errorCallback?: ErrorCallback): void {
+          , errorCallback?: ErrorCallback) {
 
         if (!stopRequest) {
             stopRequest = new StopRequest();
@@ -433,7 +429,7 @@ export default class Media {
         }).catch(errorCallback);
     }
 
-    public supportsCommand(command: string): boolean {
+    supportsCommand(command: string): boolean {
         return this.supportedMediaCommands.includes(command);
     }
 

ext/src/shim/cast/media/dataClasses.ts

@@ -13,28 +13,28 @@ import { ContainerType
 
 
 export class AudiobookChapterMediaMetadata {
-    public bookTitle?: string;
-    public chapterNumber?: number;
-    public chapterTitle?: string;
-    public images?: Image[];
-    public subtitle?: string;
-    public title?: string;
-    public type = MetadataType.AUDIOBOOK_CHAPTER;
+    bookTitle?: string;
+    chapterNumber?: number;
+    chapterTitle?: string;
+    images?: Image[];
+    subtitle?: string;
+    title?: string;
+    type = MetadataType.AUDIOBOOK_CHAPTER;
 }
 
 
 export class AudiobookContainerMetadata {
-    public authors?: string[];
-    public narrators?: string[];
-    public publisher?: string;
-    public releaseDate?: string;
+    authors?: string[];
+    narrators?: string[];
+    publisher?: string;
+    releaseDate?: string;
 }
 
 
 export class Break {
-    public duration?: number;
-    public isEmbedded?: boolean;
-    public isWatched = false;
+    duration?: number;
+    isEmbedded?: boolean;
+    isWatched = false;
 
     constructor(
             public id: string
@@ -44,36 +44,36 @@ export class Break {
 
 
 export class BreakClip {
-    public clickThroughUrl?: string;
-    public contentId?: string;
-    public contentType?: string;
-    public contentUrl?: string;
-    public customData?: {};
-    public duration?: number;
-    public hlsSegmentFormat?: HlsSegmentFormat;
-    public posterUrl?: string;
-    public title?: string;
-    public vastAdsRequest?: VastAdsRequest;
-    public whenSkippable?: number;
+    clickThroughUrl?: string;
+    contentId?: string;
+    contentType?: string;
+    contentUrl?: string;
+    customData?: {};
+    duration?: number;
+    hlsSegmentFormat?: HlsSegmentFormat;
+    posterUrl?: string;
+    title?: string;
+    vastAdsRequest?: VastAdsRequest;
+    whenSkippable?: number;
 
     constructor(public id: string) {}
 }
 
 
 export class BreakStatus {
-    public breakClipId?: string;
-    public breakId?: string;
-    public currentBreakClipTime?: number;
-    public currentBreakTime?: number;
-    public whenSkippable?: number;
+    breakClipId?: string;
+    breakId?: string;
+    currentBreakClipTime?: number;
+    currentBreakTime?: number;
+    whenSkippable?: number;
 }
 
 
 export class ContainerMetadata {
-    public containerDuration?: number;
-    public containerImages?: Image[];
-    public sections?: MediaMetadata[];
-    public title?: string;
+    containerDuration?: number;
+    containerImages?: Image[];
+    sections?: MediaMetadata[];
+    title?: string;
 
     constructor(
             public containerType: ContainerType =
@@ -82,28 +82,28 @@ export class ContainerMetadata {
 
 
 export class EditTracksInfoRequest {
-    public requestId = 0;
+    requestId = 0;
 
     constructor(
-            public activeTrackIds: (number[] | null) = null
-          , public textTrackStyle: (string | null) = null) {
+            public activeTrackIds: Nullable<number[]> = null
+          , public textTrackStyle: Nullable<string> = null) {
     }
 }
 
 
 export class GenericMediaMetadata {
-    public images: (Image[] | undefined) = undefined;
-    public metadataType: number = MetadataType.GENERIC;
-    public releaseDate: (string | undefined) = undefined;
-    public releaseYear: (number | undefined) = undefined;
-    public subtitle: (string | undefined) = undefined;
-    public title: (string | undefined) = undefined;
-    public type: number = MetadataType.GENERIC;
+    images?: Image[];
+    metadataType: number = MetadataType.GENERIC;
+    releaseDate?: string;
+    releaseYear?: number;
+    subtitle?: string;
+    title?: string;
+    type: number = MetadataType.GENERIC;
 }
 
 
 export class GetStatusRequest {
-    public customData: any = null;
+    customData: any = null;
 }
 
 
@@ -117,16 +117,16 @@ export class LiveSeekableRange {
 
 
 export class LoadRequest {
-    public activeTrackIds: (number[] | null) = null;
-    public atvCredentials?: string;
-    public atvCredentialsType?: string;
-    public autoplay: (boolean | null) = true;
-    public currentTime: (number | null) = null;
-    public customData: any = null;
-    public media: MediaInfo;
-    public requestId = 0;
-    public sessionId: (string | null) = null;
-    public type = "LOAD";
+    activeTrackIds: Nullable<number[]> = null;
+    atvCredentials?: string;
+    atvCredentialsType?: string;
+    autoplay: Nullable<boolean> = true;
+    currentTime: Nullable<number> = null;
+    customData: any = null;
+    media: MediaInfo;
+    requestId = 0;
+    sessionId: Nullable<string> = null;
+    type = "LOAD";
 
     constructor(mediaInfo: MediaInfo) {
         this.media = mediaInfo;
@@ -142,22 +142,22 @@ type Metadata =
       | TvShowMediaMetadata;
 
 export class MediaInfo {
-    public atvEntity?: string;
-    public breakClips?: BreakClip[];
-    public breaks?: Break[];
-    public customData: any = null;
-    public contentUrl?: string;
-    public duration: (number | null) = null;
-    public entity?: string;
-    public hlsSegmentFormat?: HlsSegmentFormat;
-    public hlsVideoSegmentFormat?: HlsVideoSegmentFormat;
-    public metadata: (Metadata | null) = null;
-    public startAbsoluteTime?: number;
-    public streamType: string = StreamType.BUFFERED;
-    public textTrackStyle: (TextTrackStyle | null) = null;
-    public tracks: (Track[] | null) = null;
-    public userActionStates?: UserActionState[];
-    public vmapAdsRequest?: VastAdsRequest;
+    atvEntity?: string;
+    breakClips?: BreakClip[];
+    breaks?: Break[];
+    customData: any = null;
+    contentUrl?: string;
+    duration: Nullable<number> = null;
+    entity?: string;
+    hlsSegmentFormat?: HlsSegmentFormat;
+    hlsVideoSegmentFormat?: HlsVideoSegmentFormat;
+    metadata: Nullable<Metadata> = null;
+    startAbsoluteTime?: number;
+    streamType: string = StreamType.BUFFERED;
+    textTrackStyle: Nullable<TextTrackStyle> = null;
+    tracks: Nullable<Track[]> = null;
+    userActionStates?: UserActionState[];
+    vmapAdsRequest?: VastAdsRequest;
 
     constructor(
             public contentId: string
@@ -166,13 +166,13 @@ export class MediaInfo {
 
 
 export class MediaMetadata {
-    public queueItemId?: number;
-    public sectionDuration?: number;
-    public sectionStartAbsoluteTime?: number;
-    public sectionStartTimeInContainer?: number;
-    public sectionStartTimeInMedia?: number;
-    public type: MetadataType;
-    public metadataType: MetadataType;
+    queueItemId?: number;
+    sectionDuration?: number;
+    sectionStartAbsoluteTime?: number;
+    sectionStartTimeInContainer?: number;
+    sectionStartTimeInMedia?: number;
+    type: MetadataType;
+    metadataType: MetadataType;
 
     constructor(type: MetadataType) {
         this.type = type;
@@ -182,62 +182,62 @@ export class MediaMetadata {
 
 
 export class MovieMediaMetadata {
-    public images: (Image[] | undefined) = undefined;
-    public metadataType: number = MetadataType.MOVIE;
-    public releaseDate: (string | undefined) = undefined;
-    public releaseYear: (number | undefined) = undefined;
-    public studio: (string | undefined) = undefined;
-    public subtitle: (string | undefined) = undefined;
-    public title: (string | undefined) = undefined;
-    public type: number = MetadataType.MOVIE;
+    images?: Image[];
+    metadataType: number = MetadataType.MOVIE;
+    releaseDate?: string;
+    releaseYear?: number;
+    studio?: string;
+    subtitle?: string;
+    title?: string;
+    type: number = MetadataType.MOVIE;
 }
 
 
 export class MusicTrackMediaMetadata {
-    public albumArtist: (string | undefined) = undefined;
-    public albumName: (string | undefined) = undefined;
-    public artist: (string | undefined) = undefined;
-    public artistName: (string | undefined) = undefined;
-    public composer: (string | undefined) = undefined;
-    public discNumber: (number | undefined) = undefined;
-    public images: (Image[] | undefined) = undefined;
-    public metadataType: number = MetadataType.MUSIC_TRACK;
-    public releaseDate: (string | undefined) = undefined;
-    public releaseYear: (number | undefined) = undefined;
-    public songName: (string | undefined) = undefined;
-    public title: (string | undefined) = undefined;
-    public trackNumber: (number | undefined) = undefined;
-    public type: number = MetadataType.MUSIC_TRACK;
+    albumArtist?: string;
+    albumName?: string;
+    artist?: string;
+    artistName?: string;
+    composer?: string;
+    discNumber?: number;
+    images?: Image[];
+    metadataType: number = MetadataType.MUSIC_TRACK;
+    releaseDate?: string;
+    releaseYear?: number;
+    songName?: string;
+    title?: string;
+    trackNumber?: number;
+    type: number = MetadataType.MUSIC_TRACK;
 }
 
 
 export class PauseRequest {
-    public customData: any = null;
+    customData: any = null;
 }
 
 
 export class PhotoMediaMetadata {
-    public artist: (string | undefined) = undefined;
-    public creationDateTime: (string | undefined) = undefined;
-    public height: (number | undefined) = undefined;
-    public images: (Image[] | undefined) = undefined;
-    public latitude: (number | undefined) = undefined;
-    public location: (string | undefined) = undefined;
-    public longitude: (number | undefined) = undefined;
-    public metadataType: number = MetadataType.PHOTO;
-    public title: (string | undefined) = undefined;
-    public type: number = MetadataType.PHOTO;
-    public width: (number | undefined) = undefined;
+    artist?: string;
+    creationDateTime?: string;
+    height?: number;
+    images?: Image[];
+    latitude?: number;
+    location?: string;
+    longitude?: number;
+    metadataType: number = MetadataType.PHOTO;
+    title?: string;
+    type: number = MetadataType.PHOTO;
+    width?: number;
 }
 
 
 export class PlayRequest {
-    public customData: any = null;
+    customData: any = null;
 }
 
 
 export class QueueData {
-    public shuffle = false;
+    shuffle = false;
 
     constructor(
             public id?: string
@@ -251,11 +251,11 @@ export class QueueData {
 
 
 export class QueueInsertItemsRequest {
-    public customData: any = null;
-    public insertBefore: (number | null) = null;
-    public requestId: (number | null) = null;
-    public sessionId: (string | null) = null;
-    public type = "QUEUE_INSERT";
+    customData: any = null;
+    insertBefore: Nullable<number> = null;
+    requestId: Nullable<number> = null;
+    sessionId: Nullable<string> = null;
+    type = "QUEUE_INSERT";
 
     constructor(
             public items: QueueItem[]) {}
@@ -263,14 +263,14 @@ export class QueueInsertItemsRequest {
 
 
 export class QueueItem {
-    public activeTrackIds: (number[] | null) = null;
-    public autoplay = true;
-    public customData: any = null;
-    public itemId: (number | null) = null;
-    public media: MediaInfo;
-    public playbackDuration: (number | null) = null;
-    public preloadTime = 0;
-    public startTime = 0;
+    activeTrackIds: Nullable<number[]> = null;
+    autoplay = true;
+    customData: any = null;
+    itemId: Nullable<number> = null;
+    media: MediaInfo;
+    playbackDuration: Nullable<number> = null;
+    preloadTime = 0;
+    startTime = 0;
 
     constructor(mediaInfo: MediaInfo) {
         this.media = mediaInfo;
@@ -279,22 +279,22 @@ export class QueueItem {
 
 
 export class QueueJumpRequest {
-    public jump: (number | null) = null;
-    public currentItemId: (number | null) = null;
-    public sessionId: (number | null) = null;
-    public requestId: (number | null) = null;
+    jump: Nullable<number> = null;
+    currentItemId: Nullable<number> = null;
+    sessionId: Nullable<number> = null;
+    requestId: Nullable<number> = null;
 
-    public type = "QUEUE_UPDATE";
+    type = "QUEUE_UPDATE";
 }
 
 
 export class QueueLoadRequest {
-    public customData: any = null;
-    public repeatMode: string = RepeatMode.OFF;
-    public requestId: (number | null) = null;
-    public sessionId: (string | null) = null;
-    public startIndex = 0;
-    public type = "QUEUE_LOAD";
+    customData: any = null;
+    repeatMode: string = RepeatMode.OFF;
+    requestId: Nullable<number> = null;
+    sessionId: Nullable<string> = null;
+    startIndex = 0;
+    type = "QUEUE_LOAD";
 
     constructor(
             public items: QueueItem[]) {}
@@ -302,10 +302,10 @@ export class QueueLoadRequest {
 
 
 export class QueueRemoveItemsRequest {
-    public customData: any = null;
-    public requestId: (number | null) = null;
-    public sessionId: (string | null) = null;
-    public type = "QUEUE_REMOVE";
+    customData: any = null;
+    requestId: Nullable<number> = null;
+    sessionId: Nullable<string> = null;
+    type = "QUEUE_REMOVE";
 
     constructor(
             public itemIds: number[]) {}
@@ -313,11 +313,11 @@ export class QueueRemoveItemsRequest {
 
 
 export class QueueReorderItemsRequest {
-    public customData: any = null;
-    public insertBefore: (number | null) = null;
-    public requestId: (number | null) = null;
-    public sessionId: (string | null) = null;
-    public type = "QUEUE_REORDER";
+    customData: any = null;
+    insertBefore: Nullable<number> = null;
+    requestId: Nullable<number> = null;
+    sessionId: Nullable<string> = null;
+    type = "QUEUE_REORDER";
 
     constructor(
             public itemIds: number[]) {}
@@ -325,19 +325,19 @@ export class QueueReorderItemsRequest {
 
 
 export class QueueSetPropertiesRequest {
-    public customData: any = null;
-    public repeatMode: (string | null) = null;
-    public requestId: (number | null) = null;
-    public sessionId: (string | null) = null;
-    public type = "QUEUE_UPDATE";
+    customData: any = null;
+    repeatMode: Nullable<string> = null;
+    requestId: Nullable<number> = null;
+    sessionId: Nullable<string> = null;
+    type = "QUEUE_UPDATE";
 }
 
 
 export class QueueUpdateItemsRequest {
-    public customData: any = null;
-    public requestId: (number | null) = null;
-    public sessionId: (string | null) = null;
-    public type = "QUEUE_UPDATE";
+    customData: any = null;
+    requestId: Nullable<number> = null;
+    sessionId: Nullable<string> = null;
+    type = "QUEUE_UPDATE";
 
     constructor(
             public items: QueueItem[]) {}
@@ -345,40 +345,40 @@ export class QueueUpdateItemsRequest {
 
 
 export class SeekRequest {
-    public currentTime: (number | null) = null;
-    public customData: any = null;
-    public resumeState: (string | null) = null;
+    currentTime: Nullable<number> = null;
+    customData: any = null;
+    resumeState: Nullable<string> = null;
 }
 
 
 export class StopRequest {
-    public customData: any = null;
+    customData: any = null;
 }
 
 
 export class TextTrackStyle {
-    public backgroundColor: (string | null) = null;
-    public customData: any = null;
-    public edgeColor: (string | null) = null;
-    public edgeType: (string | null) = null;
-    public fontFamily: (string | null) = null;
-    public fontGenericFamily: (string | null) = null;
-    public fontScale: (number | null) = null;
-    public fontStyle: (string | null) = null;
-    public foregroundColor: (string | null) = null;
-    public windowColor: (string | null) = null;
-    public windowRoundedCornerRadius: (number | null) = null;
-    public windowType: (string | null) = null;
+    backgroundColor: Nullable<string> = null;
+    customData: any = null;
+    edgeColor: Nullable<string> = null;
+    edgeType: Nullable<string> = null;
+    fontFamily: Nullable<string> = null;
+    fontGenericFamily: Nullable<string> = null;
+    fontScale: Nullable<number> = null;
+    fontStyle: Nullable<string> = null;
+    foregroundColor: Nullable<string> = null;
+    windowColor: Nullable<string> = null;
+    windowRoundedCornerRadius: Nullable<number> = null;
+    windowType: Nullable<string> = null;
 }
 
 
 export class Track {
-    public customData: any = null;
-    public language: (string | null) = null;
-    public name: (string | null) = null;
-    public subtype: (string | null) = null;
-    public trackContentId: (string | null) = null;
-    public trackContentType: (string | null) = null;
+    customData: any = null;
+    language: Nullable<string> = null;
+    name: Nullable<string> = null;
+    subtype: Nullable<string> = null;
+    trackContentId: Nullable<string> = null;
+    trackContentType: Nullable<string> = null;
 
     constructor(
             public trackId: number
@@ -387,23 +387,23 @@ export class Track {
 
 
 export class TvShowMediaMetadata {
-    public episode: (number | undefined) = undefined;
-    public episodeNumber: (number | undefined) = undefined;
-    public episodeTitle: (string | undefined) = undefined;
-    public images: (Image[] | undefined) = undefined;
-    public metadataType: number = MetadataType.TV_SHOW;
-    public originalAirdate: (string | undefined) = undefined;
-    public releaseYear: (number | undefined) = undefined;
-    public season: (number | undefined) = undefined;
-    public seasonNumber: (number | undefined) = undefined;
-    public seriesTitle: (string | undefined) = undefined;
-    public title: (string | undefined) = undefined;
-    public type: number = MetadataType.TV_SHOW;
+    episode?: number;
+    episodeNumber?: number;
+    episodeTitle?: string;
+    images?: Image[];
+    metadataType: number = MetadataType.TV_SHOW;
+    originalAirdate?: string;
+    releaseYear?: number;
+    season?: number;
+    seasonNumber?: number;
+    seriesTitle?: string;
+    title?: string;
+    type: number = MetadataType.TV_SHOW;
 }
 
 
 export class UserActionState {
-    public customData: any = null;
+    customData: any = null;
 
     constructor(
             public userAction: UserAction) {}
@@ -411,8 +411,8 @@ export class UserActionState {
 
 
 export class VastAdsRequest {
-    public adsResponse?: string;
-    public adTagUrl?: string;
+    adsResponse?: string;
+    adTagUrl?: string;
 }
 
 
@@ -425,7 +425,7 @@ export class VideoInformation {
 
 
 export class VolumeRequest {
-    public customData: any = null;
+    customData: any = null;
 
     constructor(
             public volume: Volume) {}