@amazon/vinyl 1.0.0

package/dist/vinylTestUtil/types/ts3.7/mock/dom/ms/MockMSMediaKeyError.d.ts

@@ -0,0 +1,13 @@
+import { MockEvent } from '@amazon/vinyl-util/browserTestUtil';
+export declare class MockMSMediaKeyError extends MockEvent implements MSMediaKeyError {
+    static readonly MS_MEDIA_KEYERR_CLIENT = 1;
+    static readonly MS_MEDIA_KEYERR_DOMAIN = 2;
+    static readonly MS_MEDIA_KEYERR_HARDWARECHANGE = 3;
+    static readonly MS_MEDIA_KEYERR_OUTPUT = 4;
+    static readonly MS_MEDIA_KEYERR_SERVICE = 5;
+    static readonly MS_MEDIA_KEYERR_UNKNOWN = 6;
+    code: number;
+    systemCode: number;
+    constructor();
+}
+//# sourceMappingURL=MockMSMediaKeyError.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/ms/MockMSMediaKeyMessageEvent.d.ts

@@ -0,0 +1,7 @@
+import { MSMediaKeyMessageEvent } from '@amazon/vinyl';
+import { MockEvent } from '@amazon/vinyl-util/browserTestUtil';
+export declare class MockMSMediaKeyMessageEvent extends MockEvent implements MSMediaKeyMessageEvent {
+    message: Uint8Array;
+    constructor();
+}
+//# sourceMappingURL=MockMSMediaKeyMessageEvent.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/ms/MockMSMediaKeySession.d.ts

