/* eslint-disable */
// The contents of this file below the line are copied from
// @types/dom-webcodecs, which is inlined here into Element Call so that we can
// apply the patch https://github.com/DefinitelyTyped/DefinitelyTyped/pull/72625
// which is needed for TypeScript 5.8 compatibility. Once that PR is merged and
// released, we can remove this file and return to depending on
// @types/dom-webcodecs.
// -----------------------------------------------------------------------------

// Versioning:
// Until the WebCodecs spec is finalized, the major version number is 0. I have chosen to use minor
// version 1 to denote the API as defined by the IDL files from the Chromium repo at
// https://chromium.googlesource.com/chromium/src/+/main/third_party/blink/renderer/modules/webcodecs.
// Please use a version number above 0.1 if using the spec at https://w3c.github.io/webcodecs/ as
// the source.

// The declarations in webcodecs.generated.d.ts have been generated using the code in
// https://github.com/yume-chan/webcodecs-lib-generator. See
// https://github.com/yume-chan/webcodecs-lib-generator/blob/main/README.md for more detail.

// The following declarations are copied from
// https://github.com/microsoft/TypeScript-DOM-lib-generator/blob/a75338e1ea8a958bf08a5745141d2ab8f14ba2ca/baselines/dom.generated.d.ts
// and modified to expand the types to include VideoFrame.

/** Shim for OffscreenCanvas, which was removed in TS 4.4 */
interface OffscreenCanvas extends EventTarget {}

/**
 * Replaces CanvasImageSource; only applies if WebCodecs is available.
 */
type CanvasImageSourceWebCodecs =
  | HTMLOrSVGImageElement
  | HTMLVideoElement
  | HTMLCanvasElement
  | ImageBitmap
  | OffscreenCanvas
  | VideoFrame;

interface CanvasRenderingContext2D {
  drawImage(image: CanvasImageSourceWebCodecs, dx: number, dy: number): void;
  drawImage(
    image: CanvasImageSourceWebCodecs,
    dx: number,
    dy: number,
    dw: number,
    dh: number,
  ): void;
  drawImage(
    image: CanvasImageSourceWebCodecs,
    sx: number,
    sy: number,
    sw: number,
    sh: number,
    dx: number,
    dy: number,
    dw: number,
    dh: number,
  ): void;
  createPattern(
    image: CanvasImageSourceWebCodecs,
    repetition: string | null,
  ): CanvasPattern | null;
}

interface OffscreenCanvasRenderingContext2D {
  drawImage(image: CanvasImageSourceWebCodecs, dx: number, dy: number): void;
  drawImage(
    image: CanvasImageSourceWebCodecs,
    dx: number,
    dy: number,
    dw: number,
    dh: number,
  ): void;
  drawImage(
    image: CanvasImageSourceWebCodecs,
    sx: number,
    sy: number,
    sw: number,
    sh: number,
    dx: number,
    dy: number,
    dw: number,
    dh: number,
  ): void;
  createPattern(
    image: CanvasImageSourceWebCodecs,
    repetition: string | null,
  ): CanvasPattern | null;
}

/**
 * Replaces ImageBitmapSource; only applies if WebCodecs is available.
 */
type ImageBitmapSourceWebCodecs = CanvasImageSourceWebCodecs | Blob | ImageData;

declare function createImageBitmap(
  image: ImageBitmapSourceWebCodecs,
  options?: ImageBitmapOptions,
): Promise<ImageBitmap>;
declare function createImageBitmap(
  image: ImageBitmapSourceWebCodecs,
  sx: number,
  sy: number,
  sw: number,
  sh: number,
  options?: ImageBitmapOptions,
): Promise<ImageBitmap>;

/**
 * Replaces TexImageSource; only applies if WebCodecs is available.
 */
type TexImageSourceWebCodecs =
  | ImageBitmap
  | ImageData
  | HTMLImageElement
  | HTMLCanvasElement
  | HTMLVideoElement
  | OffscreenCanvas
  | VideoFrame;

