@microbit/microbit-connection 0.9.0-apps.alpha.16 → 0.9.0-apps.alpha.17

package/build/cjs/device.d.ts

@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: MIT
  */
-import { TypedEventTarget, ValueIsEvent } from "./events.js";
+import { TypedEventTarget } from "./events.js";
 /**
  * Connection availability status returned by checkAvailability().
  * Used for pre-flight UX decisions before attempting to connect.
@@ -40,9 +40,13 @@ export type DeviceErrorCode =
  */
  | "timeout-error"
 /**
- * This is the fallback error case suggesting that the user reconnects their device.
+ * This is the fallback error case suggesting that the user physically reconnects their device.
  */
  | "reconnect-microbit"
+/**
+ * An operation was attempted that requires an active connection.
+ */
+ | "not-connected"
 /**
  * Error occured during serial or bluetooth communication.
  */
@@ -91,36 +95,26 @@ export type DeviceErrorCode =
  * Aligns with ConnectionAvailabilityStatus "location-disabled".
  */
  | "location-disabled";
-export declare enum ProgressStage {
-    /**
-     * Checking permissions and availability before connecting.
-     */
-    Initializing = "Initializing",
-    /**
-     * Finding device.
-     */
-    FindingDevice = "FindingDevice",
-    /**
-     * Checking that a bond is established. Only applicable on Native platforms.
-     */
-    CheckingBond = "CheckingBond",
-    /**
-     * Resetting device in preparation for flashing. Only applicable on Native platforms.
-     */
-    ResettingDevice = "ResettingDevice",
-    /**
-     * Connecting for flashing.
-     */
-    Connecting = "Connecting",
-    /**
-     * Partial flashing.
-     */
-    PartialFlashing = "PartialFlashing",
-    /**
-     * Full flashing.
-     */
-    FullFlashing = "FullFlashing"
-}
+/**
+ * Stages reported by the progress callback during connection and flashing.
+ */
+export declare const ProgressStage: {
+    /** Checking permissions and availability before connecting. */
+    readonly Initializing: "Initializing";
+    /** Finding device. */
+    readonly FindingDevice: "FindingDevice";
+    /** Checking that a bond is established. Only applicable on Native platforms. */
+    readonly CheckingBond: "CheckingBond";
+    /** Resetting device in preparation for flashing. Only applicable on Native platforms. */
+    readonly ResettingDevice: "ResettingDevice";
+    /** Connecting for flashing. */
+    readonly Connecting: "Connecting";
+    /** Partial flashing. */
+    readonly PartialFlashing: "PartialFlashing";
+    /** Full flashing. */
+    readonly FullFlashing: "FullFlashing";
+};
+export type ProgressStage = (typeof ProgressStage)[keyof typeof ProgressStage];
 /**
  * Progress callback for tracking operation stages (connection and flashing).
  *
@@ -156,10 +150,15 @@ export declare class DeviceError extends Error {
         message?: string;
     });
 }
+/**
+ * Asserts that a connection is active, throwing a {@link DeviceError}
+ * with code `"not-connected"` if it is not.
+ */
+export declare function assertConnected<T>(connection: T | undefined): asserts connection is T;
 /**
  * Tracks connection status.
  */
