drive/frontend/node_modules/@napi-rs/canvas/index.d.ts

import { ReadableStream } from 'node:stream/web'

// Clear all type of caches in Skia
export function clearAllCache(): void

interface CanvasRenderingContext2D
  extends CanvasCompositing,
  CanvasDrawPath,
  CanvasFillStrokeStyles,
  CanvasFilters,
  CanvasImageData,
  CanvasImageSmoothing,
  CanvasPath,
  CanvasPathDrawingStyles,
  CanvasRect,
  CanvasSettings,
  CanvasShadowStyles,
  CanvasState,
  CanvasText,
  CanvasTextDrawingStyles,
  CanvasTransform,
  CanvasPDFAnnotations { }

interface CanvasState {
  isContextLost(): boolean
  reset(): void
  restore(): void
  save(): void
}
interface CanvasShadowStyles {
  shadowBlur: number
  shadowColor: string
  shadowOffsetX: number
  shadowOffsetY: number
}
interface CanvasRenderingContext2DSettings {
  alpha?: boolean
  colorSpace?: PredefinedColorSpace
  desynchronized?: boolean
  willReadFrequently?: boolean
}
interface CanvasSettings {
  getContextAttributes(): CanvasRenderingContext2DSettings
}

interface CanvasRect {
  clearRect(x: number, y: number, w: number, h: number): void
  fillRect(x: number, y: number, w: number, h: number): void
  strokeRect(x: number, y: number, w: number, h: number): void
}

interface TextMetrics {
  readonly actualBoundingBoxAscent: number
  readonly actualBoundingBoxDescent: number
  readonly actualBoundingBoxLeft: number
  readonly actualBoundingBoxRight: number
  readonly alphabeticBaseline: number
  readonly emHeightAscent: number
  readonly emHeightDescent: number
  readonly fontBoundingBoxAscent: number
  readonly fontBoundingBoxDescent: number
  readonly hangingBaseline: number
  readonly ideographicBaseline: number
  readonly width: number
}

interface CanvasText {
  fillText(text: string, x: number, y: number, maxWidth?: number): void
  measureText(text: string): TextMetrics
  strokeText(text: string, x: number, y: number, maxWidth?: number): void
}

type CanvasLineCap = 'butt' | 'round' | 'square'
type CanvasLineJoin = 'bevel' | 'miter' | 'round'

interface CanvasPathDrawingStyles {
  lineCap: CanvasLineCap
  lineDashOffset: number
  lineJoin: CanvasLineJoin
  lineWidth: number
  miterLimit: number
  getLineDash(): number[]
  setLineDash(segments: number[]): void
}

interface CanvasPath {
  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void
  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void
  bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void
  closePath(): void
  ellipse(
    x: number,
    y: number,
    radiusX: number,
    radiusY: number,
    rotation: number,
    startAngle: number,
    endAngle: number,
    counterclockwise?: boolean,
  ): void
  lineTo(x: number, y: number): void
  moveTo(x: number, y: number): void
  quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void
  rect(x: number, y: number, w: number, h: number): void
  roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void
}

type ImageSmoothingQuality = 'high' | 'low' | 'medium'

interface CanvasImageSmoothing {
  imageSmoothingEnabled: boolean
  imageSmoothingQuality: ImageSmoothingQuality
}

interface CanvasTransform {
  resetTransform(): void
  rotate(angle: number): void
  scale(x: number, y: number): void
  setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void
  setTransform(transform?: DOMMatrix2DInit): void
  transform(a: number, b: number, c: number, d: number, e: number, f: number): void
  translate(x: number, y: number): void
}

interface CanvasPDFAnnotations {
  /**
   * Create a clickable URL link annotation in a PDF document.
   * This is only effective when used with PDF documents.
   * @param left - Left coordinate of the link rectangle
   * @param top - Top coordinate of the link rectangle
   * @param right - Right coordinate of the link rectangle
   * @param bottom - Bottom coordinate of the link rectangle
   * @param url - The URL to link to
   */
  annotateLinkUrl(left: number, top: number, right: number, bottom: number, url: string): void

  /**
   * Create a named destination at a specific point in a PDF document.
   * This destination can be used as a target for internal links.
   * @param x - X coordinate of the destination point
   * @param y - Y coordinate of the destination point
   * @param name - Name identifier for the destination
   */
  annotateNamedDestination(x: number, y: number, name: string): void

