mp4box/dist/log-DO1-_KSL.d.ts

JavaScript version of GPAC's MP4Box tool

declare class MP4BoxBuffer extends ArrayBuffer {
    fileStart: number;
    usedBytes?: number;
    constructor(byteLength: number);
    static fromArrayBuffer(buffer: ArrayBufferLike, fileStart: number): MP4BoxBuffer;
}

declare class ContainerBox extends Box {
    subBoxNames?: ReadonlyArray<string>;
    /** @bundle box-write.js */
    write(stream: MultiBufferStream | DataStream): void;
    /** @bundle box-print.js */
    print(output: Output): void;
    /** @bundle box-parse.js */
    parse(stream: MultiBufferStream): void;
}

declare class co64Box extends FullBox {
    static readonly fourcc: "co64";
    box_name: "ChunkLargeOffsetBox";
    chunk_offsets: Array<number>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/co64.js */
    write(stream: MultiBufferStream): void;
}

declare class cslgBox extends FullBox {
    static readonly fourcc: "cslg";
    box_name: "CompositionToDecodeBox";
    compositionToDTSShift: number;
    leastDecodeToDisplayDelta: number;
    greatestDecodeToDisplayDelta: number;
    compositionStartTime: number;
    compositionEndTime: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/cslg.js */
    write(stream: MultiBufferStream): void;
}

declare class cttsBox extends FullBox {
    static readonly fourcc: "ctts";
    box_name: "CompositionOffsetBox";
    sample_counts: Array<number>;
    sample_offsets: Array<number>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/ctts.js */
    write(stream: MultiBufferStream): void;
    /** @bundle box-unpack.js */
    unpack(samples: Array<Sample>): void;
}

declare class elngBox extends FullBox {
    static readonly fourcc: "elng";
    box_name: "ExtendedLanguageBox";
    extended_language: string;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/elng.js */
    write(stream: MultiBufferStream): void;
}

declare class elstBox extends FullBox {
    static readonly fourcc: "elst";
    box_name: "EditListBox";
    entries: Array<Entry>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/elst.js */
    write(stream: MultiBufferStream): void;
}

declare class hdlrBox extends FullBox {
    static readonly fourcc: "hdlr";
    box_name: "HandlerBox";
    version: number;
    handler: string;
    name: string;
    flags: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/hldr.js */
    write(stream: MultiBufferStream): void;
}

interface Assocation {
    id: number;
    props: Array<{
        property_index: number;
        essential: boolean;
    }>;
}
declare class ipmaBox extends FullBox {
    static readonly fourcc: "ipma";
    box_name: "ItemPropertyAssociationBox";
    associations: Array<Assocation>;
    version: number;
    flags: number;
    parse(stream: MultiBufferStream): void;
}

declare class kindBox extends FullBox {
    static readonly fourcc: "kind";
    box_name: "KindBox";
    schemeURI: string;
    value: string;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/kind.js */
    write(stream: MultiBufferStream): void;
}

declare class mdhdBox extends FullBox {
    static readonly fourcc: "mdhd";
    box_name: "MediaHeaderBox";
    creation_time: number;
    modification_time: number;
    timescale: number;
    duration: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/mdhd.js */
    write(stream: MultiBufferStream): void;
}

declare class mehdBox extends FullBox {
    static readonly fourcc: "mehd";
    box_name: "MovieExtendsHeaderBox";
    fragment_duration: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/mehd.js */
    write(stream: MultiBufferStream): void;
}

declare class mvhdBox extends FullBox {
    static readonly fourcc: "mvhd";
    box_name: "MovieHeaderBox";
    creation_time: number;
    modification_time: number;
    timescale: number;
    duration: number;
    rate: number;
    volume: number;
    next_track_id: number;
    matrix: Matrix;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/mvhd.js */
    write(stream: MultiBufferStream): void;
    /** @bundle box-print.js */
    print(output: Output): void;
}

declare class psshBox extends FullBox {
    static readonly fourcc: "pssh";
    box_name: "ProtectionSystemSpecificHeaderBox";
    system_id: string;
    kid: Array<string>;
    protection_data?: Uint8Array;
    parse(stream: MultiBufferStream): void;
}

interface Entry$1 {
    sample_count: number;
    group_description_index: number;
}
declare class sbgpBox extends FullBox {
    static readonly fourcc: "sbgp";
    box_name: "SampleToGroupBox";
    grouping_type: string;
    grouping_type_parameter: number;
    entries: Array<Entry$1>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/sbgp.js */
    write(stream: MultiBufferStream): void;
}

declare class sdtpBox extends FullBox {
    static readonly fourcc: "sdtp";
    box_name: "SampleDependencyTypeBox";
    is_leading: Array<number>;
    sample_depends_on: Array<number>;
    sample_is_depended_on: Array<number>;
    sample_has_redundancy: Array<number>;
    parse(stream: MultiBufferStream): void;
}

declare class sgpdBox extends FullBox {
    static readonly fourcc: "sgpd";
    box_name: "SampleGroupDescriptionBox";
    grouping_type: 'alst' | 'avll' | 'avss' | 'dtrt' | 'mvif' | 'prol' | 'rap' | 'rash' | 'roll' | 'scif' | 'scnm' | 'seig' | 'stsa' | 'sync' | 'tele' | 'tsas' | 'tscl' | 'vipr' | (string & {});
    default_length: number;
    default_group_description_index: number;
    default_sample_description_index: number;
    entries: Array<SampleGroupEntry>;
    used: boolean;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/sgpd.js */
    write(stream: MultiBufferStream): void;
}

declare class stcoBox extends FullBox {
    static readonly fourcc: "stco";
    box_name: "ChunkOffsetBox";
    chunk_offsets: Array<number>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writings/stco.js */
    write(stream: MultiBufferStream): void;
    /** @bundle box-unpack.js */
    unpack(samples: Array<Sample>): void;
}

declare class stdpBox extends FullBox {
    static readonly fourcc: "stpd";
    box_name: "DegradationPriorityBox";
    priority: Array<number>;
    parse(stream: MultiBufferStream): void;
}

declare class stscBox extends FullBox {
    static readonly fourcc: "stsc";
    box_name: "SampleToChunkBox";
    first_chunk: Array<number>;
    samples_per_chunk: Array<number>;
    sample_description_index: Array<number>;
    parse(stream: MultiBufferStream): void;
    write(stream: MultiBufferStream): void;
    unpack(samples: Array<Sample>): void;
}

