@amazon/vinyl 1.0.0

package/dist/types/ts4.7/drm/commonEme/StandardCommonEme.d.ts

@@ -0,0 +1,54 @@
+import { type Disposable, EventHostImpl, type Unsubscribe } from '@amazon/vinyl-util';
+import type { CommonEme, CommonMediaEncryptedEvent, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import { type EncryptedInitData } from './EncryptedInitData';
+import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
+/**
+ * A CommonEme implementation of unprefixed Encrypted Media Extensions.
+ */
+export declare class StandardCommonEme implements CommonEme {
+    requestMediaKeySystemAccess(keySystem: DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]): Promise<CommonMediaKeySystemAccess>;
+    addEncryptedListener(element: HTMLMediaElement, handler: (event: CommonMediaEncryptedEvent) => void): Unsubscribe;
+}
+/**
+ * CommonMediaKeySystemAccess for unprefixed EME implementations.
+ */
+export declare class StandardCommonMediaKeySystemAccess implements CommonMediaKeySystemAccess {
+    readonly keySystem: DrmKeySystem;
+    private readonly access;
+    constructor(keySystem: DrmKeySystem, access: MediaKeySystemAccess);
+    /**
+     * @return {Promise<CommonMediaKeys>}
+     */
+    createMediaKeys(): Promise<CommonMediaKeys>;
+}
+/**
+ * CommonMediaKeys for unprefixed EME implementations.
+ */
+export declare class StandardCommonMediaKeys implements CommonMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    private readonly mediaKeys;
+    constructor(keySystem: DrmKeySystem, mediaKeys: MediaKeys);
+    setOnElement(element: HTMLMediaElement): Promise<void>;
+    clearFromElement(element: HTMLMediaElement): Promise<void>;
+    setServerCertificate(certificate: BufferSource): Promise<boolean>;
+    createSession(mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData): CommonMediaKeySession;
+}
+/**
+ * CommonMediaKeySession for unprefixed EME implementations.
+ */
+export declare class StandardCommonMediaKeySession extends EventHostImpl<CommonMediaKeySessionEventMap> implements CommonMediaKeySession, Disposable {
+    private readonly session;
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+    readonly initData: EncryptedInitData;
+    get [Symbol.toStringTag](): string;
+    private _disposed;
+    private readonly messageHandler;
+    constructor(session: MediaKeySession, mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData);
+    private generateRequest;
+    update(key: ArrayBufferLike): Promise<void>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=StandardCommonEme.d.ts.map

package/dist/types/ts4.7/drm/commonEme/WebKitCommonEme.d.ts

@@ -0,0 +1,63 @@
+import type { Unsubscribe } from '@amazon/vinyl-util';
+import { type Disposable, EventHostImpl } from '@amazon/vinyl-util';
+import type { CommonEme, CommonMediaEncryptedEvent, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
+import { MediaKeySessionErrorType } from './CommonEme';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { EncryptedInitData } from '../../drm/commonEme/EncryptedInitData';
+import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
+declare global {
+    interface HTMLMediaElementEventMap extends HTMLElementEventMap {
+        readonly webkitneedkey: WebKitMediaKeyNeededEvent;
+    }
+    interface WebKitMediaKeyNeededEvent extends Event {
+        readonly initDataType: string;
+        readonly initData: Uint8Array | null;
+    }
+}
+/**
+ * A CommonEme implementation of WebKit-prefixed Encrypted Media Extensions.
+ */
+export declare class WebKitCommonEme implements CommonEme {
+    requestMediaKeySystemAccess(keySystem: DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]): Promise<CommonMediaKeySystemAccess>;
+    addEncryptedListener(element: HTMLMediaElement, handler: (event: CommonMediaEncryptedEvent) => void): Unsubscribe;
+}
+export declare class WebKitCommonMediaKeySystemAccess implements CommonMediaKeySystemAccess {
+    readonly keySystem: DrmKeySystem;
+    constructor(keySystem: DrmKeySystem);
+    createMediaKeys(): Promise<CommonMediaKeys>;
+}
+/** @private */
+export declare class WebKitCommonMediaKeys implements CommonMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    readonly mediaKeys: WebKitMediaKeys;
+    constructor(keySystem: DrmKeySystem, mediaKeys: WebKitMediaKeys);
+    /**
+     * Sets the media keys on the given element.
+     */
+    setOnElement(element: HTMLMediaElement): Promise<void>;
+    /**
+     * Clears the media keys from the given element.
+     */
+    clearFromElement(element: HTMLMediaElement): Promise<void>;
+    setServerCertificate(_certificate: BufferSource): Promise<boolean>;
+    createSession(mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData): CommonMediaKeySession;
+}
+/** @private */
+export declare class WebKitCommonMediaKeySession extends EventHostImpl<CommonMediaKeySessionEventMap> implements CommonMediaKeySession, Disposable {
+    private readonly session;
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+    readonly initData: EncryptedInitData;
+    private _disposed;
+    constructor(session: WebKitMediaKeySession, mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData);
+    private readonly messageHandler;
+    private readonly errorHandler;
+    update(key: ArrayBuffer): Promise<void>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+/**
+ * Returns a string for the WebKit media key error.
+ */
+export declare function webkitErrorCodeToStr(code: number): MediaKeySessionErrorType;
+//# sourceMappingURL=WebKitCommonEme.d.ts.map

package/dist/types/ts4.7/drm/commonEme/createDrmErrorHandler.d.ts

@@ -0,0 +1,3 @@
+import { ErrorLevel } from '@amazon/vinyl-util';
+export declare function createDrmErrorHandler(level?: ErrorLevel): (error: Error) => never;
+//# sourceMappingURL=createDrmErrorHandler.d.ts.map

package/dist/types/ts4.7/drm/dom/HTMLMediaElement.d.ts

@@ -0,0 +1,8 @@
+export {};
+declare global {
+    interface HTMLMediaElement {
+        webkitSetMediaKeys?(mediaKeys: WebKitMediaKeys | null): void;
+        msSetMediaKeys?(mediaKeys: MSMediaKeys | null): void;
+    }
+}
+//# sourceMappingURL=HTMLMediaElement.d.ts.map

package/dist/types/ts4.7/drm/dom/MSMediaKeys.d.ts

@@ -0,0 +1,46 @@
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * API for MS-prefixed EME.
+ *
+ * @module
+ */
+declare global {
+    class MSMediaKeys {
+        readonly keySystem: string;
+        constructor(keySystem: string);
+        static isTypeSupported(keySystem: string, type?: Maybe<string>): boolean;
+        createSession(type: string, initData: Uint8Array): MSMediaKeySession;
+    }
+    class MSMediaKeyError {
+        static readonly MS_MEDIA_KEYERR_CLIENT: number;
+        static readonly MS_MEDIA_KEYERR_DOMAIN: number;
+        static readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
+        static readonly MS_MEDIA_KEYERR_OUTPUT: number;
+        static readonly MS_MEDIA_KEYERR_SERVICE: number;
+        static readonly MS_MEDIA_KEYERR_UNKNOWN: number;
+        readonly code: number;
+        readonly systemCode: number;
+    }
+    interface MSMediaKeySession extends EventTarget {
+        readonly error: MSMediaKeyError | null;
+        readonly keySystem: string;
+        onmskeyadded: EventListener | null;
+        onmskeyerror: EventListener | null;
+        onmskeymessage: EventListener | null;
+        sessionId: string;
+        close(): void;
+        update(key: Uint8Array): void;
+        addEventListener<K extends keyof MSMediaKeySessionEventMap>(type: K, listener: (this: MSMediaKeySession, ev: MSMediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof MSMediaKeySessionEventMap>(type: K, listener: (this: MSMediaKeySession, ev: MSMediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    }
+}
+export interface MSMediaKeySessionEventMap {
+    readonly mskeymessage: MSMediaKeyMessageEvent;
+    readonly mskeyerror: Event;
+}
+export interface MSMediaKeyMessageEvent extends Event {
+    readonly message: Uint8Array;
+}
+//# sourceMappingURL=MSMediaKeys.d.ts.map

package/dist/types/ts4.7/drm/dom/WebKitMediaKeys.d.ts

@@ -0,0 +1,50 @@
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * API for WebKit-prefixed EME.
+ * WebKitPrefixed EME is supported from iOS/iPadOS 11.3 and macOS 10.10.3
+ *
+ * Modern unprefixed EME for WebKit is supported starting iOS/iPadOS 12.2 and macOS 10.14.4
+ *
+ * https://developer.apple.com/documentation/webkitjs/webkitmediakeys
+ * @module
+ */
+declare global {
+    class WebKitMediaKeys {
+        readonly keySystem: string;
+        constructor(keySystem: string);
+        static isTypeSupported(keySystem: string, type?: Maybe<string>): boolean;
+        createSession(type: string, initData: Uint8Array): WebKitMediaKeySession;
+    }
+    class WebKitMediaKeyError {
+        static readonly MEDIA_KEYERR_UNKNOWN: number;
+        static readonly MEDIA_KEYERR_CLIENT: number;
+        static readonly MEDIA_KEYERR_SERVICE: number;
+        static readonly MEDIA_KEYERR_OUTPUT: number;
+        static readonly MEDIA_KEYERR_HARDWARECHANGE: number;
+        static readonly MEDIA_KEYERR_DOMAIN: number;
+        readonly code: number;
+        readonly systemCode: number;
+    }
+    interface WebKitMediaKeySession extends EventTarget {
+        readonly error: WebKitMediaKeyError | null;
+        readonly keySystem: string;
+        onwebkitkeyadded: EventListener | null;
+        onwebkitkeyerror: EventListener | null;
+        onwebkitkeymessage: EventListener | null;
+        sessionId: string;
+        close(): void;
+        update(key: Uint8Array): void;
+        addEventListener<K extends keyof WebKitMediaKeySessionEventMap>(type: K, listener: (this: WebKitMediaKeySession, ev: WebKitMediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof WebKitMediaKeySessionEventMap>(type: K, listener: (this: WebKitMediaKeySession, ev: WebKitMediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    }
+}
+export interface WebKitMediaKeySessionEventMap {
+    readonly webkitkeymessage: WebKitMediaKeyMessageEvent;
+    readonly webkitkeyerror: Event;
+}
+export interface WebKitMediaKeyMessageEvent extends Event {
+    readonly message: Uint8Array;
+}
+//# sourceMappingURL=WebKitMediaKeys.d.ts.map

package/dist/types/ts4.7/drm/error/DrmError.d.ts

@@ -0,0 +1,16 @@
+import { type Json } from '@amazon/vinyl-util';
+import { ErrorLevel, ReportableError } from '@amazon/vinyl-util';
+/**
+ * An error originating from the DrmController.
+ * If an error comes from a key session, `extra.error` will be set with the original error and origin will be DRM.
+ */
+export declare class DrmError<ExtraType = any> extends ReportableError {
+    readonly message: string;
+    private readonly extra;
+    readonly origin: string;
+    readonly level: ErrorLevel;
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, extra?: ExtraType | null, origin?: string, level?: ErrorLevel);
+    toJSON(): Json;
+}
+//# sourceMappingURL=DrmError.d.ts.map

package/dist/types/ts4.7/drm/licenseProvider/LicenseProvider.d.ts

@@ -0,0 +1,38 @@
+import { type Maybe, type ReadonlyAbort } from '@amazon/vinyl-util';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import { type ObjectSchema } from '@amazon/vinyl-validation';
+/**
+ * LicenseProvider handles requesting DRM licenses for specific key systems.
+ */
+export type LicenseProvider = (keySystem: DrmKeySystem, serverOptions: LicenseServerOptions, challenge: ArrayBuffer, abort?: ReadonlyAbort) => Promise<ArrayBuffer>;
+/**
+ * Basic license server configuration.
+ * The license provider is given the matching configuration for the selected
+ * key system.
+ */
+export interface LicenseServerOptions {
+    /**
+     * The license server URL.
+     * This is required when using the default license provider.
+     */
+    readonly url?: Maybe<string | URL>;
+    /**
+     * License request init options.
+     */
+    readonly init?: Maybe<RequestInit>;
+    /**
+     * If set, provides the server certificate.
+     * An ArrayBufferLike object containing the server certificate.
+     * The contents are Key System-specific.
+     * If a `string` is provided, the value will be considered to be Base 64.
+     */
+    readonly serverCertificate?: Maybe<ServerCertificate>;
+}
+/**
+ * An ArrayBufferLike object containing the server certificate.
+ * The contents are Key System-specific.
+ * If a `string` is provided, the value will be considered to be Base 64.
+ */
+export type ServerCertificate = ArrayBuffer | string;
+export declare const licenseServerOptionsValidator: ObjectSchema<LicenseServerOptions>;
+//# sourceMappingURL=LicenseProvider.d.ts.map

package/dist/types/ts4.7/drm/licenseProvider/defaultLicenseProvider.d.ts

@@ -0,0 +1,15 @@
+import type { LicenseProvider } from './LicenseProvider';
+/**
+ * A basic LicenseProvider which uses the configuration set for the current key system,
+ * transmits a challenge as the body, and returns an array buffer.
+ *
+ * @param keySystem The key system for the current license challenge.
+ * @param serverOptions The resolved configuration. The default DrmController
+ * implementation provides this from the `drm` configuration set when creating
+ * a new player.
+ * @param challenge The license challenge, provided by the CDM (Content Decryption
+ * Module)
+ * @param abort (optional) When aborted, should cancel any active requests.
+ */
+export declare const defaultLicenseProvider: LicenseProvider;
+//# sourceMappingURL=defaultLicenseProvider.d.ts.map

package/dist/types/ts4.7/drm/util/createFairPlaySessionInitData.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Create the payload for EME media key session from `encrypted` / `*needkey` event data and DRM
+ * certificate.
+ * Note: This code is taken from the official FairPlay SDK example.
+ *
+ * @param initData
+ * @param contentId
+ * @param certificateData certificate data as a Uint8Array
+ */
+export declare function createFairPlaySessionInitData(initData: Uint8Array, contentId: string, certificateData: Uint8Array): Uint8Array;
+//# sourceMappingURL=createFairPlaySessionInitData.d.ts.map

package/dist/types/ts4.7/drm/util/extractContentId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extract contentId from event data encoded as UTF16.
+ *
+ * @param initData Expected byte array representing a UTF-16 string in the form
+ * `skd://0b5689bb-4171-97e5-c280-99f7abe4004f`
+ */
+export declare function extractContentId(initData: Uint8Array): string;
+//# sourceMappingURL=extractContentId.d.ts.map

package/dist/types/ts4.7/drm/util/unpackPlayReadyChallenge.d.ts

@@ -0,0 +1,46 @@
+import { type ReadonlyRecord } from '@amazon/vinyl-util';
+import type { XmlElement } from '@amazon/vinyl-xml';
+/**
+ * The final challenge buffer and headers for a playready license challenge.
+ */
+export interface UnpackedPlayReadyChallenge {
+    readonly challenge: ArrayBuffer;
+    readonly headers: ReadonlyRecord<string, string>;
+}
+/**
+ * IE and Edge wraps playready license challenges in PlayReadyKeyMessage xml.
+ * Not all PlayReady clients do this.
+ * Checks if the challenge is wrapped, and if so, returns the set headers and unwrapped challenge.
+ * Otherwise, returns the challenge as-is with the required content type header.
+ *
+ * @param challenge The array buffer from the 'message' cdm event.
+ */
+export declare function unpackPlayReadyChallenge(challenge: ArrayBuffer): UnpackedPlayReadyChallenge;
+interface PlayReadyMessage {
+    readonly PlayReadyKeyMessage: PlayReadyKeyMessageType;
+}
+interface PlayReadyKeyMessageType {
+    readonly type?: string;
+    readonly LicenseAcquisition: LicenseAcquisitionType;
+}
+interface LicenseAcquisitionType {
+    readonly Version: number;
+    readonly Challenge: ChallengeType;
+    readonly HttpHeaders: HttpHeadersType;
+}
+interface ContentType {
+    readonly _content: string;
+}
+interface ChallengeType extends ContentType {
+    readonly encoding?: string;
+}
+interface HttpHeadersType {
+    readonly HttpHeader: readonly HttpHeaderType[];
+}
+interface HttpHeaderType {
+    readonly name: ContentType;
+    readonly value: ContentType;
+}
+export declare function parsePlayReadyKeyMessage(xmlStr: string): PlayReadyMessage & XmlElement<PlayReadyMessage>;
+export {};
+//# sourceMappingURL=unpackPlayReadyChallenge.d.ts.map

package/dist/types/ts4.7/event/BasicErrorEvent.d.ts

@@ -0,0 +1,12 @@
+import type { LogTarget } from '@amazon/vinyl-util';
+export interface BasicErrorEvent {
+    /**
+     * The target reporting the error.
+     */
+    readonly target: LogTarget;
+    /**
+     * The error.
+     */
+    readonly error: Error;
+}
+//# sourceMappingURL=BasicErrorEvent.d.ts.map

package/dist/types/ts4.7/event/ChangeEvent.d.ts

@@ -0,0 +1,12 @@
+export interface ChangeEvent<T> {
+    readonly previous: T | null;
+    readonly current: T;
+}
+/**
+ * Creates a function, which when invoked, will call `inner` with a new ChangeEvent.
+ *
+ * @param getter
+ * @param inner
+ */
+export declare function createChangeEventTrigger<T>(getter: () => T, inner: (event: ChangeEvent<T>) => void): () => void;
+//# sourceMappingURL=ChangeEvent.d.ts.map

package/dist/types/ts4.7/global/PlayerRegistry.d.ts

@@ -0,0 +1,52 @@
+import type { AnyRecord, Disposable } from '@amazon/vinyl-util';
+/**
+ * A registry of all non-disposed Vinyl players.
+ * Used for debugging and cleanup validation.
+ */
+export interface PlayerRegistry {
+    /**
+     * Returns the non-disposed Vinyl players.
+     */
+    readonly players: readonly AnyRecord[];
+    /**
+     * Adds a player reference. All players must be removed before disposing VinylGlobal.
+     *
+     * @param player
+     */
+    addPlayer(player: AnyRecord): void;
+    /**
+     * Removes a player reference.
+     *
+     * @param player
+     */
+    removePlayer(player: AnyRecord): void;
+}
+export declare const DEFAULT_MAX_PLAYERS = 5;
+/**
+ * A registry of non-disposed players.
+ * Used for leak detection and debugging diagnostics.
+ */
+export declare class PlayerRegistryImpl implements PlayerRegistry, Disposable {
+    /**
+     * The number of concurrent players before a warning is logged.
+     * default: 5
+     */
+    maxPlayersWarning: number;
+    private _players;
+    private gaveMaxPlayersWarning;
+    constructor(
+    /**
+     * The number of concurrent players before a warning is logged.
+     * default: 5
+     */
+    maxPlayersWarning?: number);
+    get players(): readonly AnyRecord[];
+    addPlayer(player: AnyRecord): void;
+    removePlayer(player: AnyRecord): void;
+    /**
+     * @throws An IllegalStateError if all players have not been removed.
+     */
+    dispose(): void;
+}
+export declare const playerRegistryRef: import("@amazon/vinyl-util").GlobalRef<PlayerRegistry>;
+//# sourceMappingURL=PlayerRegistry.d.ts.map

package/dist/types/ts4.7/global/configureVinylGlobal.d.ts

@@ -0,0 +1,43 @@
+import { LogLevel, type PartialDeep } from '@amazon/vinyl-util';
+/**
+ * Configuration for VinylGlobal.
+ */
+export interface VinylGlobalOptions {
+    /**
+     * The number of concurrent players before a warning is logged.
+     * default: 5
+     */
+    readonly maxPlayersWarning: number;
+    /**
+     * Logging configuration
+     */
+    readonly logging: {
+        readonly history: {
+            /**
+             * Limits the history log level.
+             */
+            readonly logLevel: LogLevel;
+            /**
+             * Sets the logging history size.
+             */
+            readonly maxHistorySize: number;
+        };
+        /**
+         * Gates all log handlers to logs of at least this level.
+         */
+        readonly logLevel: LogLevel;
+        readonly console: {
+            /**
+             * Gates console logs
+             */
+            readonly logLevel: LogLevel;
+        };
+    };
+}
+/**
+ * Applies configuration to the current vinyl global options.
+ *
+ * @param options
+ */
+export declare function configureVinylGlobal(options: PartialDeep<VinylGlobalOptions>): void;
+//# sourceMappingURL=configureVinylGlobal.d.ts.map

package/dist/types/ts4.7/global/environment.d.ts

@@ -0,0 +1,6 @@
+/**
+ * process.env.VINYL_VERSION will be null in node unit tests, but in the built library it is
+ * replaced by the webpack DefinePlugin with the package.version.
+ */
+export declare const vinylVersion: import("@amazon/vinyl-util").Version;
+//# sourceMappingURL=environment.d.ts.map

package/dist/types/ts4.7/global/globalRef.d.ts

@@ -0,0 +1,32 @@
+import { type AnyRecord } from '@amazon/vinyl-util';
+declare global {
+    /**
+     * A reference to Vinyl's global state, easily accessible via console.
+     */
+    var vinylGlobal: any;
+}
+/**
+ * For console debugging, gives access to currently active players, logs, and client information.
+ */
+export declare class VinylGlobal {
+    get players(): readonly AnyRecord[];
+    /**
+     * Returns the first player.
+     */
+    get player(): AnyRecord;
+    get logs(): readonly import("@amazon/vinyl-util").HistoryLogItem[] | undefined;
+    get version(): string;
+    get userAgentInfo(): import("@amazon/vinyl-util").UserAgentInfo;
+    get network(): import("@amazon/vinyl-util").NetworkMetrics;
+    /**
+     * Returns the EWMA low estimate for the client's current bandwidth.
+     */
+    get bandwidth(): number;
+}
+/**
+ * Set the global vinylGlobal reference for easier console debugging.
+ * Intentionally typed as AnyRecord to prevent API usage from code. This is
+ * intended only for console debugging and the API may change at any time.
+ */
+export declare const vinylGlobalRef: import("@amazon/vinyl-util").GlobalRef<AnyRecord>;
+//# sourceMappingURL=globalRef.d.ts.map

package/dist/types/ts4.7/global/initializeVinylGlobal.d.ts

@@ -0,0 +1,2 @@
+export declare function initializeVinylGlobal(): void;
+//# sourceMappingURL=initializeVinylGlobal.d.ts.map