@amazon/vinyl-util 1.0.0

package/dist/types/current/util/url/resolveUrl.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Resolves a relative URI against a base URL using string manipulation,
+ * avoiding the overhead of constructing `URL` objects.
+ *
+ * Handles the same cases as `new URL(relative, base)`:
+ * - Absolute URIs (with scheme) are returned as-is.
+ * - Protocol-relative URIs (`//host/path`) inherit the base scheme.
+ * - Absolute paths (`/path`) replace the base path.
+ * - Relative paths are resolved against the base directory.
+ *
+ * @param relative The relative (or absolute) URI to resolve.
+ * @param base The base URL string to resolve against.
+ * @returns A resolved absolute URL string.
+ */
+export function resolveUrl(relative, base) {
+    // Absolute URI — has a scheme.
+    if (relative.indexOf('://') > 0)
+        return relative;
+    // Protocol-relative.
+    if (relative.startsWith('//')) {
+        const schemeEnd = base.indexOf('://');
+        return base.substring(0, schemeEnd + 1) + relative;
+    }
+    const schemeEnd = base.indexOf('://') + 3;
+    const pathStart = base.indexOf('/', schemeEnd);
+    const origin = pathStart === -1 ? base : base.substring(0, pathStart);
+    // Absolute path.
+    if (relative.startsWith('/'))
+        return origin + relative;
+    // Empty relative — return base as-is.
+    if (relative === '')
+        return base;
+    // Relative path — resolve against base directory.
+    const basePath = pathStart === -1 ? '/' : base.substring(pathStart);
+    const lastSlash = basePath.lastIndexOf('/');
+    const dir = basePath.substring(0, lastSlash + 1);
+    return origin + resolveDots(dir + relative);
+}
+/**
+ * Extracts the hostname from an absolute URL string.
+ *
+ * @param url An absolute URL string (e.g. `https://example.com:8080/path`).
+ * @returns The hostname (e.g. `example.com`).
+ */
+export function getHostname(url) {
+    const start = url.indexOf('://') + 3;
+    let end = url.indexOf('/', start);
+    if (end === -1)
+        end = url.length;
+    const hostPort = url.substring(start, end);
+    const colon = hostPort.indexOf(':');
+    return colon === -1 ? hostPort : hostPort.substring(0, colon);
+}
+/**
+ * Resolves `.` and `..` segments in a path.
+ */
+function resolveDots(path) {
+    // Fast path: no dots to resolve.
+    if (path.indexOf('.') === -1)
+        return path;
+    const parts = path.split('/');
+    const out = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p === '..') {
+            // Don't pop past root.
+            if (out.length > 1)
+                out.pop();
+        }
+        else if (p !== '.') {
+            out.push(p);
+        }
+    }
+    return out.join('/');
+}

package/dist/types/ts3.7/client/Version.d.ts

@@ -0,0 +1,38 @@
+import { Comparator } from '../util/comparison/compare';
+import { Maybe } from '../util/type';
+/**
+ * An object representing a version.
+ */
+export interface Version {
+    readonly str: string;
+    readonly major: number;
+    readonly minor: number | null;
+    readonly patch: number | null;
+    readonly build: number | null;
+}
+/**
+ * A comparator for Version objects.
+ * This strict comparator will consider 1.0.0 > 1.0. Use {@link compareVersions} if null
+ * segments should be treated as zero values.
+ * Use this comparator when stable sorting.
+ */
+export declare const compareVersionsStrict: Comparator<Version | null>;
+/**
+ * A comparator for Version objects.
+ * Unlike {@link compareVersionsStrict}, 1.0.0.0 === 1.
+ * Use this comparator when comparing two versions and order does not need to be stable.
+ */
+export declare const compareVersions: Comparator<Version | null>;
+/**
+ * Given a string containing a semver-like version string, finds and returns the parsed Version.
+ *
+ * @param str
+ */
+export declare function parseVersion(str: string): Version;
+/**
+ * Given a string containing a semver-like version string, finds and returns the parsed Version.
+ *
+ * @param str
+ */
+export declare function parseVersion(str: Maybe<string>): Version | null;
+//# sourceMappingURL=Version.d.ts.map

package/dist/types/ts3.7/client/userAgent/UserAgentInfo.d.ts