  /**
   * Create a link to a named destination within the PDF document.
   * This is only effective when used with PDF documents.
   * @param left - Left coordinate of the link rectangle
   * @param top - Top coordinate of the link rectangle
   * @param right - Right coordinate of the link rectangle
   * @param bottom - Bottom coordinate of the link rectangle
   * @param name - Name of the destination to link to
   */
  annotateLinkToDestination(left: number, top: number, right: number, bottom: number, name: string): void
}

type PredefinedColorSpace = 'display-p3' | 'srgb'

interface ImageDataSettings {
  colorSpace?: PredefinedColorSpace
}
interface CanvasImageData {
  createImageData(sw: number, sh: number, settings?: ImageDataSettings): ImageData
  createImageData(imagedata: ImageData): ImageData
  getImageData(sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings): ImageData
  putImageData(imagedata: ImageData, dx: number, dy: number): void
  putImageData(
    imagedata: ImageData,
    dx: number,
    dy: number,
    dirtyX: number,
    dirtyY: number,
    dirtyWidth: number,
    dirtyHeight: number,
  ): void
}

type CanvasDirection = 'inherit' | 'ltr' | 'rtl'
type CanvasFontKerning = 'auto' | 'none' | 'normal'
type CanvasFontStretch =
  | 'condensed'
  | 'expanded'
  | 'extra-condensed'
  | 'extra-expanded'
  | 'normal'
  | 'semi-condensed'
  | 'semi-expanded'
  | 'ultra-condensed'
  | 'ultra-expanded'
type CanvasFontVariantCaps =
  | 'all-petite-caps'
  | 'all-small-caps'
  | 'normal'
  | 'petite-caps'
  | 'small-caps'
  | 'titling-caps'
  | 'unicase'
type CanvasTextAlign = 'center' | 'end' | 'left' | 'right' | 'start'
type CanvasTextBaseline = 'alphabetic' | 'bottom' | 'hanging' | 'ideographic' | 'middle' | 'top'
type CanvasTextRendering = 'auto' | 'geometricPrecision' | 'optimizeLegibility' | 'optimizeSpeed'

interface CanvasTextDrawingStyles {
  direction: CanvasDirection
  font: string
  fontKerning: CanvasFontKerning
  fontStretch: CanvasFontStretch
  fontVariantCaps: CanvasFontVariantCaps
  letterSpacing: string
  textAlign: CanvasTextAlign
  textBaseline: CanvasTextBaseline
  textRendering: CanvasTextRendering
  wordSpacing: string
  fontVariationSettings: string
  lang: string
}

interface CanvasFilters {
  filter: string
}

interface CanvasFillStrokeStyles {
  fillStyle: string | CanvasGradient | CanvasPattern
  strokeStyle: string | CanvasGradient | CanvasPattern
  createConicGradient(startAngle: number, x: number, y: number): CanvasGradient
  createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient
  createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient
}

type CanvasFillRule = 'evenodd' | 'nonzero'

interface CanvasDrawPath {
  beginPath(): void
  clip(fillRule?: CanvasFillRule): void
  clip(path: Path2D, fillRule?: CanvasFillRule): void
  fill(fillRule?: CanvasFillRule): void
  fill(path: Path2D, fillRule?: CanvasFillRule): void
  isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean
  isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean
  isPointInStroke(x: number, y: number): boolean
  isPointInStroke(path: Path2D, x: number, y: number): boolean
  stroke(): void
  stroke(path: Path2D): void
}

type GlobalCompositeOperation =
  | 'color'
  | 'color-burn'
  | 'color-dodge'
  | 'copy'
  | 'darken'
  | 'destination-atop'
  | 'destination-in'
  | 'destination-out'
  | 'destination-over'
  | 'difference'
  | 'exclusion'
  | 'hard-light'
  | 'hue'
  | 'lighten'
  | 'lighter'
  | 'luminosity'
  | 'multiply'
  | 'overlay'
  | 'saturation'
  | 'screen'
  | 'soft-light'
  | 'source-atop'
  | 'source-in'
  | 'source-out'
  | 'source-over'
  | 'xor'

interface CanvasCompositing {
  globalAlpha: number
  globalCompositeOperation: GlobalCompositeOperation
}

interface DOMPointInit {
  w?: number
  x?: number
  y?: number
  z?: number
}
interface CanvasPattern {
  setTransform(transform?: DOMMatrix2DInit): void
}

interface CanvasGradient {
  addColorStop(offset: number, color: string): void
}

