event-target-shim

constructor(type: string, eventInitDict?: Event.EventInit);

static readonly AT_TARGET: number;

readonly AT_TARGET: number;

readonly bubbles: boolean;

static readonly BUBBLING_PHASE: number;

readonly BUBBLING_PHASE: number;

readonly cancelable: boolean;

cancelBubble: boolean;

static readonly CAPTURING_PHASE: number;

readonly CAPTURING_PHASE: number;

readonly composed: boolean;

readonly currentTarget: EventTarget<Record<string, Event<string>>, 'standard'>;

readonly defaultPrevented: boolean;

readonly eventPhase: number;

readonly isTrusted: boolean;

static readonly NONE: number;

readonly NONE: number;

returnValue: boolean;

readonly srcElement: EventTarget<Record<string, Event<string>>, 'standard'>;

readonly target: EventTarget<Record<string, Event<string>>, 'standard'>;

readonly timeStamp: number;

readonly type: string;

composedPath: () => EventTarget[];

initEvent: (type: string, bubbles?: boolean, cancelable?: boolean) => void;

preventDefault: () => void;

stopImmediatePropagation: () => void;

stopPropagation: () => void;

constructor();

addEventListener: {
    <T extends string & keyof TEventMap>(
        type: T,
        callback?: EventTarget.EventListener<this, TEventMap[T]> | null,
        options?: EventTarget.AddOptions
    ): void;
    (
        type: string,
        callback?: EventTarget.FallbackEventListener<this, TMode>,
        options?: EventTarget.AddOptions
    ): void;
    <T extends string & keyof TEventMap>(
        type: T,
        callback: EventTarget.EventListener<this, TEventMap[T]>,
        capture: boolean
    ): void;
    (
        type: string,
        callback: EventTarget.FallbackEventListener<this, TMode>,
        capture: boolean
    ): void;
};

dispatchEvent: {
    <T extends string & keyof TEventMap>(
        event: EventTarget.EventData<TEventMap, TMode, T>
    ): boolean;
    (event: EventTarget.FallbackEvent<TMode>): boolean;
};

removeEventListener: {
    <T extends string & keyof TEventMap>(
        type: T,
        callback?: EventTarget.EventListener<this, TEventMap[T]> | null,
        options?: EventTarget.Options
    ): void;
    (
        type: string,
        callback?: EventTarget.FallbackEventListener<this, TMode>,
        options?: EventTarget.Options
    ): void;
    <T extends string & keyof TEventMap>(
        type: T,
        callback: EventTarget.EventListener<this, TEventMap[T]>,
        capture: boolean
    ): void;
    (
        type: string,
        callback: EventTarget.FallbackEventListener<this, TMode>,
        capture: boolean
    ): void;
};

type CustomEventTarget<
    TEventMap extends Record<string, Event>,
    TMode extends 'standard' | 'strict'
> = EventTarget<TEventMap, TMode> &
    defineEventAttribute.EventAttributes<any, TEventMap>;

type CustomEventTargetConstructor<
    TEventMap extends Record<string, Event>,
    TMode extends 'standard' | 'strict'
> = {
    /**
     * Create a new instance.
     */
    new (): CustomEventTarget<TEventMap, TMode>;
    /**
     * prototype object.
     */
    prototype: CustomEventTarget<TEventMap, TMode>;
};

type EventAttributes<
    TEventTarget extends EventTarget<any, any>,
    TEventMap extends Record<string, Event>
> = {
    [P in string & keyof TEventMap as `on${P}`]: EventTarget.CallbackFunction<
        TEventTarget,
        TEventMap[P]
    > | null;
};

type EventData<
    TEventMap extends Record<string, Event>,
    TMode extends 'standard' | 'strict',
    TEventType extends string
> = TMode extends 'strict'
    ? IsValidEventMap<TEventMap> extends true
        ? ExplicitType<TEventType> &
              Omit<TEventMap[TEventType], keyof Event> &
              Partial<Omit<Event, 'type'>>
        : never
    : never;

type EventListener<
    TEventTarget extends EventTarget<any, any>,
    TEvent extends Event
> = CallbackFunction<TEventTarget, TEvent> | CallbackObject<TEvent>;

type ExplicitType<T extends string> = string extends T
    ? never
    : {
          readonly type: T;
      };

type FallbackEvent<TMode extends 'standard' | 'strict'> = TMode extends 'standard'
    ? Event
    : never;

type FallbackEventListener<
    TEventTarget extends EventTarget<any, any>,
    TMode extends 'standard' | 'strict'
> = TMode extends 'standard'
    ? EventListener<TEventTarget, Event> | null | undefined
    : never;

type IsValidEventMap<T> = string extends keyof T ? false : true;

type ErrorHandler = (error: Error) => void;

type WarningHandler = (warning: Warning) => void;