@@ -0,0 +1,36 @@
+import { Version } from '../../client/Version';
+/**
+ * A parsed user agent.
+ */
+export interface UserAgentInfo {
+    readonly userAgent: string;
+    readonly browser: UaSystemInfo | null;
+    readonly browserLike: UaSystemInfo | null;
+    readonly device: UaDeviceInfo | null;
+    readonly os: UaSystemInfo | null;
+    readonly osLike: UaSystemInfo | null;
+}
+/**
+ * Platform or system information.
+ */
+export interface UaSystemInfo {
+    readonly name: string;
+    readonly version: Version | null;
+}
+/**
+ * Device information from the user agent.
+ */
+export interface UaDeviceInfo {
+    readonly vendor: string | null;
+    readonly model: string | null;
+    readonly type: string | null;
+}
+export declare const emptyUserAgentInfo: {
+    readonly userAgent: "";
+    readonly browser: null;
+    readonly browserLike: null;
+    readonly os: null;
+    readonly osLike: null;
+    readonly device: null;
+};
+//# sourceMappingURL=UserAgentInfo.d.ts.map

package/dist/types/ts3.7/client/userAgent/defaultUserAgentRules.d.ts

@@ -0,0 +1,94 @@
+import { UserAgentRules } from './tokenizeUserAgent';
+/**
+ * An enumeration of operating systems that can be detected from the user agent.
+ */
+export declare enum Os {
+    ANDROID = "Android",
+    ANDROID_OSP = "Android OSP",
+    CHROME_OS = "chromeOS",
+    CHROMECAST = "Chromecast",
+    FEDORA = "Fedora",
+    FIREFOX_OS = "Firefox OS",// Firefox OS (legacy) does not have a differentiable user agent
+    FIRE_OS = "Fire OS",
+    FREE_BSD = "FreeBSD",
+    HARMONY_OS = "HarmonyOS",
+    I_OS = "iOS",
+    KAIOS = "KaiOS",// Based on the discontinued Firefox OS
+    LINUX = "Linux",
+    MAC_OS = "macOS",
+    MIUI = "MIUI",
+    ORBIS = "Orbis OS",
+    SMART_CAST = "SmartCast",
+    SYMBIAN = "Symbian",
+    TIZEN = "Tizen",
+    UBUNTU = "Ubuntu",
+    VEGA = "Vega",
+    WEB_OS = "webOS",
+    WINDOWS = "Windows",
+    WINDOWS_PHONE = "Windows Phone"
+}
+/**
+ * An enumeration of browsers that can be detected from the user agent.
+ */
+export declare enum Browser {
+    BRAVE = "Brave",
+    CHROME = "Chrome",
+    CHROME_HEADLESS = "Chrome Headless",
+    CHROMIUM = "Chromium",
+    DUCK_DUCK_GO = "DuckDuckGo",
+    EDGE_CHROMIUM = "Edge Chromium",
+    EDGE_LEGACY = "Edge Legacy",
+    ELECTRON = "Electron",
+    FIREFOX = "Firefox",
+    HUAWEI = "Huawei",
+    IE = "IE",
+    IE_MOBILE = "IE Mobile",// AKA Pocket Internet Explorer
+    OCULUS = "Oculus Browser",
+    OPENWAVE = "Openwave",
+    OPERA = "Opera",
+    OPERA_TOUCH = "Opera Touch",
+    QUARK = "Quark",
+    SILK = "Silk",
+    SAFARI = "Safari",
+    SAMSUNG_BROWSER = "Samsung Browser",
+    UC_BROWSER = "UC Browser",
+    WPE = "WPE WebKit",
+    YANDEX = "Yandex",
+    WEBKIT = "WebKit"
+}
+export declare enum DeviceVendor {
+    AMAZON = "Amazon",
+    APPLE = "Apple",
+    FACEBOOK = "Facebook",
+    GOOGLE = "Google",
+    HISENSE = "Hisense",
+    HTC = "HTC",
+    HUAWEI = "Huawei",
+    K = "K",
+    LG = "LG",
+    MEIZU = "Meizu",
+    MICROSOFT = "Microsoft",
+    MOTOROLA = "Motorola",
+    NINTENDO = "Nintendo",
+    NOKIA = "Nokia",
+    NVIDIA = "Nvidia",
+    ONE_PLUS = "OnePlus",
+    OPPO = "OPPO",
+    ROKU = "Roku",
+    SAMSUNG = "Samsung",
+    SKY = "Sky",
+    SKY_DEVICES = "SKY Devices",// Not related to the set-top boxes.
+    SONY = "Sony",
+    TESLA = "Tesla",
+    VIZIO = "VIZIO"
+}
+export declare enum DeviceType {
+    AUTOMOTIVE = "automotive",
+    CONSOLE = "console",
+    DESKTOP = "desktop",
+    SMART_TV = "smarttv",
+    MOBILE = "mobile",
+    WEARABLE = "wearable"
+}
+export declare const defaultUserAgentRules: UserAgentRules;
+//# sourceMappingURL=defaultUserAgentRules.d.ts.map