interface DOMRectInit {
  height?: number
  width?: number
  x?: number
  y?: number
}

interface DOMMatrixInit extends DOMMatrix2DInit {
  is2D?: boolean
  m13?: number
  m14?: number
  m23?: number
  m24?: number
  m31?: number
  m32?: number
  m33?: number
  m34?: number
  m43?: number
  m44?: number
}

// ----------- added types

export interface DOMMatrix2DInit {
  a: number
  b: number
  c: number
  d: number
  e: number
  f: number
}

interface DOMMatrixReadOnly {
  readonly a: number
  readonly b: number
  readonly c: number
  readonly d: number
  readonly e: number
  readonly f: number
  readonly is2D: boolean
  readonly isIdentity: boolean
  readonly m11: number
  readonly m12: number
  readonly m13: number
  readonly m14: number
  readonly m21: number
  readonly m22: number
  readonly m23: number
  readonly m24: number
  readonly m31: number
  readonly m32: number
  readonly m33: number
  readonly m34: number
  readonly m41: number
  readonly m42: number
  readonly m43: number
  readonly m44: number
  flipX(): DOMMatrix
  flipY(): DOMMatrix
  inverse(): DOMMatrix
  multiply(other?: DOMMatrixInit): DOMMatrix
  rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix
  rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix
  rotateFromVector(x?: number, y?: number): DOMMatrix
  scale(
    scaleX?: number,
    scaleY?: number,
    scaleZ?: number,
    originX?: number,
    originY?: number,
    originZ?: number,
  ): DOMMatrix
  scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix
  skewX(sx?: number): DOMMatrix
  skewY(sy?: number): DOMMatrix
  toFloat32Array(): Float32Array
  toFloat64Array(): Float64Array
  transformPoint(point?: DOMPointInit): DOMPoint
  translate(tx?: number, ty?: number, tz?: number): DOMMatrix
  toString(): string
}

export interface DOMMatrix extends DOMMatrixReadOnly {
  a: number
  b: number
  c: number
  d: number
  e: number
  f: number
  m11: number
  m12: number
  m13: number
  m14: number
  m21: number
  m22: number
  m23: number
  m24: number
  m31: number
  m32: number
  m33: number
  m34: number
  m41: number
  m42: number
  m43: number
  m44: number
  invertSelf(): DOMMatrix
  multiplySelf(other?: DOMMatrixInit): DOMMatrix
  preMultiplySelf(other?: DOMMatrixInit): DOMMatrix
  rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix
  rotateFromVectorSelf(x?: number, y?: number): DOMMatrix
  rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix
  scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix
  scaleSelf(
    scaleX?: number,
    scaleY?: number,
    scaleZ?: number,
    originX?: number,
    originY?: number,
    originZ?: number,
  ): DOMMatrix
  setMatrixValue(transformList: string): DOMMatrix
  skewXSelf(sx?: number): DOMMatrix
  skewYSelf(sy?: number): DOMMatrix
  translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix
  toJSON(): { [K in OmitNeverOfMatrix]: DOMMatrix[K] }
}

type OmitMatrixMethod = { [K in keyof DOMMatrix]: DOMMatrix[K] extends (...args: any[]) => any ? never : K }

type OmitNeverOfMatrix = OmitMatrixMethod[keyof OmitMatrixMethod]

export const DOMMatrix: {
  prototype: DOMMatrix
  new(init?: string | number[]): DOMMatrix
  fromFloat32Array(array32: Float32Array): DOMMatrix
  fromFloat64Array(array64: Float64Array): DOMMatrix
  fromMatrix(other?: DOMMatrixInit): DOMMatrix
}

interface DOMRectReadOnly {
  readonly bottom: number
  readonly height: number
  readonly left: number
  readonly right: number
  readonly top: number
  readonly width: number
  readonly x: number
  readonly y: number
}

export interface DOMRect extends DOMRectReadOnly {
  height: number
  width: number
  x: number
  y: number
  toJSON(): Omit<this, 'toJSON' | 'fromRect'>
}

export const DOMRect: {
  prototype: DOMRect
  new(x?: number, y?: number, width?: number, height?: number): DOMRect
  fromRect(other?: DOMRectInit): DOMRect
}

interface DOMPointReadOnly {
  readonly w: number
  readonly x: number
  readonly y: number
  readonly z: number
  matrixTransform(matrix?: DOMMatrixInit): DOMPoint
}