interface WebGLRenderingContextOverloads {
  texImage2D(
    target: GLenum,
    level: GLint,
    internalformat: GLint,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
  texSubImage2D(
    target: GLenum,
    level: GLint,
    xoffset: GLint,
    yoffset: GLint,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
}

interface WebGL2RenderingContextBase {
  texImage3D(
    target: GLenum,
    level: GLint,
    internalformat: GLint,
    width: GLsizei,
    height: GLsizei,
    depth: GLsizei,
    border: GLint,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
  texSubImage3D(
    target: GLenum,
    level: GLint,
    xoffset: GLint,
    yoffset: GLint,
    zoffset: GLint,
    width: GLsizei,
    height: GLsizei,
    depth: GLsizei,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
}

interface WebGL2RenderingContextOverloads {
  texImage2D(
    target: GLenum,
    level: GLint,
    internalformat: GLint,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
  texImage2D(
    target: GLenum,
    level: GLint,
    internalformat: GLint,
    width: GLsizei,
    height: GLsizei,
    border: GLint,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
  texSubImage2D(
    target: GLenum,
    level: GLint,
    xoffset: GLint,
    yoffset: GLint,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
  texSubImage2D(
    target: GLenum,
    level: GLint,
    xoffset: GLint,
    yoffset: GLint,
    width: GLsizei,
    height: GLsizei,
    format: GLenum,
    type: GLenum,
    source: TexImageSourceWebCodecs,
  ): void;
}

/////////////////////////////
/// webcodecs APIs
/////////////////////////////

interface AudioDataCopyToOptions {
  format?: AudioSampleFormat | undefined;
  frameCount?: number | undefined;
  frameOffset?: number | undefined;
  planeIndex: number;
}

interface AudioDataInit {
  data: AllowSharedBufferSource;
  format: AudioSampleFormat;
  numberOfChannels: number;
  numberOfFrames: number;
  sampleRate: number;
  timestamp: number;
}

interface AudioDecoderConfig {
  codec: string;
  description?: AllowSharedBufferSource | undefined;
  numberOfChannels: number;
  sampleRate: number;
}

interface AudioDecoderInit {
  error: WebCodecsErrorCallback;
  output: AudioDataOutputCallback;
}

interface AudioDecoderSupport {
  config?: AudioDecoderConfig;
  supported?: boolean;
}

interface AudioEncoderConfig {
  bitrate?: number | undefined;
  codec: string;
  numberOfChannels: number;
  sampleRate: number;
}

interface AudioEncoderInit {
  error: WebCodecsErrorCallback;
  output: EncodedAudioChunkOutputCallback;
}

interface AudioEncoderSupport {
  config?: AudioEncoderConfig;
  supported?: boolean;
}

interface AvcEncoderConfig {
  format?: AvcBitstreamFormat | undefined;
}

interface EncodedAudioChunkInit {
  data: AllowSharedBufferSource;
  duration?: number | undefined;
  timestamp: number;
  type: EncodedAudioChunkType;
}

interface EncodedAudioChunkMetadata {
  decoderConfig?: AudioDecoderConfig | undefined;
}

interface EncodedVideoChunkInit {
  data: AllowSharedBufferSource;
  duration?: number | undefined;
  timestamp: number;
  type: EncodedVideoChunkType;
}

interface EncodedVideoChunkMetadata {
  decoderConfig?: VideoDecoderConfig | undefined;
  temporalLayerId?: number | undefined;
}

interface ImageDecodeOptions {
  completeFramesOnly?: boolean | undefined;
  frameIndex?: number | undefined;
}

interface ImageDecodeResult {
  complete: boolean;
  image: VideoFrame;
}

interface ImageDecoderInit {
  colorSpaceConversion?: ColorSpaceConversion | undefined;
  data: ImageBufferSource;
  desiredHeight?: number | undefined;
  desiredWidth?: number | undefined;
  preferAnimation?: boolean | undefined;
  premultiplyAlpha?: PremultiplyAlpha | undefined;
  type: string;
}

interface PlaneLayout {
  offset: number;
  stride: number;
}

interface VideoColorSpaceInit {
  fullRange?: boolean | null | undefined;
  matrix?: VideoMatrixCoefficients | null | undefined;
  primaries?: VideoColorPrimaries | null | undefined;
  transfer?: VideoTransferCharacteristics | null | undefined;
}

interface VideoDecoderConfig {
  codec: string;
  codedHeight?: number | undefined;
  codedWidth?: number | undefined;
  colorSpace?: VideoColorSpaceInit | undefined;
  description?: AllowSharedBufferSource | undefined;
  displayAspectHeight?: number | undefined;
  displayAspectWidth?: number | undefined;
  hardwareAcceleration?: HardwarePreference | undefined;
  optimizeForLatency?: boolean | undefined;
}

interface VideoDecoderInit {
  error: WebCodecsErrorCallback;
  output: VideoFrameOutputCallback;
}

interface VideoDecoderSupport {
  config?: VideoDecoderConfig;
  supported?: boolean;
}

interface VideoEncoderConfig {
  alpha?: AlphaOption | undefined;
  avc?: AvcEncoderConfig | undefined;
  bitrate?: number | undefined;
  bitrateMode?: VideoEncoderBitrateMode | undefined;
  codec: string;
  displayHeight?: number | undefined;
  displayWidth?: number | undefined;
  framerate?: number | undefined;
  hardwareAcceleration?: HardwarePreference | undefined;
  height: number;
  latencyMode?: LatencyMode | undefined;
  scalabilityMode?: string | undefined;
  width: number;
}

interface VideoEncoderEncodeOptions {
  keyFrame?: boolean;
}

interface VideoEncoderInit {
  error: WebCodecsErrorCallback;
  output: EncodedVideoChunkOutputCallback;
}

interface VideoEncoderSupport {
  config?: VideoEncoderConfig;
  supported?: boolean;
}

interface VideoFrameBufferInit {
  codedHeight: number;
  codedWidth: number;
  colorSpace?: VideoColorSpaceInit | undefined;
  displayHeight?: number | undefined;
  displayWidth?: number | undefined;
  duration?: number | undefined;
  format: VideoPixelFormat;
  layout?: PlaneLayout[] | undefined;
  timestamp: number;
  visibleRect?: DOMRectInit | undefined;
}

interface VideoFrameCopyToOptions {
  layout?: PlaneLayout[] | undefined;
  rect?: DOMRectInit | undefined;
}

interface VideoFrameInit {
  alpha?: AlphaOption | undefined;
  displayHeight?: number | undefined;
  displayWidth?: number | undefined;
  duration?: number | undefined;
  timestamp?: number | undefined;
  visibleRect?: DOMRectInit | undefined;
}

interface AudioData {
  readonly duration: number;
  readonly format: AudioSampleFormat | null;
  readonly numberOfChannels: number;
  readonly numberOfFrames: number;
  readonly sampleRate: number;
  readonly timestamp: number;
  allocationSize(options: AudioDataCopyToOptions): number;
  clone(): AudioData;
  close(): void;
  copyTo(
    destination: AllowSharedBufferSource,
    options: AudioDataCopyToOptions,
  ): void;
}

declare var AudioData: {
  prototype: AudioData;
  new (init: AudioDataInit): AudioData;
};

interface AudioDecoderEventMap {
  dequeue: Event;
}

/** Available only in secure contexts. */
interface AudioDecoder {
  readonly decodeQueueSize: number;
  readonly state: CodecState;
  ondequeue: ((this: AudioDecoder, ev: Event) => any) | null;
  close(): void;
  configure(config: AudioDecoderConfig): void;
  decode(chunk: EncodedAudioChunk): void;
  flush(): Promise<void>;
  reset(): void;
  addEventListener<K extends keyof AudioDecoderEventMap>(
    type: K,
    listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any,
    options?: boolean | AddEventListenerOptions,
  ): void;
  addEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | AddEventListenerOptions,
  ): void;
  removeEventListener<K extends keyof AudioDecoderEventMap>(
    type: K,
    listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any,
    options?: boolean | EventListenerOptions,
  ): void;
  removeEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | EventListenerOptions,
  ): void;
}

declare var AudioDecoder: {
  prototype: AudioDecoder;
  new (init: AudioDecoderInit): AudioDecoder;
  isConfigSupported(config: AudioDecoderConfig): Promise<AudioDecoderSupport>;
};

interface AudioEncoderEventMap {
  dequeue: Event;
}

/** Available only in secure contexts. */
interface AudioEncoder {
  readonly encodeQueueSize: number;
  readonly state: CodecState;
  ondequeue: ((this: AudioEncoder, ev: Event) => any) | null;
  close(): void;
  configure(config: AudioEncoderConfig): void;
  encode(data: AudioData): void;
  flush(): Promise<void>;
  reset(): void;
  addEventListener<K extends keyof AudioEncoderEventMap>(
    type: K,
    listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any,
    options?: boolean | AddEventListenerOptions,
  ): void;
  addEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | AddEventListenerOptions,
  ): void;
  removeEventListener<K extends keyof AudioEncoderEventMap>(
    type: K,
    listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any,
    options?: boolean | EventListenerOptions,
  ): void;
  removeEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | EventListenerOptions,
  ): void;
}

declare var AudioEncoder: {
  prototype: AudioEncoder;
  new (init: AudioEncoderInit): AudioEncoder;
  isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
};

interface EncodedAudioChunk {
  readonly byteLength: number;
  readonly duration: number | null;
  readonly timestamp: number;
  readonly type: EncodedAudioChunkType;
  copyTo(destination: AllowSharedBufferSource): void;
}

declare var EncodedAudioChunk: {
  prototype: EncodedAudioChunk;
  new (init: EncodedAudioChunkInit): EncodedAudioChunk;
};

interface EncodedVideoChunk {
  readonly byteLength: number;
  readonly duration: number | null;
  readonly timestamp: number;
  readonly type: EncodedVideoChunkType;
  copyTo(destination: AllowSharedBufferSource): void;
}

declare var EncodedVideoChunk: {
  prototype: EncodedVideoChunk;
  new (init: EncodedVideoChunkInit): EncodedVideoChunk;
};

/** Available only in secure contexts. */
interface ImageDecoder {
  readonly complete: boolean;
  readonly completed: Promise<void>;
  readonly tracks: ImageTrackList;
  readonly type: string;
  close(): void;
  decode(options?: ImageDecodeOptions): Promise<ImageDecodeResult>;
  reset(): void;
}

// declare var ImageDecoder: {
//     prototype: ImageDecoder;
//     new(init: ImageDecoderInit): ImageDecoder;
//     isTypeSupported(type: string): Promise<boolean>;
// };

// interface ImageTrack {
//     readonly animated: boolean;
//     readonly frameCount: number;
//     readonly repetitionCount: number;
//     selected: boolean;
// }

// declare var ImageTrack: {
//     prototype: ImageTrack;
//     new(): ImageTrack;
// };

// interface ImageTrackList {
//     readonly length: number;
//     readonly ready: Promise<void>;
//     readonly selectedIndex: number;
//     readonly selectedTrack: ImageTrack | null;
//     [index: number]: ImageTrack;
// }

// declare var ImageTrackList: {
//     prototype: ImageTrackList;
//     new(): ImageTrackList;
// };

interface VideoColorSpace {
  readonly fullRange: boolean | null;
  readonly matrix: VideoMatrixCoefficients | null;
  readonly primaries: VideoColorPrimaries | null;
  readonly transfer: VideoTransferCharacteristics | null;
  toJSON(): VideoColorSpaceInit;
}

declare var VideoColorSpace: {
  prototype: VideoColorSpace;
  new (init?: VideoColorSpaceInit): VideoColorSpace;
};

interface VideoDecoderEventMap {
  dequeue: Event;
}

/** Available only in secure contexts. */
interface VideoDecoder {
  readonly decodeQueueSize: number;
  readonly state: CodecState;
  ondequeue: ((this: VideoDecoder, ev: Event) => any) | null;
  close(): void;
  configure(config: VideoDecoderConfig): void;
  decode(chunk: EncodedVideoChunk): void;
  flush(): Promise<void>;
  reset(): void;
  addEventListener<K extends keyof VideoDecoderEventMap>(
    type: K,
    listener: (this: VideoDecoder, ev: VideoDecoderEventMap[K]) => any,
    options?: boolean | AddEventListenerOptions,
  ): void;
  addEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | AddEventListenerOptions,
  ): void;
  removeEventListener<K extends keyof VideoDecoderEventMap>(
    type: K,
    listener: (this: VideoDecoder, ev: VideoDecoderEventMap[K]) => any,
    options?: boolean | EventListenerOptions,
  ): void;
  removeEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | EventListenerOptions,
  ): void;
}

declare var VideoDecoder: {
  prototype: VideoDecoder;
  new (init: VideoDecoderInit): VideoDecoder;
  isConfigSupported(config: VideoDecoderConfig): Promise<VideoDecoderSupport>;
};

interface VideoEncoderEventMap {
  dequeue: Event;
}

/** Available only in secure contexts. */
interface VideoEncoder {
  readonly encodeQueueSize: number;
  readonly state: CodecState;
  close(): void;
  ondequeue: ((this: VideoEncoder, ev: Event) => any) | null;
  configure(config: VideoEncoderConfig): void;
  encode(frame: VideoFrame, options?: VideoEncoderEncodeOptions): void;
  flush(): Promise<void>;
  reset(): void;
  addEventListener<K extends keyof VideoEncoderEventMap>(
    type: K,
    listener: (this: VideoEncoder, ev: VideoEncoderEventMap[K]) => any,
    options?: boolean | AddEventListenerOptions,
  ): void;
  addEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | AddEventListenerOptions,
  ): void;
  removeEventListener<K extends keyof VideoEncoderEventMap>(
    type: K,
    listener: (this: VideoEncoder, ev: VideoEncoderEventMap[K]) => any,
    options?: boolean | EventListenerOptions,
  ): void;
  removeEventListener(
    type: string,
    listener: EventListenerOrEventListenerObject,
    options?: boolean | EventListenerOptions,
  ): void;
}