package/dist/types/ts3.7/client/userAgent/hasBrowser.d.ts

@@ -0,0 +1,26 @@
+import { Browser } from './defaultUserAgentRules';
+import { UserAgentInfo } from './UserAgentInfo';
+import { Maybe } from '../../util/type';
+export interface HasBrowserOptions {
+    /**
+     * If true (default), checks both {@link UserAgentInfo.browserLike} (first) and
+     * {@link UserAgentInfo.browser} for a name match.
+     */
+    readonly checkBrowserLike?: boolean;
+    /**
+     * The parsed user agent to query. Default is the browser's parsed user agent.
+     */
+    readonly userAgentInfo?: UserAgentInfo;
+}
+/**
+ * Returns true if the current user agent matches the given browser.
+ *
+ * @param browser
+ * @param minVersionStr If provided, only returns true if the browser version is at least this version.
+ * Must be parsable by {@link parseVersion}.
+ * @param maxVersionStr If provided, only returns true if the browser version is at most this version.
+ * Must be parsable by {@link parseVersion}.
+ * @param options Additional optional configuration.
+ */
+export declare function hasBrowser(browser: Browser, minVersionStr?: Maybe<string>, maxVersionStr?: Maybe<string>, options?: HasBrowserOptions): boolean;
+//# sourceMappingURL=hasBrowser.d.ts.map

package/dist/types/ts3.7/client/userAgent/parseUserAgent.d.ts

@@ -0,0 +1,14 @@
+import { Maybe } from '../../util/type';
+import { UserAgentRules } from './tokenizeUserAgent';
+import { UserAgentInfo } from './UserAgentInfo';
+/**
+ * Parses the user agent into a {@link UserAgentInfo} object.
+ *
+ * @param userAgent The User Agent. Default: `navigator.userAgent`.
+ * @param rules The user agent rules.
+ */
+export declare function parseUserAgent(userAgent?: Maybe<string>, rules?: UserAgentRules): UserAgentInfo;
+export declare const userAgentInfoRef: import("../../global/globalRegistry").GlobalRef<UserAgentInfo>;
+export declare function getUserAgentInfo(): UserAgentInfo;
+export declare function setUserAgent(value: string): void;
+//# sourceMappingURL=parseUserAgent.d.ts.map

package/dist/types/ts3.7/client/userAgent/tokenizeUserAgent.d.ts

