const onDataProcessed = new Delegate<[data: Uint8Array]>();

// adding a module or global-scoped callback
const processData = function(data: Uint8Array) {
    // ... process data ...
};

onDataProcessed.addListener(processData);

// notify listeners with data
onDataProcessed(new Uint8Array(...));

class DataReceiver {
    constructor() { }

    handleData(data: Uint8Array) {
        // ... process data ...
    }
}
const dataReceiver = new DataReceiver();

// specify `this` context as the second argument
onDataProcessed.addListener(dataReceiver.handleData, dataReceiver);

// module/global-scoped function
onDataProcessed.removeListener(processData);

// member function
onDataProcessed.removeListener(dataReceiver.handleData, dataReceiver);

const fireAndForget = function(data: Uint8Array) {
    // do something

    onDataProcessed.removeListener(fireAndForget);
}

onDataProcessed.addListener()

// await each async callback sequentially
await onDataProcessed.asyncSeq(new Uint8Array(...));

// allow each async callback to resolve freely
await onDataProcessed.asyncAll(new Uint8Array(...));

// object literal pattern is recommended for type inference
const trackEvents = {
    onMarker: new Delegate<[name: string, timestamp: number]>(),
    onTrackEnd: new Delegate(),
    onTransition: new Delegate<[from: number, to: number]>()
};

// in a class
class TrackManager {
    constructor() { }

    events = {
        onMarker: new Delegate<[name: string, timestamp: number]>(),
        onTrackEnd: new Delegate(),
        onTransition: new Delegate<[from: number, to: number]>()
    }
}