declare var VideoEncoder: {
  prototype: VideoEncoder;
  new (init: VideoEncoderInit): VideoEncoder;
  isConfigSupported(config: VideoEncoderConfig): Promise<VideoEncoderSupport>;
};

interface VideoFrame {
  readonly codedHeight: number;
  readonly codedRect: DOMRectReadOnly | null;
  readonly codedWidth: number;
  readonly colorSpace: VideoColorSpace;
  readonly displayHeight: number;
  readonly displayWidth: number;
  readonly duration: number | null;
  readonly format: VideoPixelFormat | null;
  readonly timestamp: number;
  readonly visibleRect: DOMRectReadOnly | null;
  allocationSize(options?: VideoFrameCopyToOptions): number;
  clone(): VideoFrame;
  close(): void;
  copyTo(
    destination: AllowSharedBufferSource,
    options?: VideoFrameCopyToOptions,
  ): Promise<PlaneLayout[]>;
}

declare var VideoFrame: {
  prototype: VideoFrame;
  new (source: CanvasImageSource, init?: VideoFrameInit): VideoFrame;
  new (data: AllowSharedBufferSource, init: VideoFrameBufferInit): VideoFrame;
};

interface AudioDataOutputCallback {
  (output: AudioData): void;
}

interface EncodedAudioChunkOutputCallback {
  (output: EncodedAudioChunk, metadata: EncodedAudioChunkMetadata): void;
}

