/**
 * node-liblzma - Node.js bindings for liblzma
 * TypeScript definitions
 */

import { Transform, TransformOptions } from 'node:stream';
import type {
  CompressionCallback,
  LZMAOptions,
  NativeLZMA,
  NativeLZMACallback,
  ProgressInfo,
  StreamOptions,
  XZFileIndex,
} from './lib/types.js';

export type {
  CompressionCallback,
  LZMAOptions,
  NativeLZMA,
  NativeLZMACallback,
  ProgressInfo,
  StreamOptions,
  XZFileIndex,
};

export declare abstract class XzStream extends Transform {
  constructor(streamMode: number, opts?: LZMAOptions, options?: TransformOptions);

  /** Total bytes read from input so far */
  readonly bytesRead: number;

  /** Total bytes written to output so far */
  readonly bytesWritten: number;

  /** Flush the stream with specified flush type */
  flush(callback?: () => void): void;
  flush(kind: number, callback?: () => void): void;

  /** Close the stream */
  close(callback?: () => void): void;

  _transform(chunk: Buffer | null, encoding: string, callback: (error?: Error) => void): void;
  _flush(callback: () => void): void;
  protected _processChunk(chunk: Buffer | null, flushFlag: number, callback?: (error?: Error) => void): Buffer | undefined;

  /**
   * Listen for progress events
   * @event progress Emitted when data is written to output
   */
  on(event: 'progress', listener: (info: ProgressInfo) => void): this;
  on(event: string | symbol, listener: (...args: unknown[]) => void): this;
}

export declare class Xz extends XzStream {
  constructor(lzmaOptions?: LZMAOptions, options?: TransformOptions);
}

export declare class Unxz extends XzStream {
  constructor(lzmaOptions?: LZMAOptions, options?: TransformOptions);
}

/** Check if threading support is available */
export declare function hasThreads(): boolean;

/** Check if a buffer starts with XZ magic bytes */
export declare function isXZ(buffer: Buffer): boolean;

/** Get the runtime liblzma version string (e.g., "5.4.1") */
export declare function versionString(): string;

/** Get the runtime liblzma version number (e.g., 50040010 for 5.4.1) */
export declare function versionNumber(): number;

/** Get memory usage estimate for encoding with given preset */
export declare function easyEncoderMemusage(presetLevel: number): number;

/** Get memory usage estimate for decoding */
export declare function easyDecoderMemusage(): number;

/** Parse the index from a complete XZ file to get metadata */
export declare function parseFileIndex(buffer: Buffer): XZFileIndex;

/** Create a compression stream */
export declare function createXz(lzmaOptions?: LZMAOptions, options?: TransformOptions): Xz;

/** Create a decompression stream */
export declare function createUnxz(lzmaOptions?: LZMAOptions, options?: TransformOptions): Unxz;

/** Compress a buffer asynchronously */
export declare function xz(buffer: Buffer | string, callback: CompressionCallback): void;
export declare function xz(buffer: Buffer | string, options: LZMAOptions, callback: CompressionCallback): void;

/** Decompress a buffer asynchronously */
export declare function unxz(buffer: Buffer | string, callback: CompressionCallback): void;
export declare function unxz(buffer: Buffer | string, options: LZMAOptions, callback: CompressionCallback): void;

/** Compress a buffer synchronously */
export declare function xzSync(buffer: Buffer | string, options?: LZMAOptions): Buffer;

/** Decompress a buffer synchronously */
export declare function unxzSync(buffer: Buffer | string, options?: LZMAOptions): Buffer;

/** Compress a buffer asynchronously using Promises */
export declare function xzAsync(buffer: Buffer | string, options?: LZMAOptions): Promise<Buffer>;

/** Decompress a buffer asynchronously using Promises */
export declare function unxzAsync(buffer: Buffer | string, options?: LZMAOptions): Promise<Buffer>;

/** Constants for integrity check types */
export declare const check: {
  readonly NONE: number;
  readonly CRC32: number;
  readonly CRC64: number;
  readonly SHA256: number;
};

/** Constants for compression presets */
export declare const preset: {
  readonly DEFAULT: number;
  readonly EXTREME: number;
};

/** Constants for compression modes */
export declare const mode: {
  readonly FAST: number;
  readonly NORMAL: number;
};

/** Constants for stream flags */
export declare const flag: {
  readonly TELL_NO_CHECK: number;
  readonly TELL_UNSUPPORTED_CHECK: number;
  readonly TELL_ANY_CHECK: number;
  readonly CONCATENATED: number;
};

/** Constants for compression filters */
export declare const filter: {
  readonly LZMA2: number;
  readonly X86: number;
  readonly POWERPC: number;
  readonly IA64: number;
  readonly ARM: number;
  readonly ARMTHUMB: number;
  readonly SPARC: number;
};

// LZMA action constants
export declare const LZMA_RUN: number;
export declare const LZMA_SYNC_FLUSH: number;
export declare const LZMA_FULL_FLUSH: number;
export declare const LZMA_FINISH: number;

// LZMA status/error constants
export declare const LZMA_OK: number;
export declare const LZMA_STREAM_END: number;
export declare const LZMA_NO_CHECK: number;
export declare const LZMA_UNSUPPORTED_CHECK: number;
export declare const LZMA_GET_CHECK: number;
export declare const LZMA_MEM_ERROR: number;
export declare const LZMA_MEMLIMIT_ERROR: number;
export declare const LZMA_FORMAT_ERROR: number;
export declare const LZMA_OPTIONS_ERROR: number;
export declare const LZMA_DATA_ERROR: number;
export declare const LZMA_BUF_ERROR: number;
export declare const LZMA_PROG_ERROR: number;

// Additional filter constants
export declare const LZMA_FILTER_X86: number;
export declare const LZMA_FILTER_POWERPC: number;
export declare const LZMA_FILTER_IA64: number;
export declare const LZMA_FILTER_ARM: number;
export declare const LZMA_FILTER_ARMTHUMB: number;
export declare const LZMA_FILTERS_MAX: number;

// Grouped constants for better organization
export declare const LZMAAction: {
  readonly RUN: number;
  readonly SYNC_FLUSH: number;
  readonly FULL_FLUSH: number;
  readonly FINISH: number;
};

export declare const LZMAStatus: {
  readonly OK: number;
  readonly STREAM_END: number;
  readonly NO_CHECK: number;
  readonly UNSUPPORTED_CHECK: number;
  readonly GET_CHECK: number;
  readonly MEM_ERROR: number;
  readonly MEMLIMIT_ERROR: number;
  readonly FORMAT_ERROR: number;
  readonly OPTIONS_ERROR: number;
  readonly DATA_ERROR: number;
  readonly BUF_ERROR: number;
  readonly PROG_ERROR: number;
};

export declare const LZMAFilter: {
  readonly LZMA2: number;
  readonly X86: number;
  readonly POWERPC: number;
  readonly IA64: number;
  readonly ARM: number;
  readonly ARMTHUMB: number;
  readonly SPARC: number;
  readonly X86_ALT: number;
  readonly POWERPC_ALT: number;
  readonly IA64_ALT: number;
  readonly ARM_ALT: number;
  readonly ARMTHUMB_ALT: number;
  readonly FILTERS_MAX: number;
};

export { LZMAErrorMessage } from './lib/lzma.js';
export type { CheckType, FilterType, LZMAActionType, LZMAStatusType, ModeType, PresetType } from './lib/types.js';