@@ -0,0 +1,104 @@
+import { Maybe } from '../../util/type';
+import { Version } from '../../client/Version';
+import { UaDeviceInfo, UaSystemInfo } from './UserAgentInfo';
+/**
+ * Builds a tokenized user agent for faster queries.
+ *
+ * @param userAgent
+ */
+export declare function tokenizeUserAgent(userAgent: string): TokenizedUserAgent;
+/**
+ * A User Agent rule takes a tokenized user agent, and if the rule matches, returns the Browser
+ * or Platform
+ * information. Otherwise, returns null.
+ */
+export type SystemInfoRule = (tokenizedUa: TokenizedUserAgent) => UaSystemInfo | null;
+/**
+ * A User Agent rule takes a tokenized user agent, and if the rule matches, returns the Device
+ * information. Otherwise, returns null.
+ */
+export type DeviceInfoRule = (tokenizedUa: TokenizedUserAgent) => UaDeviceInfo | null;
+/**
+ * A User Agent rule takes a tokenized user agent, and if the rule matches, returns the Browser
+ * or Platform
+ * information. Otherwise, returns null.
+ */
+export type SystemInfoLikeRule = (tokenizedUa: TokenizedUserAgent, systemInfo: UaSystemInfo | null) => UaSystemInfo | null;
+/**
+ * The ruleset to use when parsing a user agent.
+ * Rules are expected to be from most specific to least.
+ */
+export interface UserAgentRules {
+    readonly browserRules: readonly SystemInfoRule[];
+    readonly browserLikeRules: readonly SystemInfoLikeRule[];
+    readonly osRules: readonly SystemInfoRule[];
+    readonly osLikeRules: readonly SystemInfoLikeRule[];
+    readonly deviceRules: readonly DeviceInfoRule[];
+}
+/**
+ * A tokenized user agent.
+ * A common format for user agents:
+ * `Mozilla/5.0 (<system-information>) <platform> (<platform-details>) [extensions]`
+ *
+ */
+export interface TokenizedUserAgent {
+    /**
+     * The original user agent.
+     */
+    readonly userAgent: string;
+    /**
+     * The tokenized system and platform details or extensions (parts within parenthetical sections
+     * separated by semicolons.)
+     */
+    readonly system: TokenizedInfo;
+    /**
+     * The tokenized platform info (parts outside parenthetical sections, separated by
+     * whitespace.)
+     */
+    readonly platform: TokenizedInfo;
+}
+/**
+ * A parsed system or extension part of the user agent. (A section within a parenthetical)
+ */
+export interface UserAgentPart extends UaSystemInfo {
+    readonly name: string;
+    readonly version: Version | null;
+    readonly tokens: readonly string[];
+}
+export declare class TokenizedInfo {
+    readonly parts: UserAgentPart[];
+    /**
+     * A token map of lowercase token strings to name/version pairs.
+     */
+    private readonly tokenMap;
+    constructor(parts: UserAgentPart[]);
+    /**
+     * Given lowercase tokens of only alpha characters, returns the mapped token part if all tokens
+     * are contained in the section.
+     */
+    get(...tokens: readonly string[]): UaSystemInfo | null;
+    /**
+     * Given an expression of logical operators, returns the name and version of the part
+     * that matches the expression.
+     *
+     * Logical operators currently supported: | for OR and & for AND.
+     * Operands between operators will be tokenized via {@link tokenizeWords}.
+     *
+     * @param expr The expression of tokens and operators. Example: 'windows phone|windows&mobile'
+     * will match when one part has both 'windows' and 'phone' or there are two parts, one with
+     * 'windows' and another part with 'mobile'
+     * (Case insensitive)
+     */
+    query(expr: string): UaSystemInfo | null;
+}
+/**
+ * Executes a logical expression mapping tokens with a predicate, using the result as operands.
+ *
+ * Logical operators currently supported: | for OR and & for AND.
+ * Operands between operators will be tokenized via {@link tokenizeWords}.
+ *
+ * @param expr The expression of tokens and operators.
+ * @param predicate Each token set operand will be mapped using this function.
+ */
+export declare function tokenQuery<T>(expr: string, predicate: (tokens: readonly string[]) => Maybe<T>): T | null;
+//# sourceMappingURL=tokenizeUserAgent.d.ts.map

package/dist/types/ts3.7/client/userAgent/userAgentRuleHelpers.d.ts

