import { Readable } from 'node:stream';

type DataTypeName = "ArrayBuffer" | "Base64" | "Blob" | "DataView" | "NodeStream" | "NumberArray" | "ReadableStream" | "Response" | "Text" | "Uint8Array";
type DataType = ArrayBufferLike | Base64 | Blob | DataView | Readable | number[] | ReadableStream | Response | string | Uint8Array;
type _DataTypeMap = {
    ArrayBuffer: ArrayBufferLike;
    Base64: Base64;
    Blob: Blob;
    DataView: DataView;
    NodeStream: Readable;
    NumberArray: number[];
    ReadableStream: ReadableStream;
    Response: Response;
    Text: string;
    Uint8Array: Uint8Array;
};
type DataTypeMap<T extends DataTypeName> = _DataTypeMap[T];
type Base64 = string;
type Base64Options = {
    urlSafe?: boolean;
    dataURL?: boolean;
    type?: string;
};

/**
 * Test if input is an instance of [ArrayBuffer][ArrayBuffer] and return `true` or `false`.
 * @group ArrayBuffer
 */
declare function isArrayBuffer(input: unknown): input is ArrayBuffer;
/**
 * Assert that input is an instance of [ArrayBuffer][ArrayBuffer] or throw a `TypeError`.
 * @group ArrayBuffer
 */
declare const assertArrayBuffer: (input: unknown) => void;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [Blob][Blob]
 * @group ArrayBuffer
 */
declare function arrayBufferToBlob(arrayBuffer: ArrayBuffer, options?: BlobPropertyBag): Blob;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [DataView][DataView]
 * @group ArrayBuffer
 */
declare function arrayBufferToDataView(arrayBuffer: ArrayBufferLike): DataView;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [Number Array][Number Array]
 * @group ArrayBuffer
 */
declare function arrayBufferToNumberArray(arrayBuffer: ArrayBufferLike): number[];
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [ReadableStream][ReadableStream]
 * @group ArrayBuffer
 */
declare function arrayBufferToReadableStream(arrayBuffer: ArrayBufferLike): ReadableStream<Uint8Array>;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [Response][Response]
 * @group ArrayBuffer
 */
declare function arrayBufferToResponse(arrayBuffer: ArrayBuffer, init?: ResponseInit): Response;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [Text][Text]
 * @group ArrayBuffer
 */
declare function arrayBufferToText(arrayBuffer: ArrayBuffer): string;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [Uint8Array][Uint8Array]
 *
 * @group ArrayBuffer
 */
declare function arrayBufferToUint8Array(arrayBuffer: ArrayBufferLike): Uint8Array;
/**
 * Convert from [ArrayBuffer][ArrayBuffer] to [Base64][Base64]
 * @group ArrayBuffer
 */
declare function arrayBufferToBase64(arrayBuffer: ArrayBufferLike, base64Options: Base64Options): Base64;

/**
 * Test if input matches the [Base64][Base64] data URL (data:[<mediatype>][;base64],<data>) and return `true` or `false`.
 * @group Base64
 */
declare function isBase64DataURL(input: unknown): input is Base64;
/**
 * Assert if input matches the [Base64][Base64] data URL (data:[<mediatype>][;base64],<data>) or throw a `TypeError`.
 * @group Base64
 */
declare const assertBase64: (input: unknown, opts?: Base64Options) => void;
/**
 * Convert from [Base64][Base64] to [Text][Text]
 * @param encoding - The encoding to use. Default is `utf8`.
 * @group Base64
 */
declare function base64ToText(string: Base64, opts?: Base64Options): string;
/**
 * Convert from [Base64][Base64] to [Uint8Array][Uint8Array]
 * @group Base64
 */
declare function base64ToUint8Array(string: Base64, base64Options?: Base64Options): Uint8Array;
/**
 * Convert from [Base64][Base64] to [ArrayBuffer][ArrayBuffer]
 * @group Base64
 */
declare function base64ToArrayBuffer(string: Base64, base64Options?: Base64Options): ArrayBufferLike;
/**
 * Convert from [Base64][Base64] to [Blob][Blob]
 * @group Base64
 */