export interface DOMPoint extends DOMPointReadOnly {
  w: number
  x: number
  y: number
  z: number
  toJSON(): Omit<DOMPoint, 'matrixTransform' | 'toJSON'>
}

export const DOMPoint: {
  prototype: DOMPoint
  new(x?: number, y?: number, z?: number, w?: number): DOMPoint
  fromPoint(other?: DOMPointInit): DOMPoint
}

export class ImageData {
  /**
   * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
   */
  readonly data: Uint8ClampedArray
  /**
   * Returns the actual dimensions of the data in the ImageData object, in pixels.
   */
  readonly height: number
  /**
   * Returns the actual dimensions of the data in the ImageData object, in pixels.
   */
  readonly width: number

  constructor(sw: number, sh: number, attr?: { colorSpace?: ColorSpace })
  constructor(imageData: ImageData, attr?: { colorSpace?: ColorSpace })
  constructor(data: Uint8ClampedArray | Uint16Array | Float16Array | Float32Array, sw: number, sh?: number)
}

export class Image {
  constructor()
  // attrs only affects SVG
  constructor(width: number, height: number, attrs?: { colorSpace?: ColorSpace })
  width: number
  height: number
  readonly naturalWidth: number
  readonly naturalHeight: number
  readonly complete: boolean
  readonly currentSrc: string | null
  alt: string
  // the src can be a Uint8Array or a string
  // if it's a string, it can be a file path, a data URL, a remote URL, or a SVG string
  src: Uint8Array | string
  onload?(): void
  onerror?(err: Error): void
  decode(): Promise<void>
}

export class Path2D {
  constructor(path?: Path2D | string)

  addPath(path: Path2D, transform?: DOMMatrix2DInit): void
  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void
  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void
  bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void
  closePath(): void
  ellipse(
    x: number,
    y: number,
    radiusX: number,
    radiusY: number,
    rotation: number,
    startAngle: number,
    endAngle: number,
    anticlockwise?: boolean,
  ): void
  lineTo(x: number, y: number): void
  moveTo(x: number, y: number): void
  quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void
  rect(x: number, y: number, w: number, h: number): void
  roundRect(x: number, y: number, w: number, h: number, radii?: number | number[]): void

  // PathKit methods
  op(path: Path2D, operation: PathOp): Path2D
  toSVGString(): string
  getFillType(): FillType
  getFillTypeString(): string
  setFillType(type: FillType): void
  simplify(): Path2D
  asWinding(): Path2D
  stroke(stroke?: StrokeOptions): Path2D
  transform(transform: DOMMatrix2DInit): Path2D
  getBounds(): [left: number, top: number, right: number, bottom: number]
  computeTightBounds(): [left: number, top: number, right: number, bottom: number]
  trim(start: number, end: number, isComplement?: boolean): Path2D
  dash(on: number, off: number, phase: number): Path2D
  round(radius: number): Path2D
  equals(path: Path2D): boolean
}

export interface StrokeOptions {
  width?: number
  miterLimit?: number
  cap?: StrokeCap
  join?: StrokeJoin
}

export interface SKRSContext2D extends CanvasRenderingContext2D {
  canvas: Canvas
  /**
   * @param startAngle The angle at which to begin the gradient, in radians. Angle measurements start vertically above the centre and move around clockwise.
   * @param x The x-axis coordinate of the centre of the gradient.
   * @param y The y-axis coordinate of the centre of the gradient.
   */
  createConicGradient(startAngle: number, x: number, y: number): CanvasGradient
  drawImage(image: Image | Canvas, dx: number, dy: number): void
  drawImage(image: Image | Canvas, dx: number, dy: number, dw: number, dh: number): void
  drawImage(
    image: Image | Canvas,
    sx: number,
    sy: number,
    sw: number,
    sh: number,
    dx: number,
    dy: number,
    dw: number,
    dh: number,
  ): void
  /**
   * Draw another canvas, preserving vector graphics when possible.
   * When the source canvas has recorded operations, this method preserves the
   * SkPicture representation without rasterization, which can be faster than
   * drawImage. Falls back to bitmap rendering if no picture is available.
   */
  drawCanvas(canvas: Canvas, dx: number, dy: number): void
  drawCanvas(canvas: Canvas, dx: number, dy: number, dWidth: number, dHeight: number): void
  drawCanvas(
    canvas: Canvas,
    sx: number,
    sy: number,
    sWidth: number,
    sHeight: number,
    dx: number,
    dy: number,
    dWidth: number,
    dHeight: number,
  ): void
  createPattern(
    image: Image | ImageData | Canvas | SvgCanvas,
    repeat: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat' | null,
  ): CanvasPattern
  getContextAttributes(): { alpha: boolean; desynchronized: boolean }
  getTransform(): DOMMatrix