interface EncodedVideoChunkOutputCallback {
  (chunk: EncodedVideoChunk, metadata: EncodedVideoChunkMetadata): void;
}

interface VideoFrameOutputCallback {
  (output: VideoFrame): void;
}

interface WebCodecsErrorCallback {
  (error: DOMException): void;
}

// type AllowSharedBufferSource = ArrayBuffer | ArrayBufferView;
// type BitrateMode = "constant" | "variable";
// type ImageBufferSource = ArrayBuffer | ArrayBufferView | ReadableStream;
// type AlphaOption = "discard" | "keep";
// type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar";
// type AvcBitstreamFormat = "annexb" | "avc";
// type CodecState = "closed" | "configured" | "unconfigured";
// type EncodedAudioChunkType = "delta" | "key";
// type EncodedVideoChunkType = "delta" | "key";
type HardwarePreference =
  | "no-preference"
  | "prefer-hardware"
  | "prefer-software";
// type LatencyMode = "quality" | "realtime";
// type VideoColorPrimaries = "bt470bg" | "bt709" | "smpte170m";
// type VideoMatrixCoefficients = "bt470bg" | "bt709" | "rgb" | "smpte170m";
// type VideoPixelFormat = "BGRA" | "BGRX" | "I420" | "I420A" | "I422" | "I444" | "NV12" | "RGBA" | "RGBX";
// type VideoTransferCharacteristics = "bt709" | "iec61966-2-1" | "smpte170m";