declare function base64ToBlob(string: Base64, opts?: Base64Options & {
    blobProps?: BlobPropertyBag;
}): Blob;
/**
 * Convert from [Base64][Base64] to [DataView][DataView]
 * @group Base64
 */
declare function base64ToDataView(string: Base64, base64Options?: Base64Options): DataView;
/**
 * Convert from [Base64][Base64] to [Number Array][Number Array]
 * @group Base64
 */
declare function base64ToNumberArray(string: Base64, base64Options?: Base64Options): number[];
/**
 * Convert from [Base64][Base64] to [ReadableStream][ReadableStream]
 * @group Base64
 */
declare function base64ToReadableStream(string: Base64, base64Options?: Base64Options): ReadableStream<Uint8Array>;
/**
 * Convert from [Base64][Base64] to [Response][Response]
 * @group Base64
 */
declare function base64ToResponse(string: Base64, opts?: Base64Options & {
    responseOptions?: ResponseInit;
    blobProps: BlobPropertyBag;
}): Response;

/**
 * Test if input is an instance of [Blob][Blob] and return `true` or `false`.
 * @group Blob
 */
declare function isBlob(input: unknown): input is Blob;
/**
 * Assert that input is an instance of [Blob][Blob] or throw a `TypeError`.
 * @group Blob
 */
declare const assertBlob: (input: unknown) => void;
/**
 * Convert from [Blob][Blob] to [ArrayBuffer][ArrayBuffer]
 * @group Blob
 */
declare function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
/**
 * Convert from [Blob][Blob] to [DataView][DataView]
 * @group Blob
 */
declare function blobToDataView(blob: Blob): Promise<DataView>;
/**
 * Convert from [Blob][Blob] to [Number Array][Number Array]
 * @group Blob
 */
declare function blobToNumberArray(blob: Blob): Promise<number[]>;
/**
 * Convert from [Blob][Blob] to [ReadableStream][ReadableStream]
 * @group Blob
 */
declare function blobToReadableStream(blob: Blob): ReadableStream<Uint8Array>;
/**
 * Convert from [Blob][Blob] to [Response][Response]
 * @group Blob
 */
declare function blobToResponse(blob: Blob, init?: ResponseInit): Response;
/**
 * Convert from [Blob][Blob] to [Text][Text]
 * @group Blob
 */
declare function blobToText(blob: Blob): Promise<string>;
/**
 * Convert from [Blob][Blob] to [Uint8Array][Uint8Array]
 * @group Blob
 */
declare function blobToUint8Array(blob: Blob): Promise<Uint8Array>;
/**
 * Convert from [Blob][Blob] to [Base64][Base64]
 * @group Blob
 */
declare function blobToBase64(blob: Blob, base64Options: Base64Options): Promise<Base64>;

/**
 * Test if input is an instance of [DataView][DataView] and return `true` or `false`.
 * @group DataView
 */
declare function isDataView(input: unknown): input is DataView;
/**
 * Assert that input is an instance of [DataView][DataView] or throw a `TypeError`.
 * @group DataView
 */
declare const assertDataView: (input: unknown) => void;
/**
 * Convert from [DataView][DataView] to [ArrayBuffer][ArrayBuffer]
 * @group DataView
 */
declare function dataViewToArrayBuffer(dataView: DataView): ArrayBuffer;
/**
 * Convert from [DataView][DataView] to [Blob][Blob]
 * @group DataView
 */
declare function dataViewToBlob(dataView: DataView, options?: BlobPropertyBag): Blob;
/**
 * Convert from [DataView][DataView] to [Number Array][Number Array]
 * @group DataView
 */
declare function dataViewToNumberArray(dataView: DataView): number[];
/**
 * Convert from [DataView][DataView] to [ReadableStream][ReadableStream]
 * @group DataView
 */
declare function dataViewToReadableStream(dataView: DataView): ReadableStream<Uint8Array>;
/**
 * Convert from [DataView][DataView] to [Text][Text]
 * @group DataView
 */
declare function dataViewToText(dataView: DataView): string;
/**
 * Convert from [DataView][DataView] to [Response][Response]
 * @group DataView
 */