declare class av1CBox extends Box {
    static readonly fourcc: "av1C";
    box_name: "AV1CodecConfigurationBox";
    version: number;
    seq_profile: number;
    seq_level_idx_0: number;
    seq_tier_0: number;
    high_bitdepth: number;
    twelve_bit: number;
    monochrome: number;
    chroma_subsampling_x: number;
    chroma_subsampling_y: number;
    chroma_sample_position: number;
    reserved_1: number;
    initial_presentation_delay_present: number;
    initial_presentation_delay_minus_one: number;
    reserved_2: number;
    configOBUs: Uint8Array;
    parse(stream: MultiBufferStream): void;
}

declare class ParameterSetArray extends Array<Nalu> {
    toString(): string;
}

declare class avcCBox extends Box {
    static readonly fourcc: "avcC";
    box_name: "AVCConfigurationBox";
    configurationVersion: number;
    AVCProfileIndication: number;
    profile_compatibility: number;
    AVCLevelIndication: number;
    lengthSizeMinusOne: number;
    nb_SPS_nalus: number;
    SPS: ParameterSetArray;
    nb_PPS_nalus: number;
    PPS: ParameterSetArray;
    ext: Uint8Array;
    parse(stream: MultiBufferStream | DataStream): void;
    /** @bundle writing/avcC.js */
    write(stream: MultiBufferStream): void;
}

declare class NALUArrays extends Array<NaluArray> {
    toString(): string;
}

declare class hvcCBox extends Box {
    static readonly fourcc: "hvcC";
    box_name: "HEVCConfigurationBox";
    configurationVersion: number;
    general_profile_space: number;
    general_tier_flag: number;
    general_profile_idc: number;
    general_profile_compatibility: number;
    general_constraint_indicator: Uint8Array;
    general_level_idc: number;
    min_spatial_segmentation_idc: number;
    parallelismType: number;
    chroma_format_idc: number;
    bit_depth_luma_minus8: number;
    bit_depth_chroma_minus8: number;
    avgFrameRate: number;
    constantFrameRate: number;
    numTemporalLayers: number;
    temporalIdNested: number;
    lengthSizeMinusOne: number;
    nalu_arrays: NALUArrays;
    parse(stream: MultiBufferStream | DataStream): void;
    /** @bundle writing/write.js */
    write(stream: DataStream): void;
}

declare class vpcCBox extends FullBox {
    static readonly fourcc: "vpcC";
    box_name: "VPCodecConfigurationRecord";
    profile: number;
    level: number;
    bitDepth: number;
    chromaSubsampling: number;
    videoFullRangeFlag: number;
    colourPrimaries: number;
    transferCharacteristics: number;
    matrixCoefficients: number;
    codecIntializationDataSize: number;
    codecIntializationData: Uint8Array;
    colorSpace: number;
    transferFunction: number;
    parse(stream: MultiBufferStream): void;
}

declare class vvcCBox extends FullBox {
    static readonly fourcc: "vvcC";
    box_name: "VvcConfigurationBox";
    lengthSizeMinusOne: number;
    ptl_present_flag: number;
    ols_idx: number;
    num_sublayers: number;
    constant_frame_rate: number;
    chroma_format_idc: number;
    bit_depth_minus8: number;
    num_bytes_constraint_info: number;
    general_profile_idc: number;
    general_tier_flag: number;
    general_level_idc: number;
    ptl_frame_only_constraint_flag: number;
    ptl_multilayer_enabled_flag: number;
    general_constraint_info: Uint8Array;
    ptl_sublayer_present_mask: number;
    sublayer_level_idc: Array<number>;
    ptl_num_sub_profiles: number;
    general_sub_profile_idc: Array<number>;
    max_picture_width: number;
    max_picture_height: number;
    avg_frame_rate: number;
    nalu_arrays: Array<NaluArray>;
    parse(stream: MultiBufferStream): void;
}

declare class SampleEntry extends ContainerBox {
    hdr_size?: number;
    start?: number;
    static readonly registryId: unique symbol;
    data_reference_index?: number;
    constructor(size?: number, hdr_size?: number, start?: number);
    /** @bundle box-codecs.js */
    isVideo(): boolean;
    /** @bundle box-codecs.js */
    isAudio(): boolean;
    /** @bundle box-codecs.js */
    isSubtitle(): boolean;
    /** @bundle box-codecs.js */
    isMetadata(): boolean;
    /** @bundle box-codecs.js */
    isHint(): boolean;
    /** @bundle box-codecs.js */
    getCodec(): string;
    /** @bundle box-codecs.js */
    getWidth(): number;
    /** @bundle box-codecs.js */
    getHeight(): number;
    /** @bundle box-codecs.js */
    getChannelCount(): number;
    /** @bundle box-codecs.js */
    getSampleRate(): number;
    /** @bundle box-codecs.js */
    getSampleSize(): number;
    /** @bundle parsing/sampleentries/sampleentry.js */
    parseHeader(stream: MultiBufferStream): void;
    /** @bundle parsing/sampleentries/sampleentry.js */
    parse(stream: MultiBufferStream): void;
    /** @bundle parsing/sampleentries/sampleentry.js */
    parseDataAndRewind(stream: MultiBufferStream): void;
    /** @bundle parsing/sampleentries/sampleentry.js */
    parseFooter(stream: MultiBufferStream): void;
    /** @bundle writing/sampleentry.js */
    writeHeader(stream: MultiBufferStream): void;
    /** @bundle writing/sampleentry.js */
    writeFooter(stream: MultiBufferStream): void;
    /** @bundle writing/sampleentry.js */
    write(stream: MultiBufferStream): void;
}
declare class HintSampleEntry extends SampleEntry {
}
declare class MetadataSampleEntry extends SampleEntry {
    /** @bundle box-codecs.js */
    isMetadata(): boolean;
}
declare class SubtitleSampleEntry extends SampleEntry {
    /** @bundle box-codecs.js */
    isSubtitle(): boolean;
}
declare class TextSampleEntry extends SampleEntry {
}
declare class VisualSampleEntry extends SampleEntry {
    av1C?: av1CBox;
    avcC?: avcCBox;
    hvcC?: hvcCBox;
    vpcC?: vpcCBox;
    vvcC?: vvcCBox;
    width: number;
    height: number;
    horizresolution: number;
    vertresolution: number;
    frame_count: number;
    compressorname: string;
    depth: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle box-codecs.js */
    isVideo(): boolean;
    /** @bundle box-codecs.js */
    getWidth(): number;
    /** @bundle box-codecs.js */
    getHeight(): number;
    /** @bundle writing/sampleentries/sampleentry.js */
    write(stream: MultiBufferStream): void;
}
declare class AudioSampleEntry extends SampleEntry {
    version: number;
    channel_count: number;
    samplesize: number;
    samplerate: number;
    extensions: Uint8Array;
    parse(stream: MultiBufferStream): void;
    /** @bundle box-codecs.js */
    isAudio(): boolean;
    /** @bundle box-codecs.js */
    getChannelCount(): number;
    /** @bundle box-codecs.js */
    getSampleRate(): number;
    /** @bundle box-codecs.js */
    getSampleSize(): number;
    /** @bundle writing/sampleentry.js */
    write(stream: MultiBufferStream): void;
}
declare class SystemSampleEntry extends SampleEntry {
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/sampleentry.js */
    write(stream: MultiBufferStream): void;
}

