@amazon/vinyl-util 1.0.0

package/dist/types/ts4.1/client/userAgent/defaultUserAgentRules.d.ts

@@ -0,0 +1,94 @@
+import type { 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/ts4.1/client/userAgent/hasBrowser.d.ts

@@ -0,0 +1,26 @@
+import type { Browser } from './defaultUserAgentRules';
+import type { UserAgentInfo } from './UserAgentInfo';
+import type { 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/ts4.1/client/userAgent/parseUserAgent.d.ts

@@ -0,0 +1,14 @@
+import type { Maybe } from '../../util/type';
+import type { UserAgentRules } from './tokenizeUserAgent';
+import type { 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/ts4.1/client/userAgent/tokenizeUserAgent.d.ts

@@ -0,0 +1,104 @@
+import type { Maybe } from '../../util/type';
+import type { Version } from '../../client/Version';
+import type { 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/ts4.1/client/userAgent/userAgentRuleHelpers.d.ts

@@ -0,0 +1,52 @@
+import type { Maybe } from '../../util/type';
+import type { 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/ts4.1/core/Unsubscribe.d.ts

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

package/dist/types/ts4.1/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/ts4.1/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/ts4.1/core/disposable.d.ts

@@ -0,0 +1,66 @@
+import { IllegalStateError } from '../error/IllegalStateError';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { 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/ts4.1/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/ts4.1/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/ts4.1/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/ts4.1/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/ts4.1/error/MediaUnsupportedError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from '../error/ReportableError';
+import type { 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/ts4.1/error/ReportableError.d.ts

@@ -0,0 +1,39 @@
+import type { 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

package/dist/types/ts4.1/error/ServiceResponseError.d.ts

@@ -0,0 +1,14 @@
+import { ReportableError } from './ReportableError';
+import type { Json } from '../util/serialization/json';
+export declare const SERVICE_RESPONSE_ERROR_MESSAGE = "Unexpected service response";
+export declare class ServiceResponseError extends ReportableError {
+    readonly reason: any;
+    constructor(reason: any);
+    get [Symbol.toStringTag](): string;
+    toJSON(): Json;
+}
+/**
+ * When used in a catch clause of a promise, wraps the reason in a {@link ServiceResponseError}.
+ */
+export declare function throwServiceResponse(reason: any): never;
+//# sourceMappingURL=ServiceResponseError.d.ts.map

package/dist/types/ts4.1/error/StackOverflowError.d.ts

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

package/dist/types/ts4.1/error/TimeoutError.d.ts

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

package/dist/types/ts4.1/error/UnreachableCodeError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating that a line of code was hit that should not be possible.
+ */
+export declare class UnreachableCodeError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor();
+}
+//# sourceMappingURL=UnreachableCodeError.d.ts.map

package/dist/types/ts4.1/error/ValidationError.d.ts

@@ -0,0 +1,17 @@
+import { ReportableError } from '../error/ReportableError';
+import type { Json } from '../util/serialization/json';
+/**
+ * An error indicating that input had an invalid shape.
+ */
+export declare class ValidationError extends ReportableError {
+    readonly path: readonly string[];
+    get [Symbol.toStringTag](): string;
+    /**
+     * @param message The validation error message.
+     * @param origin The error origin, typically API (default) or SERVICE_EXTERNAL
+     * @param path The property path to the invalid field.
+     */
+    constructor(message: string, origin?: string, path?: readonly string[]);
+    toJSON(): Json;
+}
+//# sourceMappingURL=ValidationError.d.ts.map

package/dist/types/ts4.1/event/DomEventHost.d.ts

@@ -0,0 +1,45 @@
+import type { Disposable } from '../core/disposable';
+import type { ReadonlyEventHost } from './EventHost';
+import type { EventHandler, SignalOptions } from './Signal';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { ExtractValues } from '../util/type';
+/**
+ * Picks the keys from T that satisfy: `[keyof T extends string]: Event`
+ */
+export type DomEventMap<T> = ExtractValues<Pick<T, keyof T & string>, Event>;
+export interface DomReadonlyEventHost<EventMap> extends ReadonlyEventHost<DomEventMap<EventMap>> {
+    /**
+     * Adds an event handler for the given typed event.
+     *
+     * @param type A case-sensitive string representing the event type to listen for.
+     * @param handler A callback to invoke when the event with the given type is dispatched.
+     * @param options An options object specifies characteristics about the event listener.
+     * @return Returns a method, when invoked, removes the handler.
+     */
+    on<K extends keyof DomEventMap<EventMap>>(type: K, handler: EventHandler<DomEventMap<EventMap>[K]>, options?: DomEventListenerOptions): Unsubscribe;
+}
+/**
+ * Event listener options for DOM events.
+ *
+ * Note: signal not supported, use abort utilities.
+ */
+export interface DomEventListenerOptions extends SignalOptions, Omit<AddEventListenerOptions, 'signal'> {
+}
+/**
+ * Wraps a js `EventTarget` with a {@link ReadonlyEventHost} interface.
+ */
+export declare class DomEventHost<EventMap> implements DomReadonlyEventHost<EventMap>, Disposable {
+    protected readonly eventTarget: EventTarget;
+    private activeSubs;
+    private listenerCounts;
+    constructor(eventTarget: EventTarget);
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof DomEventMap<EventMap>): boolean;
+    on<K extends keyof DomEventMap<EventMap>>(type: K, handler: EventHandler<DomEventMap<EventMap>[K]>, options?: DomEventListenerOptions): Unsubscribe;
+    /**
+     * Disposal of a DomEventHost removes all listeners.
+     */
+    dispose(): void;
+    __eventMapType: import("../util/type").Covariant<EventMap>;
+}
+//# sourceMappingURL=DomEventHost.d.ts.map