declare function dataViewToResponse(dataView: DataView, init?: ResponseInit): Response;
/**
 * Convert from [DataView][DataView] to [Uint8Array][Uint8Array]
 * @group DataView
 */
declare function dataViewToUint8Array(dataView: DataView): Uint8Array;
/**
 * Convert from [DataView][DataView] to [Base64][Base64]
 * @group DataView
 */
declare function dataViewToBase64(dataView: DataView, base64Options?: Base64Options): Base64;

/**
 * Test if input is an instance of [NodeStream][NodeStream] and return `true` or `false`.
 * @group NodeStream
 */
declare function isNodeStream(input: unknown): input is Readable;
/**
 * Assert that input is an instance of [NodeStream][NodeStream] or throw a `TypeError`.
 * @group NodeStream
 */
declare const assertNodeStream: (input: unknown) => void;
/**
 * Convert from [NodeStream][NodeStream] to [ArrayBuffer][ArrayBuffer]
 * @group NodeStream
 */
declare function nodeStreamToArrayBuffer(input: Readable): Promise<ArrayBufferLike>;
/**
 * Convert from [NodeStream][NodeStream] to [Blob][Blob]
 * @group NodeStream
 */
declare function nodeStreamToBlob(input: Readable, options?: BlobPropertyBag): Promise<Blob>;
/**
 * Convert from [NodeStream][NodeStream] to [DataView][DataView]
 * @group NodeStream
 */
declare function nodeStreamToDataView(input: Readable): Promise<DataView>;
/**
 * Convert from [NodeStream][NodeStream] to [Number Array][Number Array]
 * @group NodeStream
 */
declare function nodeStreamToNumberArray(input: Readable): Promise<number[]>;
/**
 * Convert from [NodeStream][NodeStream] to [ReadableStream][ReadableStream]
 * @group NodeStream
 */
declare function nodeStreamToReadableStream(input: Readable): Promise<ReadableStream>;
/**
 * Convert from [NodeStream][NodeStream] to [Text][Text]
 * @group NodeStream
 */
declare function nodeStreamToText(input: Readable): Promise<string>;
/**
 * Convert from [NodeStream][NodeStream] to [Response][Response]
 * @group NodeStream
 */
declare function nodeStreamToResponse(input: Readable, init?: ResponseInit): Promise<Response>;
/**
 * Convert from [NodeStream][NodeStream] to [Uint8Array][Uint8Array]
 * @group NodeStream
 */
declare function nodeStreamToUint8Array(input: Readable): Promise<Uint8Array>;
/**
 * Convert from [NodeStream][NodeStream] to [Base64][Base64]
 * @group NodeStream
 */
declare function nodeStreamToBase64(input: Readable, base64Options?: Base64Options): Promise<Base64>;

/**
 * Test if input is an instance of [Number Array][Number Array] and return `true` or `false`.
 * @group NumberArray
 */
declare function isNumberArray(input: unknown): input is number[];
/**
 * Assert that input is an instance of [Number Array][Number Array] or throw a `TypeError`.
 * @group NumberArray
 */
declare const assertNumberArray: (input: unknown) => void;
/**
 * Convert from [Number Array][Number Array] to [ArrayBuffer][ArrayBuffer]
 * @group NumberArray
 */
declare function numberArrayToArrayBuffer(numberArray: number[]): ArrayBufferLike;
/**
 * Convert from [Number Array][Number Array] to [Blob][Blob]
 * @group NumberArray
 */
declare function numberArrayToBlob(numberArray: number[], options?: BlobPropertyBag): Blob;
/**
 * Convert from [Number Array][Number Array] to [DataView][DataView]
 * @group NumberArray
 */
declare function numberArrayToDataView(numberArray: number[]): DataView;
/**
 * Convert from [Number Array][Number Array] to [ReadableStream][ReadableStream]
 * @group NumberArray
 */
declare function numberArrayToReadableStream(numberArray: number[]): ReadableStream<Uint8Array>;
/**
 * Convert from [Number Array][Number Array] to [Response][Response]
 */
declare function numberArrayToResponse(numberArray: number[], init?: ResponseInit): Response;
/**
 * Convert from [Number Array][Number Array] to [Text][Text]
 * @group NumberArray
 */