declare class stsdBox extends FullBox {
    static readonly fourcc: "stsd";
    box_name: "SampleDescriptionBox";
    entries: Array<SampleEntry>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/stsd.js */
    write(stream: MultiBufferStream): void;
}

declare class stssBox extends FullBox {
    static readonly fourcc: "stss";
    box_name: "SyncSampleBox";
    sample_numbers: Array<number>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/stss.js */
    write(stream: MultiBufferStream): void;
}

declare class stszBox extends FullBox {
    static readonly fourcc: "stsz";
    box_name: "SampleSizeBox";
    sample_sizes: Array<number>;
    sample_size: number;
    sample_count: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/stsz.js */
    write(stream: MultiBufferStream): void;
    /** @bundle box-unpack.js */
    unpack(samples: any): void;
}

declare class sttsBox extends FullBox {
    static readonly fourcc: "stts";
    box_name: "TimeToSampleBox";
    sample_counts: Array<number>;
    sample_deltas: Array<number>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/stts.js */
    write(stream: MultiBufferStream): void;
    /** @bundle box-unpack.js */
    unpack(samples: Array<Sample>): void;
}

declare class stz2Box extends FullBox {
    static readonly fourcc: "stz2";
    box_name: "CompactSampleSizeBox";
    sample_sizes: Array<number>;
    reserved: number;
    field_size: number;
    parse(stream: MultiBufferStream): void;
}

interface SampleInfo {
    size: number;
    sample_delta: number;
    subsamples: Array<SubSample>;
}
declare class subsBox extends FullBox {
    static readonly fourcc: "subs";
    box_name: "SubSampleInformationBox";
    entries: Array<SampleInfo>;
    parse(stream: MultiBufferStream): void;
}

declare class tfdtBox extends FullBox {
    static readonly fourcc: "tfdt";
    box_name: "TrackFragmentBaseMediaDecodeTimeBox";
    baseMediaDecodeTime: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/tdft.js */
    write(stream: MultiBufferStream): void;
}

declare class tfhdBox extends FullBox {
    static readonly fourcc: "tfhd";
    box_name: "TrackFragmentHeaderBox";
    track_id: number;
    base_data_offset: number;
    default_sample_description_index: number;
    default_sample_duration: number;
    default_sample_size: number;
    default_sample_flags: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/tfhd.js */
    write(stream: any): void;
}

declare class tfraBox extends FullBox {
    static readonly fourcc: "tfra";
    box_name: "TrackFragmentRandomAccessBox";
    track_ID: number;
    length_size_of_traf_num: number;
    length_size_of_trun_num: number;
    length_size_of_sample_num: number;
    entries: Array<SampleEntry>;
    time: number;
    moof_offset: number;
    traf_number: number;
    trun_number: number;
    sample_number: number;
    parse(stream: MultiBufferStream): void;
}

declare class tkhdBox extends FullBox {
    static readonly fourcc: "tkhd";
    box_name: "TrackHeaderBox";
    creation_time: number;
    modification_time: number;
    track_id: number;
    duration: number;
    layer: number;
    alternate_group: number;
    volume: number;
    matrix: Matrix;
    width: number;
    height: number;
    parse(stream: MultiBufferStream): void;
    write(stream: MultiBufferStream): void;
    /** @bundle box-print.js */
    print(output: {
        log: (arg: string) => void;
        indent: string;
    }): void;
}

declare class trefBox extends Box {
    static readonly fourcc: "tref";
    box_name: "TrackReferenceBox";
    static allowed_types: readonly ["hint", "cdsc", "font", "hind", "vdep", "vplx", "subt", "thmb", "auxl", "cdtg", "shsc", "aest"];
    references: Array<TrackReferenceTypeBox>;
    parse(stream: MultiBufferStream): void;
}

declare class trexBox extends FullBox {
    static readonly fourcc: "trex";
    box_name: "TrackExtendsBox";
    track_id: number;
    default_sample_description_index: number;
    default_sample_duration: number;
    default_sample_size: number;
    default_sample_flags: number;
    parse(stream: MultiBufferStream): void;
    write(stream: MultiBufferStream): void;
}

declare class trunBox extends FullBox {
    static readonly fourcc: "trun";
    box_name: "TrackRunBox";
    sample_count: number;
    data_offset: number;
    first_sample_flags: number;
    sample_duration: Array<number>;
    sample_size: Array<number>;
    sample_flags: Array<number>;
    sample_composition_time_offset: Array<number>;
    data_offset_position: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/trun.js */
    write(stream: MultiBufferStream): void;
}

declare class tycoBox extends Box {
    static readonly fourcc: "tyco";
    box_name: "TypeCombinationBox";
    compatible_brands: Array<string>;
    parse(stream: MultiBufferStream): void;
}

declare class drefBox extends FullBox {
    static readonly fourcc: "dref";
    box_name: "DataReferenceBox";
    entries: Array<Box>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/dref.js */
    write(stream: MultiBufferStream): void;
}

declare class EntityToGroup extends FullBox {
    group_id: number;
    num_entities_in_group: number;
    entity_ids: Array<number>;
    parse(stream: MultiBufferStream): void;
}

declare class mfhdBox extends FullBox {
    static readonly fourcc: "mfhd";
    box_name: "MovieFragmentHeaderBox";
    sequence_number: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/mfhd.js */
    write(stream: MultiBufferStream): void;
}

declare class smhdBox extends FullBox {
    static readonly fourcc: "smhd";
    box_name: "SoundMediaHeaderBox";
    balance: number;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/smhd.js */
    write(stream: MultiBufferStream): void;
}

declare class sthdBox extends FullBox {
    static readonly fourcc: "sthd";
    box_name: "SubtitleMediaHeaderBox";
}

