type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;
type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : TupleOf<T, N, []> : never;
/**
 * DataView wrapper for deserializing MMD data
 */
export declare class MmdDataDeserializer {
    /**
     * Whether the device is little endian
     */
    readonly isDeviceLittleEndian: boolean;
    private readonly _dataView;
    private _decoder;
    private _offset;
    /**
     * Creates MMD data deserializer
     * @param arrayBuffer ArrayBuffer to deserialize
     */
    constructor(arrayBuffer: ArrayBufferLike);
    /**
     * Current offset in the buffer
     */
    get offset(): number;
    set offset(value: number);
    private _getIsDeviceLittleEndian;
    /**
     * Changes the byte order of the array
     * @param array Array to swap
     */
    swap16Array(array: Int16Array | Uint16Array): void;
    /**
     * Changes the byte order of the array
     * @param array Array to swap
     */
    swap32Array(array: Int32Array | Uint32Array | Float32Array): void;
    /**
     * Read a uint8 value
     * @returns Uint8 value
     */
    getUint8(): number;
    /**
     * Read a int8 value
     * @returns Int8 value
     */
    getInt8(): number;
    /**
     * Read a uint8 array
     * @param dest Destination array
     */
    getUint8Array(dest: Uint8Array): void;
    /**
     * Read a uint16 value
     * @returns Uint16 value
     */
    getUint16(): number;
    /**
     * Read a uint16 array
     * @param dest Destination array
     */
    getUint16Array(dest: Uint16Array): void;
    /**
     * Read a int16 value
     * @returns Int16 value
     */
    getInt16(): number;
    /**
     * Read a int32 value
     * @returns Int32 value
     */
    getUint32(): number;
    /**
     * Read a uint32 array
     * @param dest Destination array
     */
    getUint32Array(dest: Uint32Array): void;
    /**
     * Read a int32 value
     * @returns Int32 value
     */
    getInt32(): number;
    /**
     * Read a int32 array
     * @param dest Destination array
     */
    getInt32Array(dest: Int32Array): void;
    /**
     * Read a float32 value
     * @returns Float32 value
     */
    getFloat32(): number;
    /**
     * Read a float32 array
     * @param dest Destination array
     */
    getFloat32Array(dest: Float32Array): void;
    /**
     * Read a float32 tuple
     * @param length Tuple length
     * @returns Float32 tuple
     */
    getFloat32Tuple<N extends number>(length: N): Tuple<number, N>;
    /**
     * Initializes TextDecoder with the specified encoding
     * @param encoding Encoding
     */
    initializeTextDecoder(encoding: string): void;
    /**
     * Decode the string in the encoding determined by the initializeTextDecoder method
     * @param length Length of the string in bytes
     * @param trim Whether to trim the string, usally used in Shift-JIS encoding
     * @returns Decoded string
     */
    getDecoderString(length: number, trim: boolean): string;
    /**
     * Read a utf-8 string
     * @param length Length of the string in bytes
     * @returns Utf-8 string
     */
    getSignatureString(length: number): string;
    /**
     * Calculate byte alignment for finding the offset of the next element
     * @param elementSize Element size
     * @param length Element count
     * @returns Offset of the next element
     */
    getPaddedArrayOffset(elementSize: number, length: number): number;
    /**
     * The number of bytes available
     */
    get bytesAvailable(): number;
}
export {};