declare function numberArrayToText(numberArray: number[]): string;
/**
 * Convert from [Number Array][Number Array] to [Uint8Array][Uint8Array]
 * @group NumberArray
 */
declare function numberArrayToUint8Array(numberArray: number[]): Uint8Array;
/**
 * Convert from [Number Array][Number Array] to [Base64][Base64]
 * @group NumberArray
 */
declare function numberArrayToBase64(numberArray: number[], base64Options?: Base64Options): Base64;

/**
 * Test if input is an instance of [ReadableStream][ReadableStream] and return `true` or `false`.
 * @group ReadableStream
 */
declare function isReadableStream(input: unknown): input is ReadableStream;
/**
 * Assert that input is an instance of [ReadableStream][ReadableStream] or throw a `TypeError`.
 * @group ReadableStream
 */
declare const assertReadableStream: (input: unknown) => void;
/**
 * Convert from [ReadableStream][ReadableStream] to [ArrayBuffer][ArrayBuffer]
 * @group ReadableStream
 */
declare function readableStreamToArrayBuffer(readableStream: ReadableStream): Promise<ArrayBuffer>;
/**
 * Convert from [ReadableStream][ReadableStream] to [Blob][Blob]
 * @group ReadableStream
 */
declare function readableStreamToBlob(readableStream: ReadableStream, options?: BlobPropertyBag): Promise<Blob>;
/**
 * Convert from [ReadableStream][ReadableStream] to [DataView][DataView]
 * @group ReadableStream
 */
declare function readableStreamToDataView(readableStream: ReadableStream): Promise<DataView>;
/**
 * Convert from [ReadableStream][ReadableStream] to [Number Array][Number Array]
 * @group ReadableStream
 */
declare function readableStreamToNumberArray(readableStream: ReadableStream): Promise<number[]>;
/**
 * Convert from [ReadableStream][ReadableStream] to [Text][Text]
 * @group ReadableStream
 */
declare function readableStreamToText(readableStream: ReadableStream): Promise<string>;
/**
 * Convert from [ReadableStream][ReadableStream] to [Response][Response]
 */
declare function readableStreamToResponse(readableStream: ReadableStream, init?: ResponseInit): Response;
/**
 * Convert from [ReadableStream][ReadableStream] to [Uint8Array][Uint8Array]
 * @group ReadableStream
 */
declare function readableStreamToUint8Array(readableStream: ReadableStream): Promise<Uint8Array>;
/**
 * Convert from [ReadableStream][ReadableStream] to [Base64][Base64]
 * @group ReadableStream
 */
declare function readableStreamToBase64(readableStream: ReadableStream, base64Options?: Base64Options): Promise<Base64>;

/**
 * Test if input is an instance of [Response][Response] and return `true` or `false`.
 * @group Response
 */
declare function isResponse(input: unknown): input is Response;
/**
 * Assert that input is an instance of [Response][Response] or throw a `TypeError`.
 * @group Response
 */
declare const assertResponse: (input: unknown) => void;
/**
 * Convert from [Response][Response] to [ArrayBuffer][ArrayBuffer]
 * @group Response
 */
declare function responseToArrayBuffer(response: Response): Promise<ArrayBuffer>;
/**
 * Convert from [Response][Response] to [Blob][Blob]
 * @group Response
 */
declare function responseToBlob(response: Response): Promise<Blob>;
/**
 * Convert from [Response][Response] to [DataView][DataView]
 * @group Response
 */
declare function responseToDataView(response: Response): Promise<DataView>;
/**
 * Convert from [Response][Response] to [Number Array][Number Array]
 * @group Response
 */
declare function responseToNumberArray(response: Response): Promise<number[]>;
/**
 * Convert from [Response][Response] to [ReadableStream]ReadableStream]
 * @group Response
 */
declare function responseToReadableStream(response: Response): ReadableStream;
/**
 * Convert from [Response][Response] to [Text][Text]
 * @group Response
 */
declare function responseToText(response: Response): Promise<string>;
/**
 * Convert from [Response][Response] to [Uint8Array][Uint8Array]
 * @group Response
 */