  letterSpacing: string
  wordSpacing: string
}

export type ColorSpace = 'srgb' | 'display-p3'

export interface ContextAttributes {
  alpha?: boolean
  colorSpace?: ColorSpace
}

export interface SvgCanvas {
  width: number
  height: number
  getContext(contextType: '2d', contextAttributes?: ContextAttributes): SKRSContext2D

  getContent(): Buffer
}

export interface AvifConfig {
  /** 0-100 scale, 100 is lossless */
  quality?: number
  /** 0-100 scale */
  alphaQuality?: number
  /** rav1e preset 1 (slow) 10 (fast but crappy), default is 4 */
  speed?: number
  /** How many threads should be used (0 = match core count) */
  threads?: number
  /** set to '4:2:0' to use chroma subsampling, default '4:4:4' */
  chromaSubsampling?: ChromaSubsampling
}

/** GIF encoding configuration for single-frame encoding */
export interface GifConfig {
  /**
   * Quality for NeuQuant color quantization (1-30, lower = slower but better quality)
   * @default 10
   */
  quality?: number
}

/** Configuration for the GIF encoder (animated GIFs) */
export interface GifEncoderConfig {
  /**
   * Loop count: 0 = infinite loop, positive number = finite loops
   * @default 0 (infinite)
   */
  repeat?: number
  /**
   * Quality for NeuQuant color quantization (1-30, lower = slower but better quality)
   * @default 10
   */
  quality?: number
}

/** Configuration for individual GIF frames */
export interface GifFrameConfig {
  /**
   * Frame delay in milliseconds
   * @default 100
   */
  delay?: number
  /** Disposal method for this frame */
  disposal?: GifDisposal
  /** Transparent color index (0-255), if the frame has transparency */
  transparent?: number
  /** X offset of this frame within the canvas */
  left?: number
  /** Y offset of this frame within the canvas */
  top?: number
}

/** GIF frame disposal method */
export enum GifDisposal {
  /** Keep the frame visible (default) */
  Keep = 0,
  /** Clear the frame area to the background color */
  Background = 1,
  /** Restore to the previous frame */
  Previous = 2,
}

/**
 * GIF Encoder for creating animated GIFs.
 * Implements `Disposable` interface for use with the `using` keyword (ES2024).
 *
 * @example
 * ```typescript
 * // Basic usage
 * const encoder = new GifEncoder(100, 100, { repeat: 0, quality: 10 });
 * encoder.addFrame(rgbaData, 100, 100, { delay: 100 });
 * encoder.addFrame(rgbaData2, 100, 100, { delay: 100 });
 * const buffer = encoder.finish();
 *
 * // With `using` keyword (automatic cleanup)
 * {
 *   using encoder = new GifEncoder(100, 100);
 *   encoder.addFrame(frame1, 100, 100, { delay: 100 });
 *   const buffer = encoder.finish();
 * } // encoder automatically disposed
 * ```
 */
export class GifEncoder implements Disposable {
  /**
   * Create a new GIF encoder with the specified dimensions
   * @param width - Width of the GIF canvas in pixels
   * @param height - Height of the GIF canvas in pixels
   * @param config - Optional encoder configuration
   */
  constructor(width: number, height: number, config?: GifEncoderConfig)

  /** Width of the GIF canvas */
  readonly width: number
  /** Height of the GIF canvas */
  readonly height: number
  /** Number of frames added so far */
  readonly frameCount: number

  /**
   * Add a frame from RGBA pixel data
   * @param data - RGBA pixel data (must be width * height * 4 bytes)
   * @param width - Width of the frame in pixels
   * @param height - Height of the frame in pixels
   * @param config - Optional frame configuration
   */
  addFrame(data: Uint8Array, width: number, height: number, config?: GifFrameConfig): void

  /**
   * Finish encoding and return the GIF data.
   * Clears all accumulated frames after encoding.
   * @throws Error if no frames have been added
   */
  finish(): Buffer

  /**
   * Dispose of the encoder, clearing all accumulated frames without encoding.
   * Called automatically when using the `using` keyword.
   */
  dispose(): void