@@ -0,0 +1,52 @@
+import { Maybe } from '../../util/type';
+import { DeviceInfoRule, SystemInfoLikeRule, SystemInfoRule, TokenizedUserAgent } from './tokenizeUserAgent';
+/**
+ * A rule to match platform information (parts outside parentheticals).
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ */
+export declare function uaPlatformRule(name: string, expr: string): SystemInfoRule;
+/**
+ * A rule to match system information. (Matches parts within parentheticals.)
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ * @param hasVersion If true, the version will be inferred from the matched part.
+ */
+export declare function uaSystemRule(name: string, expr: string, hasVersion: boolean): SystemInfoRule;
+/**
+ * A rule to match platform or system information.
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr A token expression.
+ */
+export declare function uaPlatformOrSystemRule(name: string, expr: string): SystemInfoRule;
+/**
+ * Changes the name of the Name/Version part returned from the given rule.
+ *
+ * @param name
+ * @param rule
+ */
+export declare function uaName(name: string, rule: SystemInfoRule): SystemInfoRule;
+export declare function uaSystemLike(name: string, derived: readonly string[]): SystemInfoLikeRule;
+/**
+ * A rule to match system or platform information, providing vendor and type information.
+ *
+ * @param vendor The device make/vendor to use when there's a match.
+ * @param type The type of device, e.g. 'mobile' or 'tablet'.
+ * @param expr The token expression to use to determine a match. If there is a match, the
+ * matched name will be used as the model unless model is explicit.
+ * @param model If defined, will be used as the model string instead of the matched expression
+ * name.
+ */
+export declare function uaDeviceRule(vendor: string | null, type: string | null, expr: string, model?: Maybe<string>): DeviceInfoRule;
+/**
+ * A rule that executes a regex, transforming the match result.
+ *
+ * @param expr
+ * @param onMatch When the expression matches, onMatch will be given the RegExpExecArray and return
+ * the final info object.
+ */
+export declare function regexRule<T>(expr: RegExp, onMatch: (match: RegExpMatchArray) => T): (t: TokenizedUserAgent) => T | null;
+//# sourceMappingURL=userAgentRuleHelpers.d.ts.map

package/dist/types/ts3.7/core/Unsubscribe.d.ts

@@ -0,0 +1,2 @@
+export type Unsubscribe = () => void;
+//# sourceMappingURL=Unsubscribe.d.ts.map

package/dist/types/ts3.7/core/clearable.d.ts

@@ -0,0 +1,19 @@
+export interface Clearable {
+    /**
+     * Clears this object.
+     */
+    clear(): void;
+}
+/**
+ * Returns true if the value implements Clearable.
+ *
+ * @param value
+ */
+export declare function isClearable(value: any): value is Clearable;
+/**
+ * If the given object implements Clearable, executes clear.
+ *
+ * @param value
+ */
+export declare function maybeClear(value: any): void;
+//# sourceMappingURL=clearable.d.ts.map

package/dist/types/ts3.7/core/cloneable.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An interface that may be implemented to provide custom clone behavior.
+ */
+export interface Cloneable<T> {
+    /**
+     * Produces a copy of this object.
+     */
+    clone(): T;
+}
+/**
+ * Returns true if the given value implements Cloneable.
+ */
+export declare function isCloneable<T>(value: T): value is T & Cloneable<T>;
+//# sourceMappingURL=cloneable.d.ts.map

package/dist/types/ts3.7/core/disposable.d.ts

@@ -0,0 +1,66 @@
+import { IllegalStateError } from '../error/IllegalStateError';
+import { Unsubscribe } from '../core/Unsubscribe';
+import { Maybe } from '../util/type';
+/**
+ * Any object that may be disposed.
+ */
+export interface Disposable {
+    dispose(): void;
+}
+/**
+ * Returns true if the given value is disposable.
+ *
+ * @param value Any value. The value will be considered Disposable if it contains a method named
+ * 'dispose', and that function requires zero parameters. This value will be type guarded to
+ * Disposable if true is returned.
+ */
+export declare function isDisposable(value: any): value is Disposable;
+/**
+ * Disposes all the given {@link Disposable} objects.
+ *
+ * @param disposables
+ */
+export declare function disposeAll(disposables: Iterable<Disposable>): void;
+/**
+ * Returns a Disposable that invokes the given function on dispose.
+ *
+ * @param unsub
+ */
+export declare function toDisposable(unsub: () => void): Disposable;
+export type AddDisposable = <T extends Maybe<Disposable | Unsubscribe>>(disposable: T) => T;
+/**
+ * A Disposer disposes added disposables as a group.
+ * The method members may be called without a receiver.
+ */
+export interface Disposer extends Disposable {
+    readonly disposed: boolean;
+    readonly add: AddDisposable;
+    readonly dispose: () => void;
+}
+/**
+ * Creates a Disposer, an object on which {@link Disposable} instances may be added, and disposed
+ * as a group.
+ *
+ * The method members may be called without a receiver, thus allowing destructuring.
+ * Example:
+ * ```
+ * function create(): Disposable {
+ *   const { dispose, add } = disposer()
+ *   add(someDisposable)
+ *   add(anotherDisposable)
+ *   return {
+ *     dispose
+ *   }
+ * }
+ * ```
+ *
+ */
+export declare function createDisposer(): Disposer;
+/**
+ * An illegal state error indicating that an object has been disposed.
+ */
+export declare class DisposedError extends IllegalStateError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=disposable.d.ts.map