declare function responseToUint8Array(response: Response): Promise<Uint8Array>;
/**
 * Convert from [Response][Response] to [Base64][Base64]
 * @group Response
 */
declare function responseToBase64(response: Response, base64Options?: Base64Options): Promise<Base64>;

/**
 * Test if input is an instance of [Text][Text] and return `true` or `false`.
 * @group Text
 */
declare function isText(input: unknown): input is string;
/**
 * Assert that input is an instance of [Text][Text] or throw a `TypeError`.
 * @group Text
 */
declare const assertText: (input: unknown) => void;
/**
 * Convert from [Text][Text] to [ArrayBuffer][ArrayBuffer]
 * @group Text
 */
declare function textToArrayBuffer(string: string): ArrayBufferLike;
/**
 * Convert from [Text][Text] to [Blob][Blob]
 * @group Text
 */
declare function textToBlob(string: string, options?: BlobPropertyBag): Blob;
/**
 * Convert from [Text][Text] to [DataView][DataView]
 * @group Text
 */
declare function textToDataView(string: string): DataView;
/**
 * Convert from [Text][Text] to [Number Array][Number Array]
 * @group Text
 */
declare function textToNumberArray(string: string): number[];
/**
 * Convert from [Text][Text] to [ReadableStream][ReadableStream]
 * @group Text
 */
declare function textToReadableStream(string: string): ReadableStream<Uint8Array>;
declare function textToResponse(string: string, init?: ResponseInit): Response;
/**
 * Convert from [Text][Text] to [Uint8Array][Uint8Array]
 * @group Text
 */
declare function textToUint8Array(string: string): Uint8Array;
/**
 * Convert from [Text][Text] to [Base64][Base64]
 * @param encoding - The encoding to use. Default is `utf8`.
 * @group Text
 */
declare function textToBase64(string: string, opts?: Base64Options): Base64;

/**
 * Test if input is an instance of [Uint8Array][Uint8Array] and return `true` or `false`.
 * @group Uint8Array
 */
declare function isUint8Array(input: unknown): input is Uint8Array;
/**
 * Assert that input is an instance of [Uint8Array][Uint8Array] or throw a `TypeError`.
 * @group Uint8Array
 */
declare const assertUint8Array: (input: unknown) => void;
/**
 * Convert from [Uint8Array][Uint8Array] to [ArrayBuffer][ArrayBuffer]
 * @group Uint8Array
 */
declare function uint8ArrayToArrayBuffer(uint8Array: Uint8Array): ArrayBufferLike;
/**
 * Convert from [Uint8Array][Uint8Array] to [Blob][Blob]
 * @group Uint8Array
 */
declare function uint8ArrayToBlob(uint8Array: Uint8Array, options?: BlobPropertyBag): Blob;
/**
 * Convert from [Uint8Array][Uint8Array] to [DataView][DataView]
 * @group Uint8Array
 */
declare function uint8ArrayToDataView(uint8Array: Uint8Array): DataView;
/**
 * Convert from [Uint8Array][Uint8Array] to [Number Array][Number Array]
 * @group Uint8Array
 */
declare function uint8ArrayToNumberArray(uint8Array: Uint8Array): number[];
/**
 * Convert from [Uint8Array][Uint8Array] to [ReadableStream][ReadableStream]
 * @group Uint8Array
 */
declare function uint8ArrayToReadableStream(uint8Array: Uint8Array): ReadableStream<Uint8Array>;
/**
 * Convert from [Uint8Array][Uint8Array] to [Response][Response]
 * @group Uint8Array
 */
declare function uint8ArrayToResponse(uint8Array: Uint8Array, init?: ResponseInit): Response;
/**
 * Convert from [Uint8Array][Uint8Array] to [Text][Text]
 * @group Uint8Array
 */
declare function uint8ArrayToText(uint8Array: Uint8Array): string;
/**
 * Convert from [Uint8Array][Uint8Array] to [Base64][Base64]
 * @group Uint8Array
 */
declare function uint8ArrayToBase64(uint8Array: Uint8Array, base64Options?: Base64Options): string;

declare function detectType(input: DataType): DataTypeName;

/**
 * Convert from any value to any supported data type
 * @param toType - The target data type
 * @param input - The input value
 * @param fromType - The source data type (optional)
 */