declare class vmhdBox extends FullBox {
    static readonly fourcc: "vmhd";
    box_name: "VideoMediaHeaderBox";
    graphicsmode: number;
    opcolor: Uint16Array | [number, number, number];
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/vmhd.js */
    write(stream: MultiBufferStream): void;
}

declare class ispeBox extends FullBox {
    static readonly fourcc: "ispe";
    box_name: "ImageSpatialExtentsProperty";
    image_width: number;
    image_height: number;
    parse(stream: MultiBufferStream): void;
}

declare class clapBox extends Box {
    static readonly fourcc: "clap";
    box_name: "CleanApertureBox";
    cleanApertureWidthN: number;
    cleanApertureWidthD: number;
    cleanApertureHeightN: number;
    cleanApertureHeightD: number;
    horizOffN: number;
    horizOffD: number;
    vertOffN: number;
    vertOffD: number;
    parse(stream: MultiBufferStream): void;
}

declare class irotBox extends Box {
    static readonly fourcc: "irot";
    box_name: "ImageRotation";
    angle: number;
    parse(stream: MultiBufferStream): void;
}

declare class maxrBox extends Box {
    static readonly fourcc: "maxr";
    box_name: "hintmaxrate";
    period: number;
    bytes: number;
    parse(stream: MultiBufferStream): void;
}

/**********************************************************************************/
/**********************************************************************************/
declare class mdatBox extends Box {
    static readonly fourcc: "mdat";
    box_name: "MediaDataBox";
    stream?: MultiBufferStream;
}
declare class idatBox extends Box {
    static readonly fourcc: "idat";
    box_name: "ItemDataBox";
}
declare class freeBox extends Box {
    static readonly fourcc: "free";
    box_name: "FreeSpaceBox";
}
declare class skipBox extends Box {
    static readonly fourcc: "skip";
    box_name: "FreeSpaceBox";
}
/**********************************************************************************/
/**********************************************************************************/
declare class hmhdBox extends FullBox {
    static readonly fourcc: "hmhd";
    box_name: "HintMediaHeaderBox";
}
declare class nmhdBox extends FullBox {
    static readonly fourcc: "nmhd";
    box_name: "NullMediaHeaderBox";
}
declare class iodsBox extends FullBox {
    static readonly fourcc: "iods";
    box_name: "ObjectDescriptorBox";
}
declare class xmlBox extends FullBox {
    static readonly fourcc: "xml ";
    box_name: "XMLBox";
}
declare class bxmlBox extends FullBox {
    static readonly fourcc: "bxml";
    box_name: "BinaryXMLBox";
}
declare class iproBox extends FullBox {
    static readonly fourcc: "ipro";
    box_name: "ItemProtectionBox";
    sinfs: Array<sinfBox>;
    get protections(): sinfBox[];
}
/**********************************************************************************/
/**********************************************************************************/
declare class moovBox extends ContainerBox {
    static readonly fourcc: "moov";
    box_name: "MovieBox";
    timescale: number;
    mvhd: mvhdBox;
    mvhds: Array<mvhdBox>;
    mvex?: mvexBox;
    mvexs: Array<mvexBox>;
    iods: iodsBox;
    iodss: Array<iodsBox>;
    trak: trakBox;
    traks: Array<trakBox>;
    psshs: Array<psshBox>;
    subBoxNames: readonly ["trak", "pssh"];
}
declare class trakBox extends ContainerBox {
    static readonly fourcc: "trak";
    box_name: "TrackBox";
    mdia: mdiaBox;
    mdias: Array<mdiaBox>;
    tkhd: tkhdBox;
    tkhds: Array<tkhdBox>;
    tref: trefBox;
    trefs: Array<trefBox>;
    edts?: edtsBox;
    edtss: Array<edtsBox>;
    udta: udtaBox;
    udtas: Array<udtaBox>;
    samples_duration: number;
    samples: Array<Sample>;
    samples_size: number;
    nextSample: number;
    lastValidSample: number;
    sample_groups_info: Array<SampleGroupInfo>;
    first_dts: number;
    first_traf_merged: boolean;
    has_fragment_subsamples: boolean;
}
declare class edtsBox extends ContainerBox {
    static readonly fourcc: "edts";
    box_name: "EditBox";
    elst?: elstBox;
    elsts: Array<elstBox>;
}
declare class mdiaBox extends ContainerBox {
    static readonly fourcc: "mdia";
    box_name: "MediaBox";
    elng: elngBox;
    elngs: Array<elngBox>;
    hdlr: hdlrBox;
    hdlrs: Array<hdlrBox>;
    mdhd: mdhdBox;
    mdhds: Array<mdhdBox>;
    minf: minfBox;
    minfs: Array<minfBox>;
}
declare class minfBox extends ContainerBox {
    static readonly fourcc: "minf";
    box_name: "MediaInformationBox";
    stbl: stblBox;
    stbls: Array<stblBox>;
    hmhd: hmhdBox;
    hmhds: Array<hmhdBox>;
    vmhd?: vmhdBox;
    vmhds?: Array<vmhdBox>;
    smhd?: smhdBox;
    smhds?: Array<smhdBox>;
    sthd?: sthdBox;
    sthds?: Array<sthdBox>;
    nmhd?: nmhdBox;
    nmhds?: Array<nmhdBox>;
    dinf: dinfBox;
    dinfs: Array<dinfBox>;
    dref: drefBox;
    drefs: Array<drefBox>;
}
declare class dinfBox extends ContainerBox {
    static readonly fourcc: "dinf";
    box_name: "DataInformationBox";
}
declare class stblBox extends ContainerBox {
    static readonly fourcc: "stbl";
    box_name: "SampleTableBox";
    cslg: cslgBox;
    cslgs: Array<cslgBox>;
    stsd: stsdBox;
    stsds: Array<stsdBox>;
    stsc: stscBox;
    stscs: Array<stscBox>;
    stco: stcoBox;
    stcos: Array<stcoBox>;
    co64: co64Box;
    co64s: Array<co64Box>;
    stsz: stszBox;
    stszs: Array<stszBox>;
    stz2: stz2Box;
    stz2s: Array<stz2Box>;
    stts: sttsBox;
    sttss: Array<sttsBox>;
    ctts: cttsBox;
    cttss: Array<cttsBox>;
    stss: stssBox;
    stsss: Array<stssBox>;
    subs: subsBox;
    subss: Array<subsBox>;
    stdp: stdpBox;
    stdps: Array<stdpBox>;
    sdtp: sdtpBox;
    sdtps: Array<sdtpBox>;
    sgpds: Array<sgpdBox>;
    sbgps: Array<sbgpBox>;
    subBoxNames: string[];
}
declare class mvexBox extends ContainerBox {
    static readonly fourcc: "mvex";
    box_name: "MovieExtendsBox";
    trex: trexBox;
    mehd: mehdBox;
    mehds: Array<mehdBox>;
    trexs: Array<trexBox>;
    subBoxNames: string[];
}
declare class moofBox extends ContainerBox {
    static readonly fourcc: "moof";
    box_name: "MovieFragmentBox";
    mfhd: mfhdBox;
    mfhds: Array<mfhdBox>;
    traf: trafBox;
    trafs: Array<trafBox>;
    subBoxNames: string[];
}
declare class trafBox extends ContainerBox {
    static readonly fourcc: "traf";
    box_name: "TrackFragmentBox";
    subs: subsBox;
    subss: Array<subsBox>;
    tfdt: tfdtBox;
    tfdts: Array<tfdtBox>;
    tfhd: tfhdBox;
    tfhds: Array<tfhdBox>;
    trun: trunBox;
    first_sample_index: number;
    sample_number: number;
    sample_groups_info: Array<SampleGroupInfo>;
    truns: Array<trunBox>;
    sgpds: Array<sgpdBox>;
    sbgps: Array<sbgpBox>;
    subBoxNames: string[];
}
declare class vttcBox extends ContainerBox {
    static readonly fourcc: "vttc";
    box_name: "VTTCueBox";
}
declare class mfraBox extends ContainerBox {
    static readonly fourcc: "mfra";
    box_name: "MovieFragmentRandomAccessBox";
    tfras: Array<tfraBox>;
    subBoxNames: readonly ["tfra"];
}
declare class mecoBox extends ContainerBox {
    static readonly fourcc: "meco";
    box_name: "AdditionalMetadataContainerBox";
}
declare class hntiBox extends ContainerBox {
    static readonly fourcc: "hnti";
    box_name: "trackhintinformation";
    subBoxNames: readonly ["sdp ", "rtp "];
}
declare class hinfBox extends ContainerBox {
    static readonly fourcc: "hinf";
    box_name: "hintstatisticsbox";
    maxrs: Array<maxrBox>;
    subBoxNames: readonly ["maxr"];
}
declare class strkBox extends ContainerBox {
    static readonly fourcc: "strk";
    box_name: "SubTrackBox";
}
declare class strdBox extends ContainerBox {
    static readonly fourcc: "strd";
    box_name: "SubTrackDefinitionBox";
}
declare class sinfBox extends ContainerBox {
    static readonly fourcc: "sinf";
    box_name: "ProtectionSchemeInfoBox";
}
declare class rinfBox extends ContainerBox {
    static readonly fourcc: "rinf";
    box_name: "RestrictedSchemeInfoBox";
}
declare class schiBox extends ContainerBox {
    static readonly fourcc: "schi";
    box_name: "SchemeInformationBox";
}
declare class trgrBox extends ContainerBox {
    static readonly fourcc: "trgr";
    box_name: "TrackGroupBox";
}
declare class udtaBox extends ContainerBox {
    static readonly fourcc: "udta";
    box_name: "UserDataBox";
    kinds: Array<kindBox>;
    strks: Array<strkBox>;
    subBoxNames: readonly ["kind", "strk"];
}
declare class iprpBox extends ContainerBox {
    static readonly fourcc: "iprp";
    box_name: "ItemPropertiesBox";
    ipco: ipcoBox;
    ipmas: Array<ipmaBox>;
    subBoxNames: readonly ["ipma"];
}
declare class ipcoBox extends ContainerBox {
    static readonly fourcc: "ipco";
    box_name: "ItemPropertyContainerBox";
    hvcCs: Array<hvcCBox>;
    ispes: Array<ispeBox>;
    claps: Array<clapBox>;
    irots: Array<irotBox>;
    subBoxNames: readonly ["hvcC", "ispe", "clap", "irot"];
}
declare class grplBox extends ContainerBox {
    static readonly fourcc: "grpl";
    box_name: "GroupsListBox";
    boxes: Array<EntityToGroup>;
}
declare class j2kHBox extends ContainerBox {
    static readonly fourcc: "j2kH";
    box_name: "J2KHeaderInfoBox";
}
declare class etypBox extends ContainerBox {
    static readonly fourcc: "etyp";
    box_name: "ExtendedTypeBox";
    tycos: Array<tycoBox>;
    subBoxNames: readonly ["tyco"];
}
declare class povdBox extends ContainerBox {
    static readonly fourcc: "povd";
    box_name: "ProjectedOmniVideoBox";
    subBoxNames: readonly ["prfr"];
}