  /**
   * Symbol.dispose implementation for ES2024 Explicit Resource Management.
   * Allows using `using encoder = new GifEncoder(...)` syntax.
   */
  [Symbol.dispose](): void
}
/**
 * https://en.wikipedia.org/wiki/Chroma_subsampling#Types_of_sampling_and_subsampling
 * https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_concepts
 */
export enum ChromaSubsampling {
  /**
   * Each of the three Y'CbCr components has the same sample rate, thus there is no chroma subsampling. This scheme is sometimes used in high-end film scanners and cinematic post-production.
   * Note that "4:4:4" may instead be wrongly referring to R'G'B' color space, which implicitly also does not have any chroma subsampling (except in JPEG R'G'B' can be subsampled).
   * Formats such as HDCAM SR can record 4:4:4 R'G'B' over dual-link HD-SDI.
   */
  Yuv444 = 0,
  /**
   * The two chroma components are sampled at half the horizontal sample rate of luma: the horizontal chroma resolution is halved. This reduces the bandwidth of an uncompressed video signal by one-third.
   * Many high-end digital video formats and interfaces use this scheme:
   * - [AVC-Intra 100](https://en.wikipedia.org/wiki/AVC-Intra)
   * - [Digital Betacam](https://en.wikipedia.org/wiki/Betacam#Digital_Betacam)
   * - [Betacam SX](https://en.wikipedia.org/wiki/Betacam#Betacam_SX)
   * - [DVCPRO50](https://en.wikipedia.org/wiki/DV#DVCPRO) and [DVCPRO HD](https://en.wikipedia.org/wiki/DV#DVCPRO_HD)
   * - [Digital-S](https://en.wikipedia.org/wiki/Digital-S)
   * - [CCIR 601](https://en.wikipedia.org/wiki/Rec._601) / [Serial Digital Interface](https://en.wikipedia.org/wiki/Serial_digital_interface) / [D1](https://en.wikipedia.org/wiki/D-1_(Sony))
   * - [ProRes (HQ, 422, LT, and Proxy)](https://en.wikipedia.org/wiki/Apple_ProRes)
   * - [XDCAM HD422](https://en.wikipedia.org/wiki/XDCAM)
   * - [Canon MXF HD422](https://en.wikipedia.org/wiki/Canon_XF-300)
   */
  Yuv422 = 1,
  /**
   * n 4:2:0, the horizontal sampling is doubled compared to 4:1:1,
   * but as the **Cb** and **Cr** channels are only sampled on each alternate line in this scheme, the vertical resolution is halved.
   * The data rate is thus the same.
   * This fits reasonably well with the PAL color encoding system, since this has only half the vertical chrominance resolution of [NTSC](https://en.wikipedia.org/wiki/NTSC).
   * It would also fit extremely well with the [SECAM](https://en.wikipedia.org/wiki/SECAM) color encoding system,
   * since like that format, 4:2:0 only stores and transmits one color channel per line (the other channel being recovered from the previous line).
   * However, little equipment has actually been produced that outputs a SECAM analogue video signal.
   * In general, SECAM territories either have to use a PAL-capable display or a [transcoder](https://en.wikipedia.org/wiki/Transcoding) to convert the PAL signal to SECAM for display.
   */
  Yuv420 = 2,
  /**
   * What if the chroma subsampling model is 4:0:0?
   * That says to use every pixel of luma data, but that each row has 0 chroma samples applied to it. The resulting image, then, is comprised solely of the luminance data—a greyscale image.
   */
  Yuv400 = 3,
}

export interface ConvertToBlobOptions {
  mime?: string
  quality?: number
}

export class Canvas {
  constructor(width: number, height: number, flag?: SvgExportFlag)