package/dist/types/ts3.7/error/AbortError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from './ReportableError';
+export declare class AbortError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=AbortError.d.ts.map

package/dist/types/ts3.7/error/ErrorOrigin.d.ts

@@ -0,0 +1,45 @@
+export declare const ErrorOrigin: {
+    /**
+     * The error originated from Vinyl and was reported from the uncaught exception or promise
+     * rejection handlers.
+     */
+    UNCAUGHT: string;
+    /**
+     * The error originated from Vinyl and was caught.
+     */
+    INTERNAL: string;
+    /**
+     * A Vinyl interface was used incorrectly by a consumer.
+     */
+    API: string;
+    /**
+     * The error originated from a failed service call (500 errors).
+     */
+    SERVICE_EXTERNAL: string;
+    /**
+     * The error originated from a failed service call (400 errors).
+     */
+    SERVICE_INTERNAL: string;
+    /**
+     * The error originated from a problem playing provided media.
+     * The reporter is from a component such as the element, source buffer, media source, etc.
+     */
+    MEDIA: string;
+    /**
+     * The error originated from a problem parsing input data.
+     * Such as a malformed Dash or HLS manifest.
+     */
+    PARSING: string;
+    /**
+     * The error originated from an incompatibility with browser APIs,
+     * such as EME.
+     */
+    COMPATIBILITY: string;
+    /**
+     * The error originated from DRM.
+     * This does not include internal or service errors, only errors from the creation of media keys or media key
+     * sessions.
+     */
+    DRM: string;
+};
+//# sourceMappingURL=ErrorOrigin.d.ts.map

package/dist/types/ts3.7/error/IllegalArgumentError.d.ts

@@ -0,0 +1,10 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating that a method was called with illegal arguments.
+ */
+export declare class IllegalArgumentError extends ReportableError {
+    readonly isInternal: boolean;
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, isInternal?: boolean);
+}
+//# sourceMappingURL=IllegalArgumentError.d.ts.map

package/dist/types/ts3.7/error/IllegalStateError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating an unexpected state.
+ */
+export declare class IllegalStateError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string);
+}
+//# sourceMappingURL=IllegalStateError.d.ts.map

package/dist/types/ts3.7/error/MediaUnsupportedError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from '../error/ReportableError';
+import { Json } from '../util/serialization/json';
+export declare class MediaUnsupportedError extends ReportableError {
+    readonly code: string;
+    constructor(message: string, code: string);
+    toJSON(): Json;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=MediaUnsupportedError.d.ts.map

package/dist/types/ts3.7/error/ReportableError.d.ts

@@ -0,0 +1,39 @@
+import { Json } from '../util/serialization/json';
+export declare enum ErrorLevel {
+    /**
+     * Fatal errors are not recoverable.
+     */
+    FATAL = "fatal",
+    /**
+     * Warn level errors should be reported, but are recoverable.
+     */
+    WARN = "warn",
+    /**
+     * Silent errors should not be reported. For example aborting a play operation due to a new track loading.
+     */
+    SILENT = "silent"
+}
+/**
+ * A Serializable Error that contains an error origin.
+ */
+export declare class ReportableError extends Error {
+    readonly origin: string;
+    readonly level: ErrorLevel;
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string, level?: ErrorLevel);
+    get name(): string;
+    /**
+     * All ReportableError instances must be serializable.
+     */
+    toJSON(): Json;
+}
+/**
+ * Returns true if the given object is a ReportableError.
+ */
+export declare function isReportableError(error: any): error is ReportableError;
+/**
+ * Returns true if the error is a ReportableError and is level SILENT.
+ * @param error
+ */
+export declare function isSilentError(error: any): boolean;
+//# sourceMappingURL=ReportableError.d.ts.map