declare class ftypBox extends Box {
    static readonly fourcc: "ftyp";
    box_name: "FileTypeBox";
    major_brand: string;
    minor_version: number;
    compatible_brands: Array<string>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/ftyp.js */
    write(stream: MultiBufferStream | DataStream): void;
}

declare class infeBox extends FullBox {
    static readonly fourcc: "infe";
    box_name: "ItemInfoEntry";
    item_ID: number;
    item_protection_index: number;
    item_name: string;
    content_type: string;
    content_encoding: string;
    extension_type: string;
    item_type: string;
    item_uri_type: string;
    parse(stream: MultiBufferStream): void;
}

declare class iinfBox extends FullBox {
    static readonly fourcc: "iinf";
    box_name: "ItemInfoBox";
    version: number;
    entry_count: number;
    item_infos: Array<infeBox>;
    parse(stream: MultiBufferStream): void;
}

interface Extent {
    extent_index: number;
    extent_offset: number;
    extent_length: number;
}
declare class ilocBox extends FullBox {
    static readonly fourcc: "iloc";
    box_name: "ItemLocationBox";
    offset_size: number;
    length_size: number;
    base_offset_size: number;
    index_size: number;
    items: Array<{
        base_offset: number;
        construction_method: number;
        item_ID: number;
        data_reference_index: number;
        extents: Array<Extent>;
    }>;
    parse(stream: MultiBufferStream): void;
}

declare class irefBox extends FullBox {
    static readonly fourcc: "iref";
    box_name: "ItemReferenceBox";
    static allowed_types: readonly ["auxl", "base", "cdsc", "dimg", "dpnd", "eroi", "evir", "exbl", "fdl ", "font", "iloc", "mask", "mint", "pred", "prem", "tbas", "text", "thmb"];
    references: Array<SingleItemTypeReferenceBox | SingleItemTypeReferenceBoxLarge>;
    version: number;
    parse(stream: MultiBufferStream): void;
}