  width: number
  height: number
  getContext(contextType: '2d', contextAttributes?: ContextAttributes): SKRSContext2D
  encodeSync(format: 'webp' | 'jpeg', quality?: number): Buffer
  encodeSync(format: 'png'): Buffer
  encodeSync(format: 'avif', cfg?: AvifConfig): Buffer
  encodeSync(format: 'gif', quality?: number): Buffer
  encode(format: 'webp' | 'jpeg', quality?: number): Promise<Buffer>
  encode(format: 'png'): Promise<Buffer>
  encode(format: 'avif', cfg?: AvifConfig): Promise<Buffer>
  encode(format: 'gif', quality?: number): Promise<Buffer>
  encodeStream(format: 'webp' | 'jpeg', quality?: number): ReadableStream<Buffer>
  encodeStream(format: 'png'): ReadableStream<Buffer>
  toBuffer(mime: 'image/png'): Buffer
  toBuffer(mime: 'image/jpeg' | 'image/webp', quality?: number): Buffer
  toBuffer(mime: 'image/avif', cfg?: AvifConfig): Buffer
  toBuffer(mime: 'image/gif', quality?: number): Buffer
  // raw pixels
  data(): Buffer
  toDataURL(mime?: 'image/png'): string
  toDataURL(mime: 'image/jpeg' | 'image/webp', quality?: number): string
  toDataURL(mime: 'image/gif', quality?: number): string
  toDataURL(mime?: 'image/jpeg' | 'image/webp' | 'image/png' | 'image/gif', quality?: number): string
  toDataURL(mime?: 'image/avif', cfg?: AvifConfig): string

  toDataURLAsync(mime?: 'image/png'): Promise<string>
  toDataURLAsync(mime: 'image/jpeg' | 'image/webp', quality?: number): Promise<string>
  toDataURLAsync(mime: 'image/gif', quality?: number): Promise<string>
  toDataURLAsync(mime?: 'image/jpeg' | 'image/webp' | 'image/png' | 'image/gif', quality?: number): Promise<string>
  toDataURLAsync(mime?: 'image/avif', cfg?: AvifConfig): Promise<string>

  toBlob(callback: (blob: Blob | null) => void, mime?: string, quality?: number): void
  convertToBlob(options?: ConvertToBlobOptions): Promise<Blob>
}

export function createCanvas(width: number, height: number): Canvas

export function createCanvas(width: number, height: number, svgExportFlag: SvgExportFlag): SvgCanvas

export declare class FontKey {
  // make it a unique type
  private readonly key: symbol
  readonly typefaceId: number
}

export interface FontVariationAxis {
  /** OpenType tag as a 32-bit integer (e.g., 0x77676874 for 'wght') */
  tag: number
  /** Current value for this axis */
  value: number
  /** Minimum value for this axis */
  min: number
  /** Maximum value for this axis */
  max: number
  /** Default value for this axis */
  def: number
  /** Whether this axis should be hidden from UI */
  hidden: boolean
}

interface IGlobalFonts {
  readonly families: { family: string; styles: { weight: number; width: string; style: string }[] }[]
  // return FontKey if succeeded, null if failed
  register(font: Buffer, nameAlias?: string): FontKey | null
  // absolute path - returns FontKey if succeeded, null if failed
  registerFromPath(path: string, nameAlias?: string): FontKey | null
  has(name: string): boolean
  loadFontsFromDir(path: string): number
  /**
   * Set an alias for a font family.
   * @param fontName The original font family name
   * @param alias The alias name to set
   * @returns true if the alias was set successfully, false if the font family doesn't exist
   */
  setAlias(fontName: string, alias: string): boolean
  remove(key: FontKey): boolean
  /**
   * Remove multiple fonts by their keys in a single operation.
   * More efficient than calling remove() multiple times as it triggers only one rebuild.
   * @param fontKeys Array of FontKey objects to remove
   * @returns Number of fonts successfully removed
   */
  removeBatch(fontKeys: FontKey[]): number
  /**
   * Remove ALL registered fonts.
   * @returns Number of fonts removed
   */
  removeAll(): number
  /**
   * Get variation axes for a specific font instance
   * @param familyName The font family name
   * @param weight Font weight (100-900)
   * @param width Font width/stretch value
   * @param slant Font slant (0 = upright, 1 = italic, 2 = oblique)
   * @returns Array of variation axes or empty array if not a variable font
   */
  getVariationAxes(familyName: string, weight: number, width: number, slant: number): FontVariationAxis[]
  /**
   * Check if a font has variable font capabilities
   * @param familyName The font family name
   * @param weight Font weight (100-900)
   * @param width Font width/stretch value
   * @param slant Font slant (0 = upright, 1 = italic, 2 = oblique)
   * @returns true if the font is a variable font
   */
  hasVariations(familyName: string, weight: number, width: number, slant: number): boolean
}

export const GlobalFonts: IGlobalFonts

export enum PathOp {
  Difference = 0, // subtract the op path from the first path
  Intersect = 1, // intersect the two paths
  Union = 2, // union (inclusive-or) the two paths
  Xor = 3, // exclusive-or the two paths
  ReverseDifference = 4, // subtract the first path from the op path
}

