import { Boom } from '@hapi/boom'
import { AxiosRequestConfig } from 'axios'
import { Readable, Transform } from 'stream'
import { URL } from 'url'
import { proto } from '../../WAProto'
import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types'
import { BinaryNode } from '../WABinary'
import { ILogger } from './logger'

export declare const hkdfInfoKey: (type: MediaType) => string

export declare const getRawMediaUploadData: (media: WAMediaUpload, mediaType: MediaType, logger?: ILogger) => Promise<{
    filePath: string
    fileSha256: Buffer<ArrayBufferLike>
    fileLength: number
}>

/** generates all the keys required to encrypt/decrypt & sign a media message */
export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo

export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
    buffer: Buffer
    original: {
        width: number | undefined
        height: number | undefined
    }
}>

export declare const encodeBase64EncodedStringForUpload: (b64: string) => string

export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
    img: Buffer
}>

/** gets the SHA256 of the given media message */
export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined

export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>

/**
  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
 */
export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array | undefined>

export declare const toReadable: (buffer: Buffer) => Readable

export declare const toBuffer: (stream: Readable) => Promise<Buffer>

export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
    readonly stream: Readable
    readonly type: "buffer"
} | {
    readonly stream: Readable
    readonly type: "readable"
} | {
    readonly stream: Readable
    readonly type: "remote"
} | {
    readonly stream: import("fs").ReadStream
    readonly type: "file"
}>

/** generates a thumbnail for a given media, if required */
export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
    logger?: Logger
}): Promise<{
    thumbnail: string | undefined
    originalImageDimensions: {
        width: number
        height: number
    } | undefined
}>

export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
    isStream?: true
}) => Promise<Readable>

type EncryptedStreamOptions = {
    saveOriginalFileIfRequired?: boolean
    logger?: Logger
    opts?: AxiosRequestConfig
}

export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
    mediaKey: Buffer
    encWriteStream: Readable
    bodyPath: string | undefined
    mac: Buffer
    fileEncSha256: Buffer
    fileSha256: Buffer
    fileLength: number
    didSaveToTmpPath: boolean
}>

export type MediaDownloadOptions = {
    startByte?: number
    endByte?: number
    options?: AxiosRequestConfig<{}>
}

export declare const getUrlFromDirectPath: (directPath: string) => string

export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>

/**
 * Decrypts and downloads an AES256-CBC encrypted file given the keys.
 * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
 * */
export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>

export declare function extensionForMediaMessage(message: WAMessageContent): string

export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction
/**
 * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
 */
export declare const encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode

export declare const decodeMediaRetryNode: (node: BinaryNode) => {
    key: proto.IMessageKey
    media?: {
        ciphertext: Uint8Array
        iv: Uint8Array
    } | undefined
    error?: Boom<any> | undefined
}

export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
    ciphertext: Uint8Array
    iv: Uint8Array
}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>

export declare const getStatusCodeForMediaRetry: (code: number) => any

export {}