declare class pitmBox extends FullBox {
    static readonly fourcc: "pitm";
    box_name: "PrimaryItemBox";
    item_id: number;
    parse(stream: MultiBufferStream): void;
}

declare class metaBox extends FullBox {
    static readonly fourcc: "meta";
    box_name: "MetaBox";
    isQT: boolean;
    hdlr: hdlrBox;
    hdlrs: Array<hdlrBox>;
    iinf: iinfBox;
    iinfs: Array<iinfBox>;
    idat: idatBox;
    idats: Array<idatBox>;
    ipro: iproBox;
    ipros: Array<iproBox>;
    grpl: grplBox;
    grpls: Array<grplBox>;
    iloc: ilocBox;
    ilocs: Array<ilocBox>;
    iprp: iprpBox;
    iprps: Array<iprpBox>;
    pitm: pitmBox;
    pitms: Array<pitmBox>;
    iref: irefBox;
    irefs: Array<irefBox>;
    dinf: dinfBox;
    dinfs: Array<dinfBox>;
    parse(stream: MultiBufferStream): void;
}

interface Reference$1 {
    reference_type: number;
    referenced_size: number;
    subsegment_duration: number;
    starts_with_SAP: number;
    SAP_type: number;
    SAP_delta_time: number;
}
declare class sidxBox extends FullBox {
    static readonly fourcc: "sidx";
    box_name: "CompressedSegmentIndexBox";
    reference_ID: number;
    timescale: number;
    earliest_presentation_time: number;
    first_offset: number;
    references: Array<Reference$1>;
    parse(stream: MultiBufferStream): void;
    /** @bundle writing/sidx.js */
    write(stream: MultiBufferStream): void;
}

declare function parseOneBox(stream: MultiBufferStream, headerOnly: boolean, parentSize?: number): IncompleteBox;