-export declare enum ConnectionStatus {
+export declare const ConnectionStatus: {
     /**
      * No device available.
      *
@@ -169,26 +168,21 @@ export declare enum ConnectionStatus {
      * Use checkAvailability() to determine whether the connection type is
      * supported before attempting to connect.
      */
-    NO_AUTHORIZED_DEVICE = "NO_AUTHORIZED_DEVICE",
-    /**
-     * Authorized device available but we haven't connected to it.
-     */
-    DISCONNECTED = "DISCONNECTED",
-    /**
-     * Connected.
-     */
-    CONNECTED = "CONNECTED",
-    /**
-     * Connecting.
-     */
-    CONNECTING = "CONNECTING",
+    readonly NoAuthorizedDevice: "NoAuthorizedDevice";
+    /** Authorized device available but we haven't connected to it. */
+    readonly Disconnected: "Disconnected";
+    /** Connected. */
+    readonly Connected: "Connected";
+    /** Connecting. */
+    readonly Connecting: "Connecting";
     /**
      * Paused due to tab visibility. The connection was temporarily suspended
      * because the browser tab became hidden. Reconnection will be attempted
      * automatically when the tab becomes visible again.
      */
-    PAUSED = "PAUSED"
-}
+    readonly Paused: "Paused";
+};
+export type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
 export interface ConnectOptions {
     /**
      * Optional progress callback for tracking connection stages.
@@ -238,29 +232,22 @@ export declare class FlashDataError extends Error {
 }
 export type FlashDataSource = (boardVersion: BoardVersion) => Promise<string | Uint8Array>;
 export type BoardVersion = "V1" | "V2";
-export declare class ConnectionStatusEvent extends Event {
-    readonly status: ConnectionStatus;
-    readonly previousStatus: ConnectionStatus;
-    constructor(status: ConnectionStatus, previousStatus: ConnectionStatus);
-}
-export declare class BeforeRequestDevice extends Event {
-    constructor();
-}
-export declare class AfterRequestDevice extends Event {
-    constructor();
+export interface ConnectionStatusChange {
+    status: ConnectionStatus;
+    previousStatus: ConnectionStatus;
 }
-export declare class BackgroundErrorEvent extends Event {
-    readonly errorMessage: string;
-    readonly error?: unknown;
-    constructor(errorMessage: string, error?: unknown);
+export interface BackgroundErrorData {
+    message: string;
+    error?: unknown;
 }
-export declare class DeviceConnectionEventMap {
-    "status": ConnectionStatusEvent;
-    "backgrounderror": BackgroundErrorEvent;
-    "beforerequestdevice": Event;
-    "afterrequestdevice": Event;
+export interface DeviceConnectionEventMap {
+    status: ConnectionStatusChange;
+    backgrounderror: BackgroundErrorData;
+    beforerequestdevice: void;
+    afterrequestdevice: void;
+    flash: void;
 }
-export interface DeviceConnection<M extends ValueIsEvent<M>> extends TypedEventTarget<DeviceConnectionEventMap & M> {
+export interface DeviceConnection<M> extends TypedEventTarget<DeviceConnectionEventMap & M> {
     status: ConnectionStatus;
     /**
      * Initializes the device.
@@ -289,22 +276,42 @@ export interface DeviceConnection<M extends ValueIsEvent<M>> extends TypedEventT
     /**
      * Get the board version.
      *
-     * @returns the board version or undefined if there is no connection.
+     * Cached after the first successful connection until {@link clearDevice}
+     * is called, so remains available after disconnection.
+     *
+     * @returns the board version.
+     * @throws {DeviceError} with code `not-connected` if no device has been connected.
      */
-    getBoardVersion(): BoardVersion | undefined;
+    getBoardVersion(): BoardVersion;
     /**
      * Disconnect from the device.
      */
     disconnect(): Promise<void>;
     /**
-     * Write serial data to the device.
+     * Flash the micro:bit.
+     *
+     * Not all connection types support flashing. For example, radio bridge
+     * connections do not support flashing, and Bluetooth connections only
+     * support flashing on native platforms (not Web).
+     *
+     * Post-flash connection state differs by transport:
+     *
+     * - **USB**: The connection remains in {@link ConnectionStatus.Connected} state.
+     *   USB connects to the micro:bit's interface chip (running DAPLink firmware),
+     *   which is not affected by flashing the application processor, so the
+     *   connection persists and serial communication is automatically reinitialised.
      *
-     * Does nothing if there is no connection.
+     * - **Bluetooth**: The connection is always left in {@link ConnectionStatus.Disconnected}
+     *   state. Bluetooth connects to the application processor directly, which
+     *   reboots after flashing, so the connection is necessarily lost. Callers
+     *   must call {@link connect} again after flashing.
      *
-     * @param data The data to write.
-     * @returns A promise that resolves when the write is complete.
+     * @param dataSource The data to use.
+     * @param options Flash options and progress callback.
+     * @throws {DeviceError} On flash failure. The error.code property indicates the failure type.
+     * @throws {FlashDataError} If data preparation fails.
      */
-    serialWrite(data: string): Promise<void>;
+    flash?(dataSource: FlashDataSource, options: FlashOptions): Promise<void>;
     /**
      * Clear device to enable chooseDevice.
      */

package/build/cjs/device.js

@@ -1,37 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceConnectionEventMap = exports.BackgroundErrorEvent = exports.AfterRequestDevice = exports.BeforeRequestDevice = exports.ConnectionStatusEvent = exports.FlashDataError = exports.ConnectionStatus = exports.DeviceError = exports.ProgressStage = void 0;
-var ProgressStage;
-(function (ProgressStage) {
-    /**
-     * Checking permissions and availability before connecting.
-     */
-    ProgressStage["Initializing"] = "Initializing";
-    /**
-     * Finding device.
-     */
-    ProgressStage["FindingDevice"] = "FindingDevice";
-    /**
-     * Checking that a bond is established. Only applicable on Native platforms.
-     */
-    ProgressStage["CheckingBond"] = "CheckingBond";
-    /**
-     * Resetting device in preparation for flashing. Only applicable on Native platforms.
-     */
-    ProgressStage["ResettingDevice"] = "ResettingDevice";
-    /**
-     * Connecting for flashing.
-     */
-    ProgressStage["Connecting"] = "Connecting";
-    /**
-     * Partial flashing.
-     */
-    ProgressStage["PartialFlashing"] = "PartialFlashing";
-    /**
-     * Full flashing.
-     */
-    ProgressStage["FullFlashing"] = "FullFlashing";
-})(ProgressStage || (exports.ProgressStage = ProgressStage = {}));
+exports.FlashDataError = exports.ConnectionStatus = exports.DeviceError = exports.ProgressStage = void 0;
+exports.assertConnected = assertConnected;
+/**
+ * Stages reported by the progress callback during connection and flashing.
+ */
+exports.ProgressStage = {
+    /** Checking permissions and availability before connecting. */
+    Initializing: "Initializing",
+    /** Finding device. */
+    FindingDevice: "FindingDevice",
+    /** Checking that a bond is established. Only applicable on Native platforms. */
+    CheckingBond: "CheckingBond",
+    /** Resetting device in preparation for flashing. Only applicable on Native platforms. */
+    ResettingDevice: "ResettingDevice",
+    /** Connecting for flashing. */
+    Connecting: "Connecting",
+    /** Partial flashing. */
+    PartialFlashing: "PartialFlashing",
+    /** Full flashing. */
+    FullFlashing: "FullFlashing",
+};
 /**
  * Error type used for all interactions with this module.
  *
@@ -54,11 +43,19 @@ class DeviceError extends Error {
     }
 }
 exports.DeviceError = DeviceError;
+/**
+ * Asserts that a connection is active, throwing a {@link DeviceError}
+ * with code `"not-connected"` if it is not.
+ */
+function assertConnected(connection) {
+    if (!connection) {
+        throw new DeviceError({ code: "not-connected", message: "Not connected" });
+    }
+}
 /**
  * Tracks connection status.
  */
-var ConnectionStatus;
-(function (ConnectionStatus) {
+exports.ConnectionStatus = {
     /**
      * No device available.
      *
@@ -68,104 +65,21 @@ var ConnectionStatus;
      * Use checkAvailability() to determine whether the connection type is
      * supported before attempting to connect.
      */
-    ConnectionStatus["NO_AUTHORIZED_DEVICE"] = "NO_AUTHORIZED_DEVICE";
-    /**
-     * Authorized device available but we haven't connected to it.
-     */
-    ConnectionStatus["DISCONNECTED"] = "DISCONNECTED";
-    /**
-     * Connected.
-     */
-    ConnectionStatus["CONNECTED"] = "CONNECTED";
-    /**
-     * Connecting.
-     */
-    ConnectionStatus["CONNECTING"] = "CONNECTING";
+    NoAuthorizedDevice: "NoAuthorizedDevice",
+    /** Authorized device available but we haven't connected to it. */
+    Disconnected: "Disconnected",
+    /** Connected. */
+    Connected: "Connected",
+    /** Connecting. */
+    Connecting: "Connecting",
     /**
      * Paused due to tab visibility. The connection was temporarily suspended
      * because the browser tab became hidden. Reconnection will be attempted
      * automatically when the tab becomes visible again.
      */
-    ConnectionStatus["PAUSED"] = "PAUSED";
-})(ConnectionStatus || (exports.ConnectionStatus = ConnectionStatus = {}));
+    Paused: "Paused",
+};
 class FlashDataError extends Error {
 }
 exports.FlashDataError = FlashDataError;
-class ConnectionStatusEvent extends Event {
-    constructor(status, previousStatus) {
-        super("status");
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: status
-        });
-        Object.defineProperty(this, "previousStatus", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: previousStatus
-        });
-    }
-}
-exports.ConnectionStatusEvent = ConnectionStatusEvent;
-class BeforeRequestDevice extends Event {
-    constructor() {
-        super("beforerequestdevice");
-    }
-}
-exports.BeforeRequestDevice = BeforeRequestDevice;
-class AfterRequestDevice extends Event {
-    constructor() {
-        super("afterrequestdevice");
-    }
-}
-exports.AfterRequestDevice = AfterRequestDevice;
-class BackgroundErrorEvent extends Event {
-    constructor(errorMessage, error) {
-        super("backgrounderror");
-        Object.defineProperty(this, "errorMessage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: errorMessage
-        });
-        Object.defineProperty(this, "error", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: error
-        });
-    }
-}
-exports.BackgroundErrorEvent = BackgroundErrorEvent;
-class DeviceConnectionEventMap {
-    constructor() {
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "backgrounderror", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "beforerequestdevice", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "afterrequestdevice", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-}
-exports.DeviceConnectionEventMap = DeviceConnectionEventMap;
 //# sourceMappingURL=device.js.map

package/build/cjs/device.js.map

@@ -1 +1 @@
-{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/device.ts"],"names":[],"mappings":";;;AAqGA,IAAY,aA6BX;AA7BD,WAAY,aAAa;IACvB;;OAEG;IACH,8CAA6B,CAAA;IAC7B;;OAEG;IACH,gDAA+B,CAAA;IAC/B;;OAEG;IACH,8CAA6B,CAAA;IAC7B;;OAEG;IACH,oDAAmC,CAAA;IACnC;;OAEG;IACH,0CAAyB,CAAA;IACzB;;OAEG;IACH,oDAAmC,CAAA;IACnC;;OAEG;IACH,8CAA6B,CAAA;AAC/B,CAAC,EA7BW,aAAa,6BAAb,aAAa,QA6BxB;AAyBD;;;;;;;;GAQG;AACH,MAAa,WAAY,SAAQ,KAAK;IAEpC,YAAY,EAAE,IAAI,EAAE,OAAO,EAA+C;QACxE,KAAK,CAAC,OAAO,CAAC,CAAC;QAFjB;;;;;WAAsB;QAGpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAND,kCAMC;AAED;;GAEG;AACH,IAAY,gBA6BX;AA7BD,WAAY,gBAAgB;IAC1B;;;;;;;;OAQG;IACH,iEAA6C,CAAA;IAC7C;;OAEG;IACH,iDAA6B,CAAA;IAC7B;;OAEG;IACH,2CAAuB,CAAA;IACvB;;OAEG;IACH,6CAAyB,CAAA;IACzB;;;;OAIG;IACH,qCAAiB,CAAA;AACnB,CAAC,EA7BW,gBAAgB,gCAAhB,gBAAgB,QA6B3B;AAiDD,MAAa,cAAe,SAAQ,KAAK;CAAG;AAA5C,wCAA4C;AAQ5C,MAAa,qBAAsB,SAAQ,KAAK;IAC9C,YACkB,MAAwB,EACxB,cAAgC;QAEhD,KAAK,CAAC,QAAQ,CAAC,CAAC;QAHhB;;;;mBAAgB,MAAM;WAAkB;QACxC;;;;mBAAgB,cAAc;WAAkB;IAGlD,CAAC;CACF;AAPD,sDAOC;AAED,MAAa,mBAAoB,SAAQ,KAAK;IAC5C;QACE,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC/B,CAAC;CACF;AAJD,kDAIC;AAED,MAAa,kBAAmB,SAAQ,KAAK;IAC3C;QACE,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC9B,CAAC;CACF;AAJD,gDAIC;AAED,MAAa,oBAAqB,SAAQ,KAAK;IAC7C,YACkB,YAAoB,EACpB,KAAe;QAE/B,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAHzB;;;;mBAAgB,YAAY;WAAQ;QACpC;;;;mBAAgB,KAAK;WAAU;IAGjC,CAAC;CACF;AAPD,oDAOC;AAED,MAAa,wBAAwB;IAArC;QACE,4BAAA,QAAQ;;;;;WAAwB;QAChC,4BAAA,iBAAiB;;;;;WAAuB;QACxC,4BAAA,qBAAqB;;;;;WAAQ;QAC7B,4BAAA,oBAAoB;;;;;WAAQ;IAC9B,CAAC;CAAA;AALD,4DAKC"}
+{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/device.ts"],"names":[],"mappings":";;;AA2KA,0CAMC;AAxED;;GAEG;AACU,QAAA,aAAa,GAAG;IAC3B,+DAA+D;IAC/D,YAAY,EAAE,cAAc;IAC5B,sBAAsB;IACtB,aAAa,EAAE,eAAe;IAC9B,gFAAgF;IAChF,YAAY,EAAE,cAAc;IAC5B,yFAAyF;IACzF,eAAe,EAAE,iBAAiB;IAClC,+BAA+B;IAC/B,UAAU,EAAE,YAAY;IACxB,wBAAwB;IACxB,eAAe,EAAE,iBAAiB;IAClC,qBAAqB;IACrB,YAAY,EAAE,cAAc;CACpB,CAAC;AA2BX;;;;;;;;GAQG;AACH,MAAa,WAAY,SAAQ,KAAK;IAEpC,YAAY,EAAE,IAAI,EAAE,OAAO,EAA+C;QACxE,KAAK,CAAC,OAAO,CAAC,CAAC;QAFjB;;;;;WAAsB;QAGpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAND,kCAMC;AAED;;;GAGG;AACH,SAAgB,eAAe,CAC7B,UAAyB;IAEzB,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,WAAW,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC;IAC7E,CAAC;AACH,CAAC;AAED;;GAEG;AACU,QAAA,gBAAgB,GAAG;IAC9B;;;;;;;;OAQG;IACH,kBAAkB,EAAE,oBAAoB;IACxC,kEAAkE;IAClE,YAAY,EAAE,cAAc;IAC5B,iBAAiB;IACjB,SAAS,EAAE,WAAW;IACtB,kBAAkB;IAClB,UAAU,EAAE,YAAY;IACxB;;;;OAIG;IACH,MAAM,EAAE,QAAQ;CACR,CAAC;AAoDX,MAAa,cAAe,SAAQ,KAAK;CAAG;AAA5C,wCAA4C"}

package/build/cjs/events.d.ts

@@ -1,110 +1,11 @@
-/**
- * Copyright (c) 2022 Jonas "DerZade" Schade
- *
- * SPDX-License-Identifier: MIT
- *
- * https://github.com/DerZade/typescript-event-target/blob/master/src/TypedEventTarget.ts
- */
-/**
- * A function that can be passed to the `listener` parameter of {@link TypedEventTarget.addEventListener} and {@link TypedEventTarget.removeEventListener}.
- *
- * @template M A map of event types to their respective event classes.
- * @template T The type of event to listen for (has to be keyof `M`).
- */
-export type TypedEventListener<M, T extends keyof M> = (evt: M[T]) => void | Promise<void>;
-/**
- * An object that can be passed to the `listener` parameter of {@link TypedEventTarget.addEventListener} and {@link TypedEventTarget.removeEventListener}.
- *
- * @template M A map of event types to their respective event classes.
- * @template T The type of event to listen for (has to be keyof `M`).
- */
-export interface TypedEventListenerObject<M, T extends keyof M> {
-    handleEvent: (evt: M[T]) => void | Promise<void>;
-}
-/**
- * Type of parameter `listener` in {@link TypedEventTarget.addEventListener} and {@link TypedEventTarget.removeEventListener}.
- *
- * The object that receives a notification (an object that implements the Event interface) when an event of the specified type occurs.
- *
- * Can be either an object with a handleEvent() method, or a JavaScript function.
- *
- * @template M A map of event types to their respective event classes.
- * @template T The type of event to listen for (has to be keyof `M`).
- */
-export type TypedEventListenerOrEventListenerObject<M, T extends keyof M> = TypedEventListener<M, T> | TypedEventListenerObject<M, T>;
-export type ValueIsEvent<T> = {
-    [key in keyof T]: Event;
-};
-/**
- * Typescript friendly version of {@link EventTarget}
- *
- * @template M A map of event types to their respective event classes.
- *
- * @example
- * ```typescript
- * interface MyEventMap {
- *     hello: Event;
- *     time: CustomEvent<number>;
- * }
- *
- * const eventTarget = new TypedEventTarget<MyEventMap>();
- *
- * eventTarget.addEventListener('time', (event) => {
- *     // event is of type CustomEvent<number>
- * });
- * ```
- */
-export interface TypedEventTarget<M extends ValueIsEvent<M>> {
-    /** Appends an event listener for events whose type attribute value is type.
-     * The callback argument sets the callback that will be invoked when the event
-     * is dispatched.
-     *
-     * The options argument sets listener-specific options. For compatibility this
-     * can be a boolean, in which case the method behaves exactly as if the value
-     * was specified as options's capture.
-     *
-     * When set to true, options's capture prevents callback from being invoked
-     * when the event's eventPhase attribute value is BUBBLING_PHASE. When false
-     * (or not present), callback will not be invoked when event's eventPhase
-     * attribute value is CAPTURING_PHASE. Either way, callback will be invoked if
-     * event's eventPhase attribute value is AT_TARGET.
-     *
-     * When set to true, options's passive indicates that the callback will not
-     * cancel the event by invoking preventDefault(). This is used to enable
-     * performance optimizations described in § 2.8 Observing event listeners.
-     *
-     * When set to true, options's once indicates that the callback will only be
-     * invoked once after which the event listener will be removed.
-     *
-     * The event listener is appended to target's event listener list and is not
-     * appended if it has the same type, callback, and capture. */
-    addEventListener: <T extends keyof M & string>(type: T, listener: TypedEventListenerOrEventListenerObject<M, T> | null, options?: boolean | AddEventListenerOptions) => void;
-    /** Removes the event listener in target's event listener list with the same
-     * type, callback, and options. */
-    removeEventListener: <T extends keyof M & string>(type: T, callback: TypedEventListenerOrEventListenerObject<M, T> | null, options?: EventListenerOptions | boolean) => void;
-    /**
-     * Dispatches a synthetic event event to target and returns true if either
-     * event's cancelable attribute value is false or its preventDefault() method
-     * was not invoked, and false otherwise.
-     * @deprecated To ensure type safety use `dispatchTypedEvent` instead.
-     */
-    dispatchEvent: (event: Event) => boolean;
-}
-export declare class TrackingEventTarget extends EventTarget {
-    private activeEventTracking;
-    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-    dispatchEvent(event: Event): boolean;
-    private filterRegistrations;
-    protected eventActivated(type: string): void;
-    protected eventDeactivated(type: string): void;
+type Listener<T> = (data: T) => void;
+export declare class TypedEventTarget<M> {
+    private listeners;
+    addEventListener<K extends keyof M & string>(type: K, listener: Listener<M[K]>): void;
+    removeEventListener<K extends keyof M & string>(type: K, listener: Listener<M[K]>): void;
+    protected dispatchEvent<K extends keyof M & string>(type: K, ...[data]: M[K] extends void ? [] : [data: M[K]]): void;
+    protected eventActivated(_type: string): void;
+    protected eventDeactivated(_type: string): void;
     protected getActiveEvents(): string[];
 }
-export declare class TypedEventTarget<M extends ValueIsEvent<M>> extends TrackingEventTarget {
-    /**
-     * Dispatches a synthetic event event to target and returns true if either
-     * event's cancelable attribute value is false or its preventDefault() method
-     * was not invoked, and false otherwise.
-     */
-    dispatchTypedEvent<T extends keyof M>(_type: T, event: M[T]): boolean;
-}
+export {};