@@ -0,0 +1,21 @@
+import { MockEventTarget } from '@amazon/vinyl-util/browserTestUtil';
+export declare class MockMSMediaKeySession extends MockEventTarget implements MSMediaKeySession {
+    error: MSMediaKeyError | null;
+    keySystem: string;
+    onmskeyadded: null;
+    onmskeyerror: null;
+    onmskeymessage: null;
+    sessionId: string;
+    close: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    update: import("@amazon/vinyl-util/browserTestUtil").Spy2<(key: Uint8Array) => void>;
+    addEventListener: import("@amazon/vinyl-util/browserTestUtil").Spy2<{
+        <K extends keyof import("@amazon/vinyl").MSMediaKeySessionEventMap>(type: K, listener: (this: MSMediaKeySession, ev: import("@amazon/vinyl").MSMediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    }>;
+    dispatchEvent: import("@amazon/vinyl-util/browserTestUtil").Spy2<((event: Event) => boolean) & ((event: Event) => any)>;
+    removeEventListener: import("@amazon/vinyl-util/browserTestUtil").Spy2<{
+        <K extends keyof import("@amazon/vinyl").MSMediaKeySessionEventMap>(type: K, listener: (this: MSMediaKeySession, ev: import("@amazon/vinyl").MSMediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    }>;
+}
+//# sourceMappingURL=MockMSMediaKeySession.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/ms/MockMSMediaKeys.d.ts

@@ -0,0 +1,8 @@
+import { DrmKeySystem } from '@amazon/vinyl';
+export declare class MockMSMediaKeys implements MSMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    constructor(keySystem: DrmKeySystem);
+    createSession: import("@amazon/vinyl-util/browserTestUtil").Spy2<((type: string, initData: Uint8Array) => MSMediaKeySession) & ((type: string, initData: Uint8Array) => any)>;
+    static isTypeSupported: import("@amazon/vinyl-util/browserTestUtil").Spy2<typeof MSMediaKeys.isTypeSupported & ((keySystem: string, type?: import("@amazon/vinyl-util").Maybe<string>) => any)>;
+}
+//# sourceMappingURL=MockMSMediaKeys.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/webkit/MockWebKitMediaKeyError.d.ts

@@ -0,0 +1,13 @@
+import { MockEvent } from '@amazon/vinyl-util/browserTestUtil';
+export declare class MockWebKitMediaKeyError extends MockEvent implements WebKitMediaKeyError {
+    static readonly MEDIA_KEYERR_UNKNOWN = 1;
+    static readonly MEDIA_KEYERR_CLIENT = 2;
+    static readonly MEDIA_KEYERR_SERVICE = 3;
+    static readonly MEDIA_KEYERR_OUTPUT = 4;
+    static readonly MEDIA_KEYERR_HARDWARECHANGE = 5;
+    static readonly MEDIA_KEYERR_DOMAIN = 6;
+    code: number;
+    systemCode: number;
+    constructor();
+}
+//# sourceMappingURL=MockWebKitMediaKeyError.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/webkit/MockWebKitMediaKeyMessageEvent.d.ts

@@ -0,0 +1,7 @@
+import { WebKitMediaKeyMessageEvent } from '@amazon/vinyl';
+import { MockEvent } from '@amazon/vinyl-util/browserTestUtil';
+export declare class MockWebKitMediaKeyMessageEvent extends MockEvent implements WebKitMediaKeyMessageEvent {
+    message: Uint8Array;
+    constructor();
+}
+//# sourceMappingURL=MockWebKitMediaKeyMessageEvent.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/webkit/MockWebKitMediaKeySession.d.ts

@@ -0,0 +1,21 @@
+import { MockEventTarget } from '@amazon/vinyl-util/browserTestUtil';
+export declare class MockWebKitMediaKeySession extends MockEventTarget implements WebKitMediaKeySession {
+    error: WebKitMediaKeyError | null;
+    keySystem: string;
+    onwebkitkeyadded: null;
+    onwebkitkeyerror: null;
+    onwebkitkeymessage: null;
+    sessionId: string;
+    close: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    update: import("@amazon/vinyl-util/browserTestUtil").Spy2<(key: Uint8Array) => void>;
+    addEventListener: import("@amazon/vinyl-util/browserTestUtil").Spy2<{
+        <K extends keyof import("@amazon/vinyl").WebKitMediaKeySessionEventMap>(type: K, listener: (this: WebKitMediaKeySession, ev: import("@amazon/vinyl").WebKitMediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    }>;
+    dispatchEvent: import("@amazon/vinyl-util/browserTestUtil").Spy2<((event: Event) => boolean) & ((event: Event) => any)>;
+    removeEventListener: import("@amazon/vinyl-util/browserTestUtil").Spy2<{
+        <K extends keyof import("@amazon/vinyl").WebKitMediaKeySessionEventMap>(type: K, listener: (this: WebKitMediaKeySession, ev: import("@amazon/vinyl").WebKitMediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    }>;
+}
+//# sourceMappingURL=MockWebKitMediaKeySession.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/webkit/MockWebKitMediaKeys.d.ts

@@ -0,0 +1,8 @@
+import { DrmKeySystem } from '@amazon/vinyl';
+export declare class MockWebKitMediaKeys implements WebKitMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    constructor(keySystem: DrmKeySystem);
+    createSession: import("@amazon/vinyl-util/browserTestUtil").Spy2<((type: string, initData: Uint8Array) => WebKitMediaKeySession) & ((type: string, initData: Uint8Array) => any)>;
+    static isTypeSupported: import("@amazon/vinyl-util/browserTestUtil").Spy2<typeof WebKitMediaKeys.isTypeSupported & ((keySystem: string, type?: import("@amazon/vinyl-util").Maybe<string>) => any)>;
+}
+//# sourceMappingURL=MockWebKitMediaKeys.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/dom/webkit/useWebKitMediaKeys.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Overrides media key support.
+ */
+export declare function useWebKitMediaKeys(present: boolean): void;
+//# sourceMappingURL=useWebKitMediaKeys.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/drm/MockCommonEme.d.ts

@@ -0,0 +1,6 @@
+import { CommonEme } from '@amazon/vinyl';
+export declare class MockCommonEme implements CommonEme {
+    requestMediaKeySystemAccess: import("@amazon/vinyl-util/browserTestUtil").Spy2<((keySystem: import("@amazon/vinyl").DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]) => Promise<import("@amazon/vinyl").CommonMediaKeySystemAccess>) & ((keySystem: import("@amazon/vinyl").DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]) => any)>;
+    addEncryptedListener: import("@amazon/vinyl-util/browserTestUtil").Spy2<((element: HTMLMediaElement, handler: (event: import("@amazon/vinyl").CommonMediaEncryptedEvent) => void) => import("@amazon/vinyl-util").Unsubscribe) & ((element: HTMLMediaElement, handler: (event: import("@amazon/vinyl").CommonMediaEncryptedEvent) => void) => any)>;
+}
+//# sourceMappingURL=MockCommonEme.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/drm/MockCommonMediaKeySession.d.ts

@@ -0,0 +1,11 @@
+import { DrmInitDataType } from '@amazon/vinyl';
+import { CommonMediaKeySession, CommonMediaKeySessionEventMap, EncryptedInitData } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockCommonMediaKeySession extends MockEventHost<CommonMediaKeySessionEventMap> implements CommonMediaKeySession {
+    initData: EncryptedInitData;
+    initDataType: DrmInitDataType;
+    mimeType: string;
+    disposed: boolean;
+    update: import("@amazon/vinyl-util/browserTestUtil").Spy2<((key: ArrayBuffer) => Promise<void>) & ((key: ArrayBuffer) => any)>;
+}
+//# sourceMappingURL=MockCommonMediaKeySession.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/drm/MockCommonMediaKeySystemAccess.d.ts

@@ -0,0 +1,8 @@
+import { DrmKeySystem } from '@amazon/vinyl';
+import { CommonMediaKeySystemAccess } from '@amazon/vinyl';
+export declare class MockCommonMediaKeySystemAccess implements CommonMediaKeySystemAccess {
+    keySystem: DrmKeySystem;
+    constructor(keySystem: DrmKeySystem);
+    createMediaKeys: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => Promise<import("@amazon/vinyl").CommonMediaKeys>) & (() => any)>;
+}
+//# sourceMappingURL=MockCommonMediaKeySystemAccess.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/drm/MockCommonMediaKeys.d.ts

@@ -0,0 +1,9 @@
+import { CommonMediaKeys, DrmKeySystem } from '@amazon/vinyl';
+export declare class MockCommonMediaKeys implements CommonMediaKeys {
+    keySystem: DrmKeySystem;
+    clearFromElement: import("@amazon/vinyl-util/browserTestUtil").Spy2<((element: HTMLMediaElement) => Promise<void>) & ((element: HTMLMediaElement) => any)>;
+    createSession: import("@amazon/vinyl-util/browserTestUtil").Spy2<((mimeType: string, initDataType: import("@amazon/vinyl").DrmInitDataType, initData: import("@amazon/vinyl").EncryptedInitData) => import("@amazon/vinyl").CommonMediaKeySession) & ((mimeType: string, initDataType: string, initData: import("@amazon/vinyl").EncryptedInitData) => any)>;
+    setOnElement: import("@amazon/vinyl-util/browserTestUtil").Spy2<((element: HTMLMediaElement) => Promise<void>) & ((element: HTMLMediaElement) => any)>;
+    setServerCertificate: import("@amazon/vinyl-util/browserTestUtil").Spy2<((certificate: BufferSource) => Promise<boolean>) & ((certificate: BufferSource) => any)>;
+}
+//# sourceMappingURL=MockCommonMediaKeys.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/drm/MockDrmController.d.ts

@@ -0,0 +1,13 @@
+import { DrmController, DrmControllerEventMap } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockDrmController extends MockEventHost<DrmControllerEventMap> implements DrmController {
+    error: Error | null;
+    configure: import("@amazon/vinyl-util/browserTestUtil").Spy2<(options: import("@amazon/vinyl-util").Maybe<Partial<import("@amazon/vinyl").DrmOptions>>) => void>;
+    isEmeSupported: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => boolean) & (() => any)>;
+    isSupported: import("@amazon/vinyl-util/browserTestUtil").Spy2<((drmInfo: import("@amazon/vinyl").MediaFormatMetadata) => Promise<import("@amazon/vinyl").DrmKeySystemSupport>) & ((drmInfo: import("@amazon/vinyl").MediaFormatMetadata) => any)>;
+    initializeForPlayback: import("@amazon/vinyl-util/browserTestUtil").Spy2<(drmInfo: import("@amazon/vinyl").MediaFormatMetadata | null, abort?: import("@amazon/vinyl-util").ReadonlyAbort) => void>;
+    setBufferingDrmInfo: import("@amazon/vinyl-util/browserTestUtil").Spy2<(drmInfo: import("@amazon/vinyl").MediaFormatMetadata | null, abort?: import("@amazon/vinyl-util").ReadonlyAbort) => void>;
+    closeSessions: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockDrmController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/hls/MockHlsManifestController.d.ts

@@ -0,0 +1,19 @@
+import { HlsManifestController, HlsManifestData } from '@amazon/vinyl';
+/**
+ * Mock implementation of HlsManifestController.
+ *
+ * Uses a real MutableValue internally so that map/pick/onData work correctly.
+ */
+export declare class MockHlsManifestController implements HlsManifestController {
+    private readonly _data;
+    refresh: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    get value(): Promise<HlsManifestData>;
+    get changeId(): number;
+    getValue(): Promise<HlsManifestData>;
+    onData(callback: (value: Promise<HlsManifestData>, previous: Promise<HlsManifestData> | undefined) => void): import("@amazon/vinyl-util").Unsubscribe;
+    map<U>(transform: (value: Promise<HlsManifestData>) => U): import("@amazon/vinyl-observable").MutableValue<U>;
+    pick<K extends keyof NonNullable<Promise<HlsManifestData>>>(prop: K): import("@amazon/vinyl-observable").MutableValue<Promise<HlsManifestData>[K]>;
+    setManifest(manifest: Promise<HlsManifestData>): void;
+}
+//# sourceMappingURL=MockHlsManifestController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/hls/mockHlsManifest.d.ts

@@ -0,0 +1,6 @@
+import { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+import { HlsManifestData } from '@amazon/vinyl';
+export declare const mockMediaPlaylist: MediaPlaylist;
+export declare const mockMainPlaylist: MainPlaylist;
+export declare const mockHlsManifestData: HlsManifestData;
+//# sourceMappingURL=mockHlsManifest.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/logging/MockHistoryLogHandler.d.ts

@@ -0,0 +1,9 @@
+import { HistoryLogHandler, HistoryLogItem } from '@amazon/vinyl-util';
+import { LogLevel } from '@amazon/vinyl-util';
+export declare class MockHistoryLogHandler implements HistoryLogHandler {
+    logLevel: LogLevel;
+    maxHistorySize: number;
+    history: HistoryLogItem[];
+    clear: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockHistoryLogHandler.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/playback/MockLoudnessNormalizationController.d.ts

@@ -0,0 +1,8 @@
+import { LoudnessNormalizationController, LoudnessNormalizationControllerEventMap } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockLoudnessNormalizationController extends MockEventHost<LoudnessNormalizationControllerEventMap> implements LoudnessNormalizationController {
+    gain: number;
+    setTrackLoudness: import("@amazon/vinyl-util/browserTestUtil").Spy2<(value: number | null) => void>;
+    clear: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockLoudnessNormalizationController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/playback/MockPlaybackController.d.ts

@@ -0,0 +1,34 @@
+import { PlaybackController, PlaybackControllerEventMap } from '@amazon/vinyl';
+import { PlaybackNetworkState, PlaybackReadyState } from '@amazon/vinyl';
+import { RangesImpl } from '@amazon/vinyl-util';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockPlaybackController extends MockEventHost<PlaybackControllerEventMap> implements PlaybackController {
+    buffered: RangesImpl;
+    canPlay: boolean;
+    canPlayThrough: boolean;
+    currentTime: number;
+    currentTimePercent: number;
+    defaultPlaybackRate: number;
+    duration: number;
+    ended: boolean;
+    error: Error | null;
+    hasMetadata: boolean;
+    loop: boolean;
+    muted: boolean;
+    networkState: PlaybackNetworkState;
+    pause: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    paused: boolean;
+    play: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => Promise<void>) & (() => any)>;
+    playIsPending: boolean;
+    playbackRate: number;
+    playing: boolean;
+    preservesPitch: boolean;
+    readyState: PlaybackReadyState;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    seekTo: import("@amazon/vinyl-util/browserTestUtil").Spy2<((time: number, tolerance?: number) => Promise<void>) & ((time: number, tolerance?: number | undefined) => any)>;
+    seekable: RangesImpl;
+    seeking: boolean;
+    volume: number;
+    waiting: boolean;
+}
+//# sourceMappingURL=MockPlaybackController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/playback/MockPlaybackSource.d.ts

@@ -0,0 +1,10 @@
+import { CrossOrigin, PlaybackSource } from '@amazon/vinyl';
+export declare class MockPlaybackSource implements PlaybackSource {
+    crossOrigin: CrossOrigin;
+    currentSrc: string;
+    src: string | null;
+    srcObject: MediaStream | null;
+    disableRemotePlayback: boolean;
+    load: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockPlaybackSource.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/player/MockVinylPlayerDependencies.d.ts

@@ -0,0 +1,38 @@
+import { DrmKeySystemResolver, VinylOptions } from '@amazon/vinyl';
+import { MockCapabilities } from '../../mock/client/MockCapabilities';
+import { MockPlaybackController } from '../../mock/playback/MockPlaybackController';
+import { MockPlaybackSource } from '../../mock/playback/MockPlaybackSource';
+import { MockTrackController } from '../../mock/track/MockTrackController';
+import { MockDrmController } from '../../mock/drm/MockDrmController';
+import { MockAutoResetController } from '../../mock/track/MockAutoResetController';
+import { noop } from '@amazon/vinyl-util';
+export type MockVinylDependencies = ReturnType<typeof createMockVinylDependencies>;
+/**
+ * Creates mock dependencies for the Vinyl Player and all track factories.
+ */
+export declare function createMockVinylDependencies(): {
+    readonly options: import("@amazon/vinyl-observable").MutableValueImpl<VinylOptions>;
+    readonly trackController: MockTrackController<import("@amazon/vinyl").VinylTrackLoadOptions>;
+    readonly playbackSource: MockPlaybackSource;
+    readonly playbackController: MockPlaybackController;
+    readonly capabilities: MockCapabilities;
+    readonly drmController: MockDrmController;
+    readonly createDashFactories: (_loadOptions: import("@amazon/vinyl").DashTrackLoadOptions) => import("@amazon/vinyl-di").Factories<{
+        readonly contentTypesValue: import("@amazon/vinyl-observable").MutableValueImpl<Promise<Set<import("@amazon/vinyl").ContentType>>>;
+        readonly contentStreamFactory: jasmine.Spy<((contentType: import("@amazon/vinyl").ContentType) => import("@amazon/vinyl").ContentStream) & ((contentType: import("@amazon/vinyl").ContentType) => any)>;
+        readonly manifestController: import("../..").MockDashManifestController;
+        readonly manifestTransformed: import("../..").MockDashManifestController;
+        readonly mediaTimeline: import("@amazon/vinyl-observable").MutableValueImpl<Promise<import("@amazon/vinyl").MediaTimeline>>;
+        readonly mediaTimelineTransformed: import("@amazon/vinyl-observable").MutableValueImpl<Promise<import("@amazon/vinyl").MediaTimeline>>;
+        readonly mediaSourceController: import("../..").MockMediaSourceController;
+        readonly playbackSource: MockPlaybackSource;
+        readonly playbackController: MockPlaybackController;
+        readonly drmController: MockDrmController;
+        readonly mediaQualityMetadataResolver: jasmine.Spy<import("@amazon/vinyl").DashMediaQualityMetadataResolver>;
+    }>;
+    readonly createHlsFactories: (_loadOptions: import("@amazon/vinyl").HlsTrackLoadOptions) => any;
+    readonly autoResetController: MockAutoResetController;
+    readonly requestInterceptor: typeof noop;
+    readonly drmKeySystemResolver: jasmine.Spy<DrmKeySystemResolver>;
+};
+//# sourceMappingURL=MockVinylPlayerDependencies.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/streaming/MockContentStream.d.ts

@@ -0,0 +1,18 @@
+import { ContentStream, ContentType, MediaQualityMetadata, StreamingEventMap } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+import { RangesImpl } from '@amazon/vinyl-util';
+export declare class MockContentStream extends MockEventHost<StreamingEventMap> implements ContentStream {
+    contentType: ContentType;
+    bufferingQuality: MediaQualityMetadata | null;
+    error: Error | null;
+    fetchedRanges: RangesImpl;
+    playbackQuality: MediaQualityMetadata | null;
+    streamingQuality: MediaQualityMetadata | null;
+    bufferingEnded: boolean;
+    clearPrefetch: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    activate: import("@amazon/vinyl-util/browserTestUtil").Spy2<(options: import("@amazon/vinyl").ContentStreamActivateOptions) => void>;
+    deactivate: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    preload: import("@amazon/vinyl-util/browserTestUtil").Spy2<(options: import("@amazon/vinyl").ContentStreamPreloadOptions) => void>;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockContentStream.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/streaming/MockSegmentController.d.ts

@@ -0,0 +1,15 @@
+import { MediaQualityMetadata, SegmentController, SegmentControllerEventMap } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockSegmentController extends MockEventHost<SegmentControllerEventMap> implements SegmentController {
+    error: Error | null;
+    getDuration: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => Promise<number | null>) & (() => any)>;
+    configure: import("@amazon/vinyl-util/browserTestUtil").Spy2<(options: Partial<import("@amazon/vinyl").PrefetchOptions>) => void>;
+    fetchedRanges: import("@amazon/vinyl-util").ReadonlyRanges;
+    activate: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    clear: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    deactivate: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    getSegment: import("@amazon/vinyl-util/browserTestUtil").Spy2<((time: number, abort?: import("@amazon/vinyl-util").ReadonlyAbort) => Promise<import("@amazon/vinyl").SegmentReference<ArrayBuffer> | null>) & ((time: number, abort?: import("@amazon/vinyl-util").ReadonlyAbort | undefined) => any)>;
+    streamingQuality: MediaQualityMetadata | null;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockSegmentController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/streaming/abr/MockQualitySelector.d.ts

@@ -0,0 +1,5 @@
+import { QualitySelector } from '@amazon/vinyl';
+export declare class MockQualitySelector implements QualitySelector {
+    selectQuality: import("@amazon/vinyl-util/browserTestUtil").Spy2<((qualities: readonly import("@amazon/vinyl").MediaQualityMetadata[], prefetchState: import("@amazon/vinyl").PrefetchState) => number) & ((qualities: readonly import("@amazon/vinyl").MediaQualityMetadata[], prefetchState: import("@amazon/vinyl").PrefetchState) => any)>;
+}
+//# sourceMappingURL=MockQualitySelector.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/streaming/buffering/MockBufferingController.d.ts

@@ -0,0 +1,14 @@
+import { BufferingController, BufferingControllerEventMap, MediaQualityMetadata } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockBufferingController extends MockEventHost<BufferingControllerEventMap> implements BufferingController {
+    error: Error | null;
+    active: boolean;
+    bufferingEnded: boolean;
+    playbackQuality: MediaQualityMetadata | null;
+    bufferingQuality: MediaQualityMetadata | null;
+    activate: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    deactivate: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    clear: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockBufferingController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/streaming/buffering/MockMediaSourceController.d.ts

@@ -0,0 +1,11 @@
+import { MediaSourceController, MediaSourceControllerEventMap } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockMediaSourceController extends MockEventHost<MediaSourceControllerEventMap> implements MediaSourceController {
+    duration: number;
+    readyState: ReadyState;
+    createSourceBuffer: import("@amazon/vinyl-util/browserTestUtil").Spy2<((contentType: import("@amazon/vinyl").ContentType, mimeType: string) => import("@amazon/vinyl").SourceBufferRef) & ((contentType: import("@amazon/vinyl").ContentType, mimeType: string) => any)>;
+    endOfStream: import("@amazon/vinyl-util/browserTestUtil").Spy2<(error?: EndOfStreamError) => void>;
+    createUrl: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => string) & (() => any)>;
+    readyToAppend: boolean;
+}
+//# sourceMappingURL=MockMediaSourceController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/streaming/buffering/MockSourceBufferController.d.ts

@@ -0,0 +1,15 @@
+import { SourceBufferController } from '@amazon/vinyl';
+import { RangesImpl } from '@amazon/vinyl-util';
+export declare class MockSourceBufferController implements SourceBufferController {
+    buffered: RangesImpl;
+    append: import("@amazon/vinyl-util/browserTestUtil").Spy2<((data: ArrayBuffer) => Promise<void>) & ((data: ArrayBuffer) => any)>;
+    appendInit: import("@amazon/vinyl-util/browserTestUtil").Spy2<((data: ArrayBuffer, mimeType: string) => Promise<void>) & ((data: ArrayBuffer, mimeType: string) => any)>;
+    clear: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => Promise<void>) & (() => any)>;
+    enqueue: import("@amazon/vinyl-util/browserTestUtil").Spy2<(<T = void>(task: import("@amazon/vinyl-util").Task<T>) => Promise<T>) & ((task: import("@amazon/vinyl-util").Task<unknown>) => any)>;
+    isBusy: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => boolean) & (() => any)>;
+    remove: import("@amazon/vinyl-util/browserTestUtil").Spy2<((startTime: number, endTime: number) => Promise<void>) & ((startTime: number, endTime: number) => any)>;
+    setAppendWindow: import("@amazon/vinyl-util/browserTestUtil").Spy2<((appendWindowStart?: number, appendWindowEnd?: number) => Promise<void>) & ((appendWindowStart?: number | undefined, appendWindowEnd?: number | undefined) => any)>;
+    setTimestampOffset: import("@amazon/vinyl-util/browserTestUtil").Spy2<((timestampOffset: number) => Promise<void>) & ((timestampOffset: number) => any)>;
+    dispose: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockSourceBufferController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/track/MockAutoResetController.d.ts

@@ -0,0 +1,7 @@
+import { AutoResetController, AutoResetControllerEventMap } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockAutoResetController extends MockEventHost<AutoResetControllerEventMap> implements AutoResetController {
+    setError: import("@amazon/vinyl-util/browserTestUtil").Spy2<(error: Error) => void>;
+    clear: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockAutoResetController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/track/MockTrack.d.ts

@@ -0,0 +1,29 @@
+import { ContentType, MediaQualityMetadata, Track, TrackEventMap } from '@amazon/vinyl';
+import { RangesImpl } from '@amazon/vinyl-util';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockTrack extends MockEventHost<TrackEventMap> implements Track {
+    get [Symbol.toStringTag](): string;
+    uri: string;
+    type: string;
+    active: boolean;
+    fetchedRanges: RangesImpl;
+    preload: import("@amazon/vinyl-util/browserTestUtil").Spy2<(trackOptions: import("@amazon/vinyl").TrackPreloadOptions, loadOptions: import("@amazon/vinyl-util").AnyRecord) => void>;
+    contentTypes: Set<ContentType>;
+    qualities: readonly MediaQualityMetadata[] | null;
+    qualitiesUnfiltered: readonly MediaQualityMetadata[] | null;
+    getStreamingQuality: import("@amazon/vinyl-util/browserTestUtil").Spy2<(contentType: ContentType) => MediaQualityMetadata | null>;
+    getBufferingQuality: import("@amazon/vinyl-util/browserTestUtil").Spy2<(contentType: ContentType) => MediaQualityMetadata | null>;
+    getPlaybackQuality: import("@amazon/vinyl-util/browserTestUtil").Spy2<(contentType: ContentType) => MediaQualityMetadata | null>;
+    extra: any;
+    error: Error | null;
+    activate: import("@amazon/vinyl-util/browserTestUtil").Spy2<(loadOptions: import("@amazon/vinyl-util").AnyRecord) => void>;
+    deactivate: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    clearPrefetch: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    disposed: boolean;
+    /**
+     * Installs fakes for activate and deactivate to set active status.
+     */
+    implementActivateFakes(): void;
+}
+//# sourceMappingURL=MockTrack.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/track/MockTrackController.d.ts

@@ -0,0 +1,20 @@
+import { Track, TrackController, TrackControllerEventMap, TrackLoadOptions } from '@amazon/vinyl';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockTrackController<TrackLoadOptionsType extends TrackLoadOptions = TrackLoadOptions> extends MockEventHost<TrackControllerEventMap<TrackLoadOptionsType>> implements TrackController<TrackLoadOptionsType> {
+    currentTrack: Track | null;
+    queue: any[];
+    clearPrefetch: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    clearQueue: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    clearTrackCache: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    enqueue: import("@amazon/vinyl-util/browserTestUtil").Spy2<(...loadOptionsList: readonly any[]) => void>;
+    getCachedTrack: import("@amazon/vinyl-util/browserTestUtil").Spy2<(uri: import("@amazon/vinyl").TrackUri) => import("@amazon/vinyl").ReadonlyTrack | null>;
+    getCachedTracks: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => IterableIterator<import("@amazon/vinyl").ReadonlyTrack>) & (() => any)>;
+    hasNext: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => boolean) & (() => any)>;
+    isTrackCached: import("@amazon/vinyl-util/browserTestUtil").Spy2<((uri: import("@amazon/vinyl").TrackUri) => boolean) & ((uri: string) => any)>;
+    load: import("@amazon/vinyl-util/browserTestUtil").Spy2<(...loadOptionsList: readonly any[]) => void>;
+    next: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    preload: import("@amazon/vinyl-util/browserTestUtil").Spy2<(...loadOptionsList: readonly any[]) => void>;
+    unload: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    reset: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+}
+//# sourceMappingURL=MockTrackController.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/track/MockTrackFactory.d.ts

@@ -0,0 +1,7 @@
+import { TrackFactory, TrackLoadOptions } from '@amazon/vinyl';
+export declare class MockTrackFactory<TrackLoadOptionsType extends TrackLoadOptions = TrackLoadOptions> implements TrackFactory<TrackLoadOptionsType> {
+    private readonly spyFactory;
+    validate: import("@amazon/vinyl-util/browserTestUtil").Spy2<(options: TrackLoadOptionsType) => void>;
+    createTrack: import("@amazon/vinyl-util/browserTestUtil").Spy2<((options: TrackLoadOptionsType) => import("@amazon/vinyl").Track) & ((options: TrackLoadOptionsType) => any)>;
+}
+//# sourceMappingURL=MockTrackFactory.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/track/dash/createMockDashDependencies.d.ts

@@ -0,0 +1,21 @@
+import { ContentType, DashMediaQualityMetadataResolver, MediaTimeline } from '@amazon/vinyl';
+import { MockDashManifestController } from '../../../mock/dash/MockDashManifestController';
+import { MockMediaSourceController } from '../../../mock/streaming/buffering/MockMediaSourceController';
+import { MockPlaybackSource } from '../../../mock/playback/MockPlaybackSource';
+import { MockPlaybackController } from '../../../mock/playback/MockPlaybackController';
+import { MockDrmController } from '../../../mock/drm/MockDrmController';
+export declare function createMockDashDependencies(): {
+    readonly contentTypesValue: import("@amazon/vinyl-observable").MutableValueImpl<Promise<Set<ContentType>>>;
+    readonly contentStreamFactory: jasmine.Spy<((contentType: ContentType) => import("@amazon/vinyl").ContentStream) & ((contentType: ContentType) => any)>;
+    readonly manifestController: MockDashManifestController;
+    readonly manifestTransformed: MockDashManifestController;
+    readonly mediaTimeline: import("@amazon/vinyl-observable").MutableValueImpl<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: import("@amazon/vinyl-observable").MutableValueImpl<Promise<MediaTimeline>>;
+    readonly mediaSourceController: MockMediaSourceController;
+    readonly playbackSource: MockPlaybackSource;
+    readonly playbackController: MockPlaybackController;
+    readonly drmController: MockDrmController;
+    readonly mediaQualityMetadataResolver: jasmine.Spy<DashMediaQualityMetadataResolver>;
+};
+export type MockDashDependencies = ReturnType<typeof createMockDashDependencies>;
+//# sourceMappingURL=createMockDashDependencies.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/mock/track/hls/createMockHlsDependencies.d.ts

@@ -0,0 +1,21 @@
+import { ContentType, HlsMediaQualityMetadataResolver, MediaTimeline } from '@amazon/vinyl';
+import { MockHlsManifestController } from '../../../mock/hls/MockHlsManifestController';
+import { MockMediaSourceController } from '../../../mock/streaming/buffering/MockMediaSourceController';
+import { MockPlaybackSource } from '../../../mock/playback/MockPlaybackSource';
+import { MockPlaybackController } from '../../../mock/playback/MockPlaybackController';
+import { MockDrmController } from '../../../mock/drm/MockDrmController';
+export declare function createMockHlsDependencies(): {
+    readonly contentTypesValue: import("@amazon/vinyl-observable").MutableValueImpl<Promise<Set<ContentType>>>;
+    readonly contentStreamFactory: jasmine.Spy<((contentType: ContentType) => import("@amazon/vinyl").ContentStream) & ((contentType: ContentType) => any)>;
+    readonly manifestController: MockHlsManifestController;
+    readonly manifestTransformed: import("@amazon/vinyl-observable").MutableValue<Promise<import("@amazon/vinyl").HlsManifestData>>;
+    readonly mediaTimeline: import("@amazon/vinyl-observable").MutableValueImpl<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: import("@amazon/vinyl-observable").MutableValueImpl<Promise<MediaTimeline>>;
+    readonly mediaSourceController: MockMediaSourceController;
+    readonly playbackSource: MockPlaybackSource;
+    readonly playbackController: MockPlaybackController;
+    readonly drmController: MockDrmController;
+    readonly mediaQualityMetadataResolver: jasmine.Spy<HlsMediaQualityMetadataResolver>;
+};
+export type MockHlsDependencies = ReturnType<typeof createMockHlsDependencies>;
+//# sourceMappingURL=createMockHlsDependencies.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/player/createVinylSuite.d.ts

@@ -0,0 +1,41 @@
+import { VinylDependencyOptions, VinylPlayer } from '@amazon/vinyl';
+export interface VinylSuiteOptions {
+    /**
+     * The number of seconds before the tests in this suite time out.
+     * Default is 60s.
+     */
+    readonly timeout?: number;
+    /**
+     * If true, will fail the test on error events.
+     * default: true
+     */
+    readonly failOnError?: boolean;
+}
+export declare class VinylSuite<T extends VinylPlayer<any, any> = VinylPlayer> {
+    /**
+     * Constructs a new player.
+     */
+    private readonly playerFactory;
+    protected readonly options?: VinylSuiteOptions | undefined;
+    get [Symbol.toStringTag](): string;
+    readonly logPrefix: string;
+    private _player;
+    get player(): T;
+    private readonly visibilityChangeHandler;
+    constructor(
+    /**
+     * Constructs a new player.
+     */
+    playerFactory: () => T, options?: VinylSuiteOptions | undefined);
+    /**
+     * Initializes jasmine test setup.
+     */
+    init(): void;
+}
+/**
+ * Prepares an integration test for a Vinyl Player.
+ * This will create a player, handle disposal and global cleanup, and watch for window
+ * visibility changes, which can interfere with test results.
+ */
+export declare function createVinylSuite(playerDependencyOptions?: Partial<VinylDependencyOptions>, options?: VinylSuiteOptions): VinylSuite;
+//# sourceMappingURL=createVinylSuite.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/player/mediaRef.d.ts

@@ -0,0 +1,6 @@
+/**
+ * For reliable integ tests on 3P devices, there should be a single media element.
+ * When using the media element, unload any sources and reset any state after each test.
+ */
+export declare const mediaRef: import("@amazon/vinyl-util").Lazy<HTMLMediaElement>;
+//# sourceMappingURL=mediaRef.d.ts.map

package/dist/vinylTestUtil/types/ts3.7/ui/requireUserInteraction.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Displays a prompt awaiting user interaction, resolving after a click, keypress, or touch event.
+ */
+export declare function requireUserInteraction(): Promise<void>;
+//# sourceMappingURL=requireUserInteraction.d.ts.map