export enum FillType {
  Winding = 0,
  EvenOdd = 1,
  InverseWinding = 2,
  InverseEvenOdd = 3,
}

export enum StrokeJoin {
  Miter = 0,
  Round = 1,
  Bevel = 2,
}

export enum StrokeCap {
  Butt = 0,
  Round = 1,
  Square = 2,
}

export enum SvgExportFlag {
  ConvertTextToPaths = 0x01,
  NoPrettyXML = 0x02,
  RelativePathEncoding = 0x04,
}

export function convertSVGTextToPath(svg: Buffer | string): Buffer

export interface LoadImageOptions {
  alt?: string
  maxRedirects?: number
  requestOptions?: import('http').RequestOptions
}

export function loadImage(
  source: string | URL | Buffer | ArrayBufferLike | Uint8Array | Image | import('stream').Readable,
  options?: LoadImageOptions,
): Promise<Image>

export interface PDFMetadata {
  /// The document's title
  title?: string
  /// The name of the person who created the document
  author?: string
  /// The subject of the document
  subject?: string
  /// Keywords associated with the document
  keywords?: string
  /// The product that created the original document
  creator?: string
  /// The product that is converting this document to PDF (defaults to "Skia/PDF")
  producer?: string
  /// The DPI for rasterization (default: 72.0)
  rasterDPI?: number
  /// Encoding quality: 0-100 for lossy JPEG, 101 for lossless (default: 101)
  encodingQuality?: number
  /// Whether to conform to PDF/A-2b standard (default: false)
  pdfa?: boolean
  /// Compression level: -1 (default), 0 (none), 1 (low/fast), 6 (average), 9 (high/slow)
  compressionLevel?: number
}

export interface Rect {
  left: number
  top: number
  right: number
  bottom: number
}

export declare class PDFDocument {
  constructor(metadata?: PDFMetadata | undefined | null)
  beginPage(width: number, height: number, rect?: Rect | undefined | null): CanvasRenderingContext2D
  endPage(): void
  close(): Buffer
}

export interface LottieAnimationOptions {
  /** Base path for resolving external resources (images, fonts) */
  resourcePath?: string
}

export interface LottieRenderRect {
  x: number
  y: number
  width: number
  height: number
}

/**
 * Lottie animation class for loading and rendering Lottie JSON files.
 *
 * @example
 * ```typescript
 * import { LottieAnimation, createCanvas } from '@napi-rs/canvas'
 *
 * const animation = LottieAnimation.loadFromFile('./animation.json')
 * const canvas = createCanvas(animation.width, animation.height)
 * const ctx = canvas.getContext('2d')
 *
 * // Render frame 0
 * animation.seekFrame(0)
 * animation.render(ctx)
 *
 * // Save to PNG
 * const buffer = canvas.toBuffer('image/png')
 * ```
 */
export declare class LottieAnimation {
  /**
   * Load animation from JSON string or Buffer
   * @param data - JSON string or Buffer containing Lottie animation data
   * @param options - Optional configuration
   */
  static loadFromData(data: string | Buffer, options?: LottieAnimationOptions): LottieAnimation

  /**
   * Load animation from file path
   * External assets are resolved relative to the file's directory
   * @param path - Path to the Lottie JSON file
   */
  static loadFromFile(path: string): LottieAnimation

  /** Animation duration in seconds */
  readonly duration: number

  /** Frame rate (frames per second) */
  readonly fps: number

  /** Total frame count */
  readonly frames: number

  /** Animation width in pixels */
  readonly width: number

  /** Animation height in pixels */
  readonly height: number

  /** Lottie format version string */
  readonly version: string

  /** Animation in-point (start frame) */
  readonly inPoint: number

  /** Animation out-point (end frame) */
  readonly outPoint: number

  /**
   * Seek to normalized position
   * @param t - Position between 0.0 (start) and 1.0 (end)
   */
  seek(t: number): void

  /**
   * Seek to specific frame index
   * @param frame - Frame index (0 = first frame)
   */
  seekFrame(frame: number): void

  /**
   * Seek to specific time in seconds
   * @param seconds - Time in seconds from start
   */
  seekTime(seconds: number): void

  /**
   * Render current frame to canvas context
   * @param ctx - Canvas 2D rendering context
   * @param dst - Optional destination rectangle for scaling/positioning
   */
  render(ctx: CanvasRenderingContext2D, dst?: LottieRenderRect): void
}