import { Readable } from 'node:stream';
import { File } from 'formdata-node';
/** discriminator for `MediaInput` envelopes */
export declare enum MediaSourceType {
    Path = "path",
    Url = "url",
    FileId = "file_id",
    Buffer = "buffer",
    Stream = "stream",
    File = "file",
    ArrayBuffer = "array_buffer",
    Local = "local"
}
/** options shared by every `MediaSource.X(...)` factory */
export interface MediaInputOptions {
    filename?: string;
}
/** url-only options — `forceUpload` makes puregram fetch the url and upload its bytes directly */
export interface MediaInputUrlOptions {
    forceUpload?: boolean;
}
interface Base extends MediaInputOptions {
    type: MediaSourceType;
}
/** local-file upload envelope */
export interface MediaSourcePath extends Base {
    type: MediaSourceType.Path;
    value: string;
}
/** url upload envelope (telegram fetches it, unless `forceUpload` is set) */
export interface MediaSourceUrl extends Base, MediaInputUrlOptions {
    type: MediaSourceType.Url;
    value: string;
}
/** existing-on-server reference envelope */
export interface MediaSourceFileId extends Base {
    type: MediaSourceType.FileId;
    value: string;
}
/** in-memory bytes envelope */
export interface MediaSourceBuffer extends Base {
    type: MediaSourceType.Buffer;
    value: Buffer;
}
/** stream upload envelope */
export interface MediaSourceStream extends Base {
    type: MediaSourceType.Stream;
    value: Readable;
}
/** WHATWG `File` envelope */
export interface MediaSourceFile extends Base {
    type: MediaSourceType.File;
    value: File;
}
/** raw `ArrayBuffer` envelope */
export interface MediaSourceArrayBuffer extends Base {
    type: MediaSourceType.ArrayBuffer;
    value: ArrayBufferLike;
}
/** local-server on-disk reference envelope — the server reads the path itself, no upload */
export interface MediaSourceLocal extends Base {
    type: MediaSourceType.Local;
    value: string;
}
/** discriminated union of every `MediaSource.X(...)` return value */
export type MediaInput = MediaSourcePath | MediaSourceUrl | MediaSourceFileId | MediaSourceBuffer | MediaSourceStream | MediaSourceFile | MediaSourceArrayBuffer | MediaSourceLocal;
/**
 * Static factories for the various ways media can be uploaded to the bot api
 *
 * @example
 * ```ts
 * tg.api.sendDocument({
 *   chat_id: CHAT_ID,
 *   document: MediaSource.buffer(catBuffer, { filename: 'cat.png' })
 * })
 * ```
 */
export declare class MediaSource {
    /**
     * upload a local file by absolute or relative path
     *
     * @example
     * ```ts
     * update.sendPhoto(MediaSource.path('./cat.png'))
     * ```
     */
    static path(path: string, opts?: MediaInputOptions): MediaSourcePath;
    /**
     * reference a file the *local bot api server* reads directly off disk, skipping
     * the multipart upload entirely. requires `useLocal: true` and a filesystem the
     * server can see (same host/container). prefer an absolute path; relative paths
     * resolve against the bot process cwd. resolved to a `file://` uri at request time
     *
     * @example
     * ```ts
     * // tg built with { useLocal: true, apiBaseUrl: 'http://localhost:8081/bot' }
     * update.sendVideo(MediaSource.local('/srv/media/clip.mp4'))
     * ```
     */
    static local(path: string, opts?: MediaInputOptions): {
        filename?: string;
        type: MediaSourceType;
        value: string;
    };
    /**
     * upload from a url. by default telegram fetches the url itself, which only
     * works for gif/pdf/zip on `sendDocument`. set `forceUpload: true` to make
     * puregram fetch the bytes and upload them as multipart instead
     *
     * @example
     * ```ts
     * update.sendDocument(MediaSource.url(catUrl), { forceUpload: true, filename: 'cat.png' })
     * ```
     */
    static url(url: string, opts?: MediaInputOptions & MediaInputUrlOptions): MediaSourceUrl;
    /**
     * reference an already-uploaded file by `file_id`
     *
     * @example
     * ```ts
     * update.sendPhoto(MediaSource.fileId(savedFileId))
     * ```
     */
    static fileId(id: string, opts?: MediaInputOptions): MediaSourceFileId;
    /**
     * upload an in-memory buffer
     *
     * @example
     * ```ts
     * update.sendMediaGroup(buffers.map(b => InputMedia.photo({ media: MediaSource.buffer(b) })))
     * ```
     */
    static buffer(buffer: Buffer, opts?: MediaInputOptions): MediaSourceBuffer;
    /**
     * upload from a node `Readable` stream
     *
     * @example
     * ```ts
     * update.sendDocument(MediaSource.stream(createReadStream('./big-file.bin')))
     * ```
     */
    static stream(stream: Readable, opts?: MediaInputOptions): MediaSourceStream;
    /**
     * upload a WHATWG `File`
     *
     * @example
     * ```ts
     * const ab = await response.arrayBuffer()
     * update.sendDocument(MediaSource.file(new File([ab], 'cat.png')))
     * ```
     */
    static file(file: File, opts?: MediaInputOptions): MediaSourceFile;
    /**
     * upload from an `ArrayBuffer`/`SharedArrayBuffer`
     *
     * @example
     * ```ts
     * const ab = await response.arrayBuffer()
     * update.sendPhoto(MediaSource.arrayBuffer(ab))
     * ```
     */
    static arrayBuffer(buffer: ArrayBufferLike, opts?: MediaInputOptions): {
        filename?: string;
        type: MediaSourceType;
        value: ArrayBufferLike;
    };
    /**
     * upload from any `ArrayBufferView` (`Uint8Array`, other typed arrays, `DataView`).
     * convenient for bytes coming back from web apis where you'd otherwise wrap the
     * value with `Buffer.from(...)` yourself
     *
     * @example
     * ```ts
     * const bytes = new Uint8Array(await response.arrayBuffer())
     * update.sendDocument(MediaSource.bytes(bytes, { filename: 'cat.png' }))
     * ```
     */
    static bytes(view: ArrayBufferView, opts?: MediaInputOptions): MediaSourceBuffer;
    /**
     * upload from a base64 string. internally decoded to a `Buffer` since the bot
     * api has no native base64 upload form
     *
     * @example
     * ```ts
     * update.sendDocument(MediaSource.base64(await getBase64()))
     * ```
     */
    static base64(b64: string, opts?: MediaInputOptions): MediaSourceBuffer;
    /**
     * upload a utf-8 string as a file. shortcut for `MediaSource.buffer(Buffer.from(text))`
     *
     * @example
     * ```ts
     * update.sendDocument(MediaSource.text('hello world', { filename: 'note.txt' }))
     * ```
     */
    static text(text: string, opts?: MediaInputOptions): MediaSourceBuffer;
    /**
     * upload a value serialized as json. accepts an optional `space` for pretty-printing,
     * mirroring `JSON.stringify`'s third argument
     *
     * @example
     * ```ts
     * update.sendDocument(MediaSource.json({ ok: true }, { filename: 'state.json', space: 2 }))
     * ```
     */
    static json(value: unknown, opts?: MediaInputOptions & {
        space?: number | string;
    }): MediaSourceBuffer;
}
/** narrowing predicate for "is this a `MediaSource.X(...)` envelope" */
export declare function isMediaInput(value: unknown): value is MediaInput;
export {};
//# sourceMappingURL=index.d.ts.map