declare class SampleGroupInfo {
    grouping_type: string;
    grouping_type_parameter: number;
    sbgp?: sbgpBox;
    last_sample_in_run: number;
    entry_index: number;
    description: Description;
    fragment_description: Description;
    is_fragment: boolean;
    constructor(grouping_type: string, grouping_type_parameter: number, sbgp?: sbgpBox);
}
interface IsoFileOptions {
    brands?: Array<string>;
    description_boxes?: Array<BoxKind>;
    duration?: number;
    height?: number;
    id?: number;
    language?: string;
    layer?: number;
    media_duration?: number;
    rate?: number;
    timescale?: number;
    type?: SampleEntryFourCC;
    width?: number;
    hdlr?: string;
    name?: string;
    hevcDecoderConfigRecord?: ArrayBuffer;
    avcDecoderConfigRecord?: ArrayBuffer;
    balance?: number;
    channel_count?: number;
    samplesize?: number;
    samplerate?: number;
    namespace?: string;
    schema_location?: string;
    auxiliary_mime_types?: string;
    description?: Box;
    default_sample_description_index?: number;
    default_sample_duration?: number;
    default_sample_size?: number;
    default_sample_flags?: number;
}
declare class ISOFile<TSegmentUser = unknown, TSampleUser = unknown> {
    /** MutiBufferStream object used to parse boxes */
    stream: MultiBufferStream;
    /** Array of all boxes (in order) found in the file */
    boxes: Array<Box>;
    /** Array of all mdats */
    mdats: Array<mdatBox>;
    /** Array of all moofs */
    moofs: Array<moofBox>;
    /** Boolean indicating if the file is compatible with progressive parsing (moov first) */
    isProgressive: boolean;
    /** Boolean used to fire moov start event only once */
    moovStartFound: boolean;
    /** Callback called when the moov parsing starts */
    onMoovStart?: () => void;
    /** Boolean keeping track of the call to onMoovStart, to avoid double calls */
    moovStartSent: boolean;
    /** Callback called when the moov is entirely parsed */
    onReady?: (info: Movie) => void;
    /** Boolean keeping track of the call to onReady, to avoid double calls */
    readySent: boolean;
    /** Callback to call when segments are ready */
    onSegment?: (id: number, user: TSegmentUser, buffer: ArrayBuffer, nextSample: number, last: boolean) => void;
    /** Callback to call when samples are ready */
    onSamples?: (id: number, user: TSampleUser, samples: Array<Sample>) => void;
    /** Callback to call when there is an error in the parsing or processing of samples */
    onError?: (module: string, message: string) => void;
    /** Callback to call when an item is processed */
    onItem?: () => void;
    /** Boolean indicating if the moov box run-length encoded tables of sample information have been processed */
    sampleListBuilt: boolean;
    /** Array of Track objects for which fragmentation of samples is requested */
    fragmentedTracks: Array<FragmentedTrack<TSegmentUser>>;
    /** Array of Track objects for which extraction of samples is requested */
    extractedTracks: Array<ExtractedTrack<TSampleUser>>;
    /** Boolean indicating that fragmention is ready */
    isFragmentationInitialized: boolean;
    /** Boolean indicating that fragmented has started */
    sampleProcessingStarted: boolean;
    /** Number of the next 'moof' to generate when fragmenting */
    nextMoofNumber: number;
    /** Boolean indicating if the initial list of items has been produced */
    itemListBuilt: boolean;
    /** Callback called when the sidx box is entirely parsed */
    onSidx?: (sidx: sidxBox) => void;
    /** Boolean keeping track of the call to onSidx, to avoid double calls */
    sidxSent: boolean;
    /** @bundle isofile-item-processing.js */
    items: Array<Item>;
    /** @bundle isofile-item-processing.js */
    entity_groups: Array<EntityGroup>;
    /**
     * size of the buffers allocated for samples
     * @bundle isofile-item-processing.js
     */
    itemsDataSize: number;
    moov: moovBox;
    moovs: Array<moovBox>;
    sidx: sidxBox;
    sidxs: Array<sidxBox>;
    meta: metaBox;
    metas: Array<metaBox>;
    ftyp: ftypBox;
    ftyps: Array<ftypBox>;
    nextSeekPosition: number;
    initial_duration: number;
    constructor(stream?: MultiBufferStream, discardMdatData?: boolean);
    setSegmentOptions(id: number, user: TSegmentUser, opts: Partial<{
        nbSamples: number;
        nbSamplesPerFragment: number;
        sizePerSegment: number;
        rapAlignement: boolean;
    }>): void;
    unsetSegmentOptions(id: number): void;
    setExtractionOptions(id: number, user?: TSampleUser, { nbSamples: nb_samples }?: {
        nbSamples?: number;
    }): void;
    unsetExtractionOptions(id: number): void;
    parse(): void;
    checkBuffer(ab?: MP4BoxBuffer): boolean;
    /**
     * Processes a new ArrayBuffer (with a fileStart property)
     * Returns the next expected file position, or undefined if not ready to parse
     */
    appendBuffer(ab: MP4BoxBuffer, last?: boolean): number;
    getFragmentDuration(): {
        num: number;
        den: number;
    };
    getInfo(): Movie;
    setNextSeekPositionFromSample(sample: Sample): void;
    processSamples(last?: boolean): void;
    getBox<T extends AllIdentifiers>(type: T): AllRegisteredBoxes[T] | undefined;
    getBoxes<T extends AllIdentifiers>(type: T, returnEarly: boolean): AllRegisteredBoxes[T][];
    getTrackSamplesInfo(track_id: number): Sample[];
    getTrackSample(track_id: number, number: number): Sample;
    releaseUsedSamples(id: number, sampleNum: number): void;
    start(): void;
    stop(): void;
    flush(): void;
    seekTrack(time: number, useRap: boolean, trak: trakBox): {
        offset: number;
        time: number;
    };
    getTrackDuration(trak: trakBox): number;
    seek(time: number, useRap: boolean): {
        offset: number;
        time: number;
    };
    equal(b: {
        boxes: Array<Box>;
    }): boolean;
    /**
     * Rewrite the entire file
     * @bundle isofile-write.js
     */
    write(outstream: DataStream): void;
    /** @bundle isofile-write.js */
    createFragment(track_id: number, sampleStart: number, sampleEnd: number, existingStream: DataStream): DataStream;
    /**
     * Modify the file and create the initialization segment
     * @bundle isofile-write.js
     */
    static writeInitializationSegment(ftyp: ftypBox, moov: moovBox, total_duration: number): MP4BoxBuffer;
    /** @bundle isofile-write.js */
    save(name: string): Blob;
    /** @bundle isofile-write.js */
    getBuffer(): DataStream;
    /** @bundle isofile-write.js */
    initializeSegmentation(): {
        tracks: {
            id: number;
            user: TSegmentUser;
        }[];
        buffer: MP4BoxBuffer;
    };
    /**
     * Index of the last moof box received
     * @bundle isofile-sample-processing.js
     */
    lastMoofIndex: number;
    /**
     * size of the buffers allocated for samples
     * @bundle isofile-sample-processing.js
     */
    samplesDataSize: number;
    /**
     * Resets all sample tables
     * @bundle isofile-sample-processing.js
     */
    resetTables(): void;
    /** @bundle isofile-sample-processing.js */
    static initSampleGroups(trak: trakBox, traf: trafBox | undefined, sbgps: Array<sbgpBox>, trak_sgpds: Array<sgpdBox>, traf_sgpds?: Array<sgpdBox>): void;
    /** @bundle isofile-sample-processing.js */
    static setSampleGroupProperties(trak: trakBox, sample: Sample, sample_number: number, sample_groups_info: Array<SampleGroupInfo>): void;
    /** @bundle isofile-sample-processing.js */
    static process_sdtp(sdtp: sdtpBox, sample: Sample, number: number): void;
    buildSampleLists(): void;
    buildTrakSampleLists(trak: trakBox): void;
    /**
     * Update sample list when new 'moof' boxes are received
     * @bundle isofile-sample-processing.js
     */
    updateSampleLists(): void;
    /**
     * Try to get sample data for a given sample:
     * returns null if not found
     * returns the same sample if already requested
     *
     * @bundle isofile-sample-processing.js
     */
    getSample(trak: trakBox, sampleNum: number): Sample;
    /**
     * Release the memory used to store the data of the sample
     *
     * @bundle isofile-sample-processing.js
     */
    releaseSample(trak: trakBox, sampleNum: number): number;
    /** @bundle isofile-sample-processing.js */
    getAllocatedSampleDataSize(): number;
    /**
     * Builds the MIME Type 'codecs' sub-parameters for the whole file
     *
     * @bundle isofile-sample-processing.js
     */
    getCodecs(): string;
    /**
     * Helper function
     *
     * @bundle isofile-sample-processing.js
     */
    getTrexById(id: number): trexBox;
    /**
     * Helper function
     *
     * @bundle isofile-sample-processing.js
     */
    getTrackById(id: number): trakBox;
    /** @bundle isofile-item-processing.js */
    flattenItemInfo(): void;
    /** @bundle isofile-item-processing.js */
    getItem(item_id: number): Item;
    /**
     * Release the memory used to store the data of the item
     *
     * @bundle isofile-item-processing.js
     */
    releaseItem(item_id: number): number;
    /** @bundle isofile-item-processing.js */
    processItems(callback: (item: Item) => void): void;
    /** @bundle isofile-item-processing.js */
    hasItem(name: string): number;
    /** @bundle isofile-item-processing.js */
    getMetaHandler(): string;
    /** @bundle isofile-item-processing.js */
    getPrimaryItem(): Item;
    /** @bundle isofile-item-processing.js */
    itemToFragmentedTrackFile({ itemId }?: {
        itemId?: number;
    }): ISOFile<unknown, unknown>;
    /**
     * position in the current buffer of the beginning of the last box parsed
     *
     * @bundle isofile-advanced-parsing.js
     */
    lastBoxStartPosition: number;
    /**
     * indicator if the parsing is stuck in the middle of an mdat box
     *
     * @bundle isofile-advanced-parsing.js
     */
    parsingMdat?: mdatBox;
    nextParsePosition: number;
    /**
     * keep mdat data
     *
     * @bundle isofile-advanced-parsing.js
     */
    discardMdatData: boolean;
    /** @bundle isofile-advanced-parsing.js */
    processIncompleteBox(ret: IncompleteBox): boolean;
    /** @bundle isofile-advanced-parsing.js */
    hasIncompleteMdat(): boolean;
    /**
     * Transfer the data of the mdat box to its stream
     * @param mdat the mdat box to use
     */
    transferMdatData(inMdat?: mdatBox): void;
    /** @bundle isofile-advanced-parsing.js */
    processIncompleteMdat(): boolean;
    /** @bundle isofile-advanced-parsing.js */
    restoreParsePosition(): boolean;
    /** @bundle isofile-advanced-parsing.js */
    saveParsePosition(): void;
    /** @bundle isofile-advanced-parsing.js */
    updateUsedBytes(box: Box, _ret: ReturnType<typeof parseOneBox>): void;
    /** @bundle isofile-advanced-creation.js */
    addBox<T extends Box>(box: T): T;
    /** @bundle isofile-advanced-creation.js */
    init(options?: IsoFileOptions): this;
    /** @bundle isofile-advanced-creation.js */
    addTrack(_options?: IsoFileOptions): number;
    /** @bundle isofile-advanced-creation.js */
    addSample(track_id: number, data: Uint8Array<ArrayBuffer>, { sample_description_index, duration, cts, dts, is_sync, is_leading, depends_on, is_depended_on, has_redundancy, degradation_priority, subsamples, offset, }?: {
        sample_description_index?: number;
        duration?: number;
        cts?: number;
        dts?: number;
        is_sync?: boolean;
        is_leading?: number;
        depends_on?: number;
        is_depended_on?: number;
        has_redundancy?: number;
        degradation_priority?: number;
        subsamples?: Array<SubSample>;
        offset?: number;
    }): Sample;
    /** @bundle isofile-advanced-creation.js */
    createMoof(samples: Array<Sample>): moofBox;
    /** @bundle box-print.js */
    print(output: Output): void;
}