declare function convertTo<T extends Exclude<DataTypeName, "NodeStream">>(toType: T, input: DataType, fromType?: DataTypeName): DataTypeMap<T>;
/**
 * Convert from any value to [ArrayBuffer][ArrayBuffer]
 * @group ArrayBuffer
 */
declare const toArrayBuffer: (input: DataType) => any;
/**
 * Convert from any value to [Blob][Blob]
 * @group Blob
 */
declare const toBlob: (input: DataType) => any;
/**
 * Convert from any value to [DataView][DataView]
 * @group DataView
 */
declare const toDataView: (input: DataType) => any;
/**
 * Convert from any value to [Number Array][Number Array]
 * @group NumberArray
 */
declare const toNumberArray: (input: DataType) => any;
/**
 * Convert from any value to [ReadableStream][ReadableStream]
 * @group ReadableStream
 */
declare const toReadableStream: (input: DataType) => any;
/**
 * Convert from any value to [Response][Response]
 * @group ReadableStream
 */
declare const toResponse: (input: DataType) => any;
/**
 * Convert from any value to [Text][Text]
 * @group String
 */
declare const toText: (input: DataType) => any;
/**
 * Convert from any value to [Uint8Array][Uint8Array]
 * @group Uint8Array
 */
declare const toUint8Array: (input: DataType) => any;
/**
 * Convert from any value to [Base64][Base64]
 * @group Base64
 */
declare const toBase64: (input: DataType) => any;

export { type Base64, type Base64Options, type DataType, type DataTypeMap, type DataTypeName, type _DataTypeMap, arrayBufferToBase64, arrayBufferToBlob, arrayBufferToDataView, arrayBufferToNumberArray, arrayBufferToReadableStream, arrayBufferToResponse, arrayBufferToText, arrayBufferToUint8Array, assertArrayBuffer, assertBase64, assertBlob, assertDataView, assertNodeStream, assertNumberArray, assertReadableStream, assertResponse, assertText, assertUint8Array, base64ToArrayBuffer, base64ToBlob, base64ToDataView, base64ToNumberArray, base64ToReadableStream, base64ToResponse, base64ToText, base64ToUint8Array, blobToArrayBuffer, blobToBase64, blobToDataView, blobToNumberArray, blobToReadableStream, blobToResponse, blobToText, blobToUint8Array, convertTo, dataViewToArrayBuffer, dataViewToBase64, dataViewToBlob, dataViewToNumberArray, dataViewToReadableStream, dataViewToResponse, dataViewToText, dataViewToUint8Array, detectType, isArrayBuffer, isBase64DataURL, isBlob, isDataView, isNodeStream, isNumberArray, isReadableStream, isResponse, isText, isUint8Array, nodeStreamToArrayBuffer, nodeStreamToBase64, nodeStreamToBlob, nodeStreamToDataView, nodeStreamToNumberArray, nodeStreamToReadableStream, nodeStreamToResponse, nodeStreamToText, nodeStreamToUint8Array, numberArrayToArrayBuffer, numberArrayToBase64, numberArrayToBlob, numberArrayToDataView, numberArrayToReadableStream, numberArrayToResponse, numberArrayToText, numberArrayToUint8Array, readableStreamToArrayBuffer, readableStreamToBase64, readableStreamToBlob, readableStreamToDataView, readableStreamToNumberArray, readableStreamToResponse, readableStreamToText, readableStreamToUint8Array, responseToArrayBuffer, responseToBase64, responseToBlob, responseToDataView, responseToNumberArray, responseToReadableStream, responseToText, responseToUint8Array, textToArrayBuffer, textToBase64, textToBlob, textToDataView, textToNumberArray, textToReadableStream, textToResponse, textToUint8Array, toArrayBuffer, toBase64, toBlob, toDataView, toNumberArray, toReadableStream, toResponse, toText, toUint8Array, uint8ArrayToArrayBuffer, uint8ArrayToBase64, uint8ArrayToBlob, uint8ArrayToDataView, uint8ArrayToNumberArray, uint8ArrayToReadableStream, uint8ArrayToResponse, uint8ArrayToText };