type ReadTypeReturnValue = string | number | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | Array<ReadTypeReturnValue> | {
    [key: string]: ReadTypeReturnValue;
};
declare enum Endianness {
    BIG_ENDIAN = 1,
    LITTLE_ENDIAN = 2
}
declare class DataStream {
    #private;
    static ENDIANNESS: Endianness;
    isofile?: ISOFile;
    _buffer?: MP4BoxBuffer;
    _byteOffset?: number;
    _dataView?: DataView<ArrayBuffer>;
    endianness: Endianness;
    protected position: number;
    /**
     * DataStream reads scalars, arrays and structs of data from an ArrayBuffer.
     * It's like a file-like DataView on steroids.
     *
     * @param arrayBuffer ArrayBuffer to read from.
     * @param byteOffset Offset from arrayBuffer beginning for the DataStream.
     * @param endianness Endianness of the DataStream (default: BIG_ENDIAN).
     */
    constructor(arrayBuffer?: ArrayBuffer | DataView<ArrayBuffer> | number, byteOffset?: number, endianness?: Endianness);
    getPosition(): number;
    /**
     * Internal function to resize the DataStream buffer when required.
     * @param extra Number of bytes to add to the buffer allocation.
     */
    _realloc(extra: number): void;
    /**
     * Internal function to trim the DataStream buffer when required.
     * Used for stripping out the extra bytes from the backing buffer when
     * the virtual byteLength is smaller than the buffer byteLength (happens after
     * growing the buffer with writes and not filling the extra space completely).
     */
    _trimAlloc(): void;
    /**
     * Virtual byte length of the DataStream backing buffer.
     * Updated to be max of original buffer size and last written size.
     * If dynamicSize is false is set to buffer size.
     */
    _byteLength: number;
    /**
     * Returns the byte length of the DataStream object.
     * @type {number}
     */
    get byteLength(): number;
    /**
     * Set/get the backing ArrayBuffer of the DataStream object.
     * The setter updates the DataView to point to the new buffer.
     * @type {Object}
     */
    get buffer(): MP4BoxBuffer;
    set buffer(value: MP4BoxBuffer);
    /**
     * Set/get the byteOffset of the DataStream object.
     * The setter updates the DataView to point to the new byteOffset.
     * @type {number}
     */
    get byteOffset(): number;
    set byteOffset(value: number);
    /**
     * Set/get the byteOffset of the DataStream object.
     * The setter updates the DataView to point to the new byteOffset.
     * @type {number}
     */
    get dataView(): DataView<ArrayBuffer>;
    set dataView(value: DataView<ArrayBuffer>);
    /**
     *   Sets the DataStream read/write position to given position.
     *   Clamps between 0 and DataStream length.
     *
     *   @param pos Position to seek to.
     *   @return
     */
    seek(pos: number): void;
    /**
     * Returns true if the DataStream seek pointer is at the end of buffer and
     * there's no more data to read.
     *
     * @return True if the seek pointer is at the end of the buffer.
     */
    isEof(): boolean;
    /**
     * Maps a Uint8Array into the DataStream buffer.
     *
     * Nice for quickly reading in data.
     *
     * @param length Number of elements to map.
     * @param e Endianness of the data to read.
     * @return Uint8Array to the DataStream backing buffer.
     */
    mapUint8Array(length: number): Uint8Array<MP4BoxBuffer>;
    /**
     * Reads an Int32Array of desired length and endianness from the DataStream.
     *
     * @param length Number of elements to map.
     * @param endianness Endianness of the data to read.
     * @return The read Int32Array.
     */
    readInt32Array(length?: number, endianness?: Endianness): Int32Array<ArrayBuffer>;
    /**
     * Reads an Int16Array of desired length and endianness from the DataStream.
     *
     * @param length Number of elements to map.
     * @param endianness Endianness of the data to read.
     * @return The read Int16Array.
     */
    readInt16Array(length?: number, endianness?: Endianness): Int16Array<ArrayBuffer>;
    /**
     * Reads an Int8Array of desired length from the DataStream.
     *
     * @param length Number of elements to map.
     * @param e Endianness of the data to read.
     * @return The read Int8Array.
     */
    readInt8Array(length?: number): Int8Array<ArrayBuffer>;
    /**
     * Reads a Uint32Array of desired length and endianness from the DataStream.
     *
     *  @param length Number of elements to map.
     *  @param endianness Endianness of the data to read.
     *  @return The read Uint32Array.
     */
    readUint32Array(length?: number, endianness?: Endianness): Uint32Array<ArrayBuffer>;
    /**
     * Reads a Uint16Array of desired length and endianness from the DataStream.
     *
     * @param length Number of elements to map.
     * @param endianness Endianness of the data to read.
     * @return The read Uint16Array.
     */
    readUint16Array(length?: number, endianness?: Endianness): Uint16Array<ArrayBuffer>;
    /**
     * Reads a Uint8Array of desired length from the DataStream.
     *
     * @param length Number of elements to map.
     * @param e Endianness of the data to read.
     * @return The read Uint8Array.
     */
    readUint8Array(length?: number): Uint8Array<ArrayBuffer>;
    /**
     * Reads a Float64