mp4box.d.ts

// Generated by dts-bundle-generator v9.5.1

declare class AudioSampleEntry extends SampleEntry {
	channel_count: number;
	samplesize: number;
	samplerate: number;
	constructor(type: string, size?: number);
	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 BoxBase {
	type: string;
	size: number;
	uuid?: string;
	boxes: Array<BoxBase>;
	data: Array<number> | Uint8Array;
	hdr_size?: number;
	language: number;
	languageString?: string;
	sizePosition?: number;
	start?: number;
	track_ids?: Uint32Array;
	constructor(type: string, size?: number, uuid?: string);
	addBox<T extends Box>(box: T): T;
	set<TProp extends keyof this>(prop: TProp, value: this[TProp]): this;
	addEntry(value: Box, _prop?: string): this;
	/** @bundle box-write.js */
	writeHeader(stream: DataStream, msg?: string): void;
	/** @bundle box-write.js */
	write(stream: DataStream): void;
	/** @bundle box-print.js */
	printHeader(output: Output): void;
	/** @bundle box-print.js */
	print(output: Output): void;
	/** @bundle box-parse.js */
	parse(stream: MultiBufferStream): void;
	/** @bundle box-parse.js */
	parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
	/** @bundle box-parse.js */
	parseLanguage(stream: MultiBufferStream): void;
	/** @bundle isofile-advanced-creation.js */
	computeSize(stream_?: MultiBufferStream): void;
}
declare class CoLLBox extends FullBox {
	maxCLL: number;
	maxFALL: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class ColorPoint {
	x: number;
	y: number;
	constructor(x: number, y: number);
	toString(): string;
}
declare class DecoderConfigDescriptor extends Descriptor {
	avgBitrate: number;
	bufferSize: number;
	maxBitrate: number;
	oti: number;
	streamType: number;
	upStream: boolean;
	constructor(size: number);
	parse(stream: MultiBufferStream): void;
}
declare class DecoderSpecificInfo extends Descriptor {
	constructor(size: number);
}
declare class EntityToGroup extends FullBox {
	group_id: number;
	num_entities_in_group: number;
	entity_ids: Array<number>;
	parse(stream: MultiBufferStream): void;
}
declare class FullBoxBase extends BoxBase {
	flags: number;
	version: number;
	/** @bundle box-write.js */
	writeHeader(stream: MultiBufferStream): void;
	/** @bundle box-print.js */
	printHeader(output: Output): void;
	/** @bundle box-parse.js */
	parseDataAndRewind(stream: MultiBufferStream): void;
	/** @bundle box-parse.js */
	parseFullHeader(stream: MultiBufferStream): void;
	/** @bundle box-parse.js */
	parse(stream: MultiBufferStream): void;
}
declare class HintSampleEntry extends SampleEntry {
	constructor(type: string, size?: number);
}
declare class MetadataSampleEntry extends SampleEntry {
	constructor(type: string, size?: number);
	/** @bundle box-codecs.js */
	isMetadata(): boolean;
}
declare class OpusSampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class Pixel {
	bad_pixel_row: number;
	bad_pixel_column: number;
	constructor(bad_pixel_row: number, bad_pixel_column: number);
	toString(): string;
}
declare class SLConfigDescriptor extends Descriptor {
	constructor(size: number);
}
declare class SampleEntryBase extends ContainerBoxBase {
	hdr_size?: number;
	start?: number;
	data_reference_index?: number;
	constructor(type: string, 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 SmDmBox extends FullBox {
	primaryRChromaticity_x: number;
	primaryRChromaticity_y: number;
	primaryGChromaticity_x: number;
	primaryGChromaticity_y: number;
	primaryBChromaticity_x: number;
	primaryBChromaticity_y: number;
	whitePointChromaticity_x: number;
	whitePointChromaticity_y: number;
	luminanceMax: number;
	luminanceMin: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class SubtitleSampleEntry extends SampleEntry {
	constructor(type: string, size?: number);
	/** @bundle box-codecs.js */
	isSubtitle(): boolean;
}
declare class SystemSampleEntry extends SampleEntry {
	constructor(type: string, size?: number);
}
declare class TextSampleEntry extends SampleEntry {
	constructor(type: string, size?: number);
}
declare class VisualSampleEntry extends SampleEntry {
	width: number;
	height: number;
	horizresolution: number;
	vertresolution: number;
	frame_count: number;
	compressorname: string;
	depth: number;
	constructor(type: string, size?: 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 a1lxBox extends Box {
	layer_size: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class a1opBox extends Box {
	op_index: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class ac_3SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class ac_4SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class aebrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class afbrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class albcBox extends EntityToGroup {
	constructor(size?: number);
}
declare class alstSampleGroupEntry extends SampleGroupEntry {
	first_output_sample: number;
	sample_offset: Array<number>;
	num_output_samples: Array<number>;
	num_total_samples: Array<number>;
	parse(stream: MultiBufferStream): void;
}
declare class altrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class auxCBox extends FullBox {
	aux_type: string;
	aux_subtype: Uint8Array;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class av01SampleEntry extends VisualSampleEntry {
	av1C: av1CBox;
	constructor(size?: number);
	/** @bundle box-codecs.js */
	getCodec(): string;
}
declare class av1CBox extends Box {
	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;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class avc1SampleEntry extends avcCSampleEntryBase {
	constructor(size?: number);
}
declare class avc2SampleEntry extends avcCSampleEntryBase {
	constructor(size?: number);
}
declare class avc3SampleEntry extends avcCSampleEntryBase {
	constructor(size?: number);
}
declare class avc4SampleEntry extends avcCSampleEntryBase {
	constructor(size?: number);
}
declare class avcCBox extends Box {
	configurationVersion: number;
	AVCProfileIndication: number;
	profile_compatibility: number;
	AVCLevelIndication: number;
	lengthSizeMinusOne: number;
	nb_SPS_nalus: number;
	SPS: Array<{
		length: number;
		nalu: Uint8Array;
	}>;
	nb_PPS_nalus: number;
	PPS: Array<{
		length: number;
		nalu: Uint8Array;
	}>;
	ext: Uint8Array;
	constructor(size?: number);
	parse(stream: DataStream | MP4BoxStream): void;
	/** @bundle writing/avcC.js */
	write(stream: MultiBufferStream): void;
}
declare class avcCSampleEntryBase extends VisualSampleEntry {
	avcC: avcCBox;
	/** @bundle box-codecs.js */
	getCodec(): string;
}
declare class avllSampleGroupEntry extends SampleGroupEntry {
	layerNumber: number;
	accurateStatisticsFlag: number;
	avgBitRate: number;
	avgFrameRate: number;
	parse(stream: MultiBufferStream): void;
}
declare class avs3SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class avssSampleGroupEntry extends SampleGroupEntry {
	subSequenceIdentifier: number;
	layerNumber: number;
	durationFlag: number;
	avgRateFlag: number;
	duration: number;
	accurateStatisticsFlag: number;
	avgBitRate: number;
	avgFrameRate: number;
	dependency: Array<{
		subSeqDirectionFlag: number;
		layerNumber: number;
		subSequenceIdentifier: number;
	}>;
	parse(stream: MultiBufferStream): void;
}
declare class brstBox extends EntityToGroup {
	constructor(size?: number);
}
declare class btrtBox extends Box {
	bufferSizeDB: number;
	maxBitrate: number;
	avgBitrate: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class bxmlBox extends FullBox {
	constructor(size?: number);
}
declare class ccstBox extends FullBox {
	all_ref_pics_intra: boolean;
	intra_pred_used: boolean;
	max_ref_per_pic: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class cdefBox extends Box {
	channel_count: number;
	channel_indexes: Array<number>;
	channel_types: Array<number>;
	channel_associations: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class clapBox extends Box {
	cleanApertureWidthN: number;
	cleanApertureWidthD: number;
	cleanApertureHeightN: number;
	cleanApertureHeightD: number;
	horizOffN: number;
	horizOffD: number;
	vertOffN: number;
	vertOffD: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class clefBox extends FullBox {
	width: number;
	height: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class clliBox extends Box {
	max_content_light_level: number;
	max_pic_average_light_level: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class cmexBox extends Box {
	flags: number;
	pos_x: number;
	pos_y: number;
	pos_z: number;
	version: number;
	quat_x: number;
	quat_y: number;
	quat_z: number;
	id: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class cminBox extends Box {
	focal_length_x: number;
	principal_point_x: number;
	principal_point_y: number;
	flags: number;
	focal_length_y: number;
	skew_factor: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class cmpdBox extends Box {
	component_count: number;
	component_types: Array<number>;
	component_type_urls: Array<string>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class co64Box extends FullBox {
	chunk_offsets: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/co64.js */
	write(stream: MultiBufferStream): void;
}
declare class colrBox extends Box {
	colour_type: string;
	colour_primaries: number;
	transfer_characteristics: number;
	matrix_coefficients: number;
	full_range_flag: number;
	ICC_profile: Uint8Array;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class cprtBox extends FullBox {
	notice: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class cslgBox extends FullBox {
	compositionToDTSShift: number;
	leastDecodeToDisplayDelta: number;
	greatestDecodeToDisplayDelta: number;
	compositionStartTime: number;
	compositionEndTime: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/cslg.js */
	write(stream: MultiBufferStream): void;
}
declare class cttsBox extends FullBox {
	sample_counts: Array<number>;
	sample_offsets: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/ctts.js */
	write(stream: MultiBufferStream): void;
	/** @bundle box-unpack.js */
	unpack(samples: Array<Sample>): void;
}
declare class dOpsBox extends Box {
	Version: number;
	OutputChannelCount: number;
	PreSkip: number;
	InputSampleRate: number;
	OutputGain: number;
	ChannelMappingFamily: number;
	StreamCount: number;
	CoupledCount: number;
	ChannelMapping: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dac3Box extends Box {
	fscod: number;
	bsid: number;
	bsmod: number;
	acmod: number;
	lfeon: number;
	bit_rate_code: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dav1SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class dec3Box extends Box {
	data_rate: number;
	num_ind_sub: number;
	ind_subs: Array<IndSub>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dfLaBox extends FullBox {
	samplerate: number;
	numMetadataBlocks: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dimmBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dinfBox extends ContainerBox {
	constructor(size?: number);
}
declare class dmax extends Box {
	time: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dmedBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dobrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class drefBox extends FullBox {
	entries: Array<Box>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/dref.js */
	write(stream: MultiBufferStream): void;
}
declare class drepBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class dtrtSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class dvh1SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class dvheSampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class ec_3SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class edtsBox extends ContainerBox {
	elst: elstBox;
	constructor(size?: number);
}
declare class elngBox extends FullBox {
	extended_language: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/elng.js */
	write(stream: MultiBufferStream): void;
}
declare class elstBox extends FullBox {
	entries: Entry[];
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/elst.js */
	write(stream: MultiBufferStream): void;
}
declare class emsgBox extends FullBox {
	timescale: number;
	presentation_time: number;
	event_duration: number;
	id: number;
	scheme_id_uri: string;
	value: string;
	presentation_time_delta: number;
	message_data: Uint8Array;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/emsg.js */
	write(stream: MultiBufferStream): void;
}
declare class encaSampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class encmSampleEntry extends MetadataSampleEntry {
	sinfs: Array<sinfBox>;
	subBoxNames: readonly [
		"sinf"
	];
	constructor(size?: number);
}
declare class encsSampleEntry extends SystemSampleEntry {
	sinfs: Array<sinfBox>;
	subBoxNames: readonly [
		"sinf"
	];
	constructor(size?: number);
}
declare class enctSampleEntry extends TextSampleEntry {
	sinfs: Array<sinfBox>;
	subBoxNames: readonly [
		"sinf"
	];
	constructor(size?: number);
}
declare class encuSampleEntry extends SubtitleSampleEntry {
	sinfs: Array<sinfBox>;
	subBoxNames: readonly [
		"sinf"
	];
	constructor(size?: number);
}
declare class encvSampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class enofBox extends FullBox {
	width: number;
	height: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class eqivBox extends EntityToGroup {
	constructor(size?: number);
}
declare class esdsBox extends FullBox {
	esd: ES_Descriptor;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class etypBox extends ContainerBox {
	tycos: Array<tycoBox>;
	subBoxNames: readonly [
		"tyco"
	];
	constructor(size?: number);
}
declare class fLaCSampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class favcBox extends EntityToGroup {
	constructor(size?: number);
}
declare class fielBox extends Box {
	fieldCount: number;
	fieldOrdering: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class fobrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class freeBox extends Box {
	constructor(size?: number);
}
declare class frmaBox extends Box {
	data_format: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class ftypBox extends Box {
	major_brand: string;
	minor_version: number;
	compatible_brands: Array<string>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/ftyp.js */
	write(stream: MultiBufferStream): void;
}
declare class grplBox extends ContainerBox {
	constructor(size?: number);
}
declare class hdlrBox extends Box {
	version: number;
	handler: string;
	name: string;
	flags: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/hldr.js */
	write(stream: MultiBufferStream): void;
}
declare class hev1SampleEntry extends hvcCSampleEntryBase {
	constructor(size?: number);
}
declare class hinfBox extends ContainerBox {
	constructor(size?: number);
}
declare class hmhdBox extends FullBox {
	constructor(size?: number);
}
declare class hntiBox extends ContainerBox {
	constructor(size?: number);
}
declare class hvc1SampleEntry extends hvcCSampleEntryBase {
	constructor(size?: number);
}
declare class hvcCBox extends Box {
	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: Array<NaluArray$1>;
	constructor(size?: number);
	parse(stream: DataStream | MP4BoxStream): void;
	/** @bundle writing/write.js */
	write(stream: DataStream): void;
}
declare class hvcCSampleEntryBase extends VisualSampleEntry {
	hvcC: hvcCBox;
	/** @bundle box-codecs.js */
	getCodec(): string;
}
declare class hvt1SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class iaugBox extends EntityToGroup {
	constructor(size?: number);
}
declare class idatBox extends Box {
	constructor(size?: number);
}
declare class iinfBox extends Box {
	version: number;
	entry_count: number;
	item_infos: Array<infeBox>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class ilocBox extends FullBox {
	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: Extent[];
	}>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class imirBox extends Box {
	reserved: number;
	axis: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class infeBox extends FullBox {
	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;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class iodsBox extends FullBox {
	constructor(size?: number);
}
declare class ipcoBox extends ContainerBox {
	constructor(size?: number);
}
declare class ipmaBox extends Box {
	associations: Array<Assocation>;
	version: number;
	flags: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class iproBox extends FullBox {
	protections: Array<unknown>;
	constructor(size?: number);
}
declare class iprpBox extends ContainerBox {
	ipco: ipcoBox;
	ipmas: Array<ipmaBox>;
	subBoxNames: readonly [
		"ipma"
	];
	constructor(size?: number);
}
declare class irefBox extends Box {
	references: {
		references: Array<unknown>;
		from_item_ID: number;
		type: unknown;
	}[];
	version: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream | MP4BoxStream): void;
}
declare class irotBox extends Box {
	angle: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class ispeBox extends Box {
	image_width: number;
	image_height: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class j2kHBox extends ContainerBox {
	constructor(size?: number);
}
declare class j2kiSampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class kindBox extends FullBox {
	schemeURI: string;
	value: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/kind.js */
	write(stream: MultiBufferStream): void;
}
declare class levaBox extends FullBox {
	levels: Array<Level>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class lhe1SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class lhvCBox extends Box {
	configurationVersion: number;
	min_spatial_segmentation_idc: number;
	parallelismType: number;
	numTemporalLayers: number;
	temporalIdNested: number;
	lengthSizeMinusOne: number;
	nalu_arrays: Array<NaluArray>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class lselBox extends Box {
	layer_id: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class maxrBox extends Box {
	period: number;
	bytes: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class mdatBox extends Box {
	constructor(size?: number);
}
declare class mdcvBox extends Box {
	display_primaries: Array<ColorPoint>;
	white_point: ColorPoint;
	max_display_mastering_luminance: number;
	min_display_mastering_luminance: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class mdhdBox extends FullBox {
	creation_time: number;
	modification_time: number;
	timescale: number;
	duration: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/mdhd.js */
	write(stream: MultiBufferStream): void;
}
declare class mdiaBox extends ContainerBox {
	elng: elngBox;
	hdlr: hdlrBox;
	mdhd: mdhdBox;
	minf: minfBox;
	constructor(size?: number);
}
declare class mecoBox extends ContainerBox {
	constructor(size?: number);
}
declare class mehdBox extends FullBox {
	fragment_duration: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/mehd.js */
	write(stream: MultiBufferStream): void;
}
declare class metaBox extends FullBox {
	hdlr: hdlrBox;
	iinf: iinfBox;
	ipro: iproBox;
	grpl: grplBox;
	iloc: ilocBox;
	iprp: iprpBox;
	pitm: pitmBox;
	iref: irefBox;
	dinf: dinfBox;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class mettSampleEntry extends MetadataSampleEntry {
	content_encoding: string;
	mime_format: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class metxSampleEntry extends MetadataSampleEntry {
	content_encoding: string;
	namespace: string;
	schema_location: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class mfhdBox extends FullBox {
	sequence_number: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/mfhd.js */
	write(stream: MultiBufferStream): void;
}
declare class mfraBox extends ContainerBox {
	tfras: Array<tfraBox>;
	subBoxNames: readonly [
		"tfra"
	];
	constructor(size?: number);
}
declare class mfroBox extends FullBox {
	_size: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class mha1SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class mha2SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class mhm1SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class mhm2SampleEntry extends AudioSampleEntry {
	constructor(size?: number);
}
declare class minfBox extends ContainerBox {
	stbl: stblBox;
	constructor(size?: number);
}
declare class mjp2SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class mjpgSampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class moofBox extends ContainerBox {
	trafs: Array<trafBox>;
	subBoxNames: string[];
	constructor(size?: number);
}
declare class moovBox extends ContainerBox {
	timescale: number;
	mvhd: mvhdBox;
	mvex: mvexBox;
	iods: iodsBox;
	traks: Array<trakBox>;
	psshs: Array<psshBox>;
	subBoxNames: readonly [
		"trak",
		"pssh"
	];
	constructor(size?: number);
}
declare class mp4aSampleEntry extends AudioSampleEntry {
	esds: esdsBox;
	constructor(size?: number);
	getCodec(): string;
}
declare class mskCBox extends FullBox {
	bits_per_pixel: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class msrcTrackGroupTypeBox extends TrackGroupTypeBox {
}
declare class mvexBox extends ContainerBox {
	mehd: mehdBox;
	trexs: Array<trexBox>;
	subBoxNames: string[];
	constructor(size?: number);
}
declare class mvhdBox extends FullBox {
	creation_time: number;
	modification_time: number;
	timescale: number;
	duration: number;
	rate: number;
	volume: number;
	next_track_id: number;
	matrix: Matrix;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/mvhd.js */
	write(stream: MultiBufferStream): void;
	/** @bundle box-print.js */
	print(output: Output): void;
}
declare class mvifSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class nmhdBox extends FullBox {
	constructor(size?: number);
}
declare class npckBox extends Box {
	packetssent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class numpBox extends Box {
	packetssent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class padbBox extends FullBox {
	padbits: number | Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class panoBox extends EntityToGroup {
	constructor(size?: number);
}
declare class paspBox extends Box {
	hSpacing: number;
	vSpacing: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class paylBox extends Box {
	text: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class paytBox extends Box {
	payloadID: number;
	rtpmap_string: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class pdinBox extends Box {
	rate: Array<number>;
	initial_delay: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class pitmBox extends FullBox {
	item_id: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class pixiBox extends FullBox {
	num_channels: number;
	bits_per_channels: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class pmaxBox extends Box {
	bytes: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class prdiBox extends FullBox {
	step_count: number;
	item_count: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class prftBox extends FullBox {
	ref_track_id: number;
	ntp_timestamp: number;
	media_time: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class prgrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class profBox extends FullBox {
	width: number;
	height: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class prolSampleGroupEntry extends SampleGroupEntry {
	roll_distance: number;
	parse(stream: MultiBufferStream): void;
}
declare class psshBox extends FullBox {
	system_id: string;
	kid: Array<string>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class pymdBox extends EntityToGroup {
	tile_size_x: number;
	tile_size_y: number;
	layer_binning: Array<number>;
	tiles_in_layer_column_minus1: Array<number>;
	tiles_in_layer_row_minus1: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class rapSampleGroupEntry extends SampleGroupEntry {
	num_leading_samples_known: number;
	num_leading_samples: number;
	parse(stream: MultiBufferStream): void;
}
declare class rashSampleGroupEntry extends SampleGroupEntry {
	operation_point_count: number;
	target_rate_share: number | Array<number>;
	available_bitrate: Array<number>;
	maximum_bitrate: number;
	minimum_bitrate: number;
	discard_priority: number;
	parse(stream: MultiBufferStream): void;
}
declare class rinfBox extends ContainerBox {
	constructor(size?: number);
}
declare class rollSampleGroupEntry extends SampleGroupEntry {
	roll_distance: number;
	parse(stream: MultiBufferStream): void;
}
declare class rtpBox extends Box {
	descriptionformat: string;
	sdptext: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class saioBox extends FullBox {
	aux_info_type: number;
	aux_info_type_parameter: number;
	offset: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class saizBox extends FullBox {
	aux_info_type: number;
	aux_info_type_parameter: number;
	default_sample_info_size: number;
	sample_info_size: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class sbgpBox extends FullBox {
	grouping_type: string;
	grouping_type_parameter: number;
	entries: Array<Entry$1>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/sbgp.js */
	write(stream: MultiBufferStream): void;
}
declare class sbpmBox extends FullBox {
	component_count: number;
	component_index: Array<number>;
	correction_applied: boolean;
	num_bad_rows: number;
	num_bad_cols: number;
	num_bad_pixels: number;
	bad_rows: Array<number>;
	bad_columns: Array<number>;
	bad_pixels: Pixel[];
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class sbttSampleEntry extends SubtitleSampleEntry {
	content_encoding: string;
	mime_format: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class schiBox extends ContainerBox {
	constructor(size?: number);
}
declare class schmBox extends FullBox {
	scheme_type: string;
	scheme_version: number;
	scheme_uri: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class scifSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class scnmSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class sdpBox extends Box {
	sdptext?: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class sdtpBox extends FullBox {
	is_leading: Array<number>;
	sample_depends_on: Array<number>;
	sample_is_depended_on: Array<number>;
	sample_has_redundancy: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class seigSampleGroupEntry extends SampleGroupEntry {
	reserved: number;
	crypt_byte_block: number;
	skip_byte_block: number;
	isProtected: number;
	Per_Sample_IV_Size: number;
	KID: unknown;
	constant_IV_size: number;
	constant_IV: number | Uint8Array;
	parse(stream: MultiBufferStream): void;
}
declare class sencBox extends FullBox {
	constructor(size?: number);
}
declare class sgpdBox extends FullBox {
	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: SampleGroupEntry[];
	used: boolean;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/sgpd.js */
	write(stream: MultiBufferStream): void;
}
declare class sidxBox extends FullBox {
	reference_ID: number;
	timescale: number;
	earliest_presentation_time: number;
	first_offset: number;
	references: Reference[];
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/sidx.js */
	write(stream: MultiBufferStream): void;
}
declare class sinfBox extends ContainerBox {
	constructor(size?: number);
}
declare class skipBox extends Box {
	constructor(size?: number);
}
declare class slidBox extends EntityToGroup {
	constructor(size?: number);
}
declare class smhdBox extends FullBox {
	balance: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/smhd.js */
	write(stream: MultiBufferStream): void;
}
declare class ssixBox extends FullBox {
	subsegments: SubSegment[];
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class stblBox extends ContainerBox {
	cslg: cslgBox;
	stsd: stsdBox;
	stsc: stscBox;
	stco: stcoBox;
	co64: co64Box;
	stsz: stszBox;
	stz2: stz2Box;
	stts: sttsBox;
	ctts: cttsBox;
	stss: stssBox;
	subs: subsBox;
	stdp: stdpBox;
	sdtp: sdtpBox;
	sgpds: Array<sgpdBox>;
	sbgps: Array<sbgpBox>;
	subBoxNames: string[];
	constructor(size?: number);
}
declare class stcoBox extends FullBox {
	chunk_offsets: Array<number>;
	constructor(size?: 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 {
	priority: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class sterBox extends EntityToGroup {
	constructor(size?: number);
}
declare class sthdBox extends FullBox {
	constructor(size?: number);
}
declare class stppSampleEntry extends SubtitleSampleEntry {
	namespace: string;
	schema_location: string;
	auxiliary_mime_types: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/sampleentry.js */
	write(stream: MultiBufferStream): void;
}
declare class strdBox extends ContainerBox {
	constructor(size?: number);
}
declare class striBox extends FullBox {
	switch_group: number;
	alternate_group: number;
	sub_track_id: number;
	attribute_list: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class strkBox extends ContainerBox {
	constructor(size?: number);
}
declare class stsaSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class stscBox extends FullBox {
	first_chunk: Array<number>;
	samples_per_chunk: Array<number>;
	sample_description_index: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	write(stream: MultiBufferStream): void;
	unpack(samples: Array<Sample>): void;
}
declare class stsdBox extends FullBox {
	entries: Array<SampleEntry>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/stsd.js */
	write(stream: MultiBufferStream): void;
}
declare class stsgBox extends FullBox {
	grouping_type: number;
	group_description_index: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class stshBox extends FullBox {
	shadowed_sample_numbers: Array<number>;
	sync_sample_numbers: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	write(stream: MultiBufferStream): void;
}
declare class stssBox extends FullBox {
	sample_numbers: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/stss.js */
	write(stream: MultiBufferStream): void;
}
declare class stszBox extends FullBox {
	sample_sizes: Array<number>;
	sample_size: number;
	sample_count: number;
	constructor(size?: 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 {
	sample_counts: Array<number>;
	sample_deltas: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/stts.js */
	write(stream: MultiBufferStream): void;
	/** @bundle box-unpack.js */
	unpack(samples: Array<Sample>): void;
}
declare class stviBox extends FullBox {
	single_view_allowed: number;
	stereo_scheme: number;
	stereo_indication_type: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class stxtSampleEntry extends SubtitleSampleEntry {
	content_encoding: string;
	mime_format: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	getCodec(): string;
}
declare class stypBox extends ftypBox {
}
declare class stz2Box extends FullBox {
	sample_sizes: Array<number>;
	reserved: number;
	field_size: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class subsBox extends FullBox {
	entries: SampleInfo[];
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class syncSampleGroupEntry extends SampleGroupEntry {
	NAL_unit_type: number;
	parse(stream: MultiBufferStream): void;
}
declare class taptBox extends ContainerBox {
	clef: Array<clefBox>;
	prof: Array<profBox>;
	enof: Array<enofBox>;
	subBoxNames: readonly [
		"clef",
		"prof",
		"enof"
	];
	constructor(size?: number);
}
declare class teleSampleGroupEntry extends SampleGroupEntry {
	level_independently_decodable: number;
	parse(stream: MultiBufferStream): void;
}
declare class tencBox extends FullBox {
	default_crypt_byte_block: number;
	default_skip_byte_block: number;
	default_isProtected: number;
	default_Per_Sample_IV_Size: number;
	default_KID: string;
	default_constant_IV_size: number;
	default_constant_IV: Uint8Array;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tfdtBox extends FullBox {
	baseMediaDecodeTime: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/tdft.js */
	write(stream: MultiBufferStream): void;
}
declare class tfhdBox extends FullBox {
	track_id: number;
	base_data_offset: number;
	default_sample_description_index: number;
	default_sample_duration: number;
	default_sample_size: number;
	default_sample_flags: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/tfhd.js */
	write(stream: any): void;
}
declare class tfraBox extends FullBox {
	track_ID: number;
	length_size_of_traf_num: number;
	length_size_of_trun_num: number;
	length_size_of_sample_num: number;
	entries: Array<unknown>;
	time: number;
	moof_offset: number;
	traf_number: number;
	trun_number: number;
	sample_number: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tkhdBox extends FullBox {
	creation_time: number;
	modification_time: number;
	track_id: number;
	duration: number;
	layer: number;
	alternate_group: number;
	volume: number;
	matrix: Matrix;
	width: number;
	height: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle box-print.js */
	print(output: {
		log: (arg: string) => void;
		indent: string;
	}): void;
}
declare class tmaxBox extends Box {
	time: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tminBox extends Box {
	time: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class totlBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tpayBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tpylBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class trafBox extends ContainerBox {
	first_sample_index: number;
	sample_number: number;
	tfhd: tfhdBox;
	tfdt: tfdtBox;
	subs: subsBox;
	sample_groups_info: Array<SampleGroupInfo>;
	truns: Array<trunBox>;
	sgpds: Array<sgpdBox>;
	sbgps: Array<sbgpBox>;
	subBoxNames: string[];
	constructor(size?: number);
}
declare class trakBox extends ContainerBox {
	mdia: mdiaBox;
	tkhd: tkhdBox;
	tref: trefBox;
	edts: edtsBox;
	samples_duration: number;
	udta: udtaBox;
	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;
	constructor(size?: number);
}
declare class trefBox extends ContainerBox {
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class trepBox extends FullBox {
	track_ID: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class trexBox extends FullBox {
	track_id: number;
	default_sample_description_index: number;
	default_sample_duration: number;
	default_sample_size: number;
	default_sample_flags: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	write(stream: MultiBufferStream): void;
}
declare class trgrBox extends ContainerBox {
	constructor(size?: number);
}
declare class trpyBox extends Box {
	bytessent: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class trunBox extends FullBox {
	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;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/trun.js */
	write(stream: MultiBufferStream): void;
}
declare class tsasSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class tsclSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class tselBox extends FullBox {
	switch_group: number;
	attribute_list: Array<number>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tsynBox extends EntityToGroup {
	constructor(size?: number);
}
declare class tx3gSampleEntry extends SubtitleSampleEntry {
	displayFlags: number;
	horizontal_justification: number;
	vertical_justification: number;
	bg_color_rgba: Uint8Array;
	box_record: Int16Array;
	style_record: Uint8Array;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class txtcBox extends FullBox {
	config: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class tycoBox extends Box {
	compatible_brands: Array<string>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class udesBox extends FullBox {
	lang: string;
	name: string;
	description: string;
	tags: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class udtaBox extends ContainerBox {
	kinds: Array<kindBox>;
	subBoxNames: readonly [
		"kind"
	];
	constructor(size?: number);
}
declare class uncCBox extends FullBox {
	profile: number;
	component_count: number;
	component_index: Array<number>;
	component_bit_depth_minus_one: Array<number>;
	component_format: Array<number>;
	component_align_size: Array<number>;
	sampling_type: number;
	interleave_type: number;
	block_size: number;
	component_little_endian: number;
	block_pad_lsb: number;
	block_little_endian: number;
	block_reversed: number;
	pad_unknown: number;
	pixel_size: number;
	row_align_size: number;
	tile_align_size: number;
	num_tile_cols_minus_one: number;
	num_tile_rows_minus_one: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class uncvSampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class urlBox extends FullBox {
	location?: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/url.js */
	write(stream: MultiBufferStream): void;
}
declare class urnBox extends FullBox {
	name: string;
	location: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/urn.js */
	write(stream: MultiBufferStream): void;
}
declare class viprSampleGroupEntry extends SampleGroupEntry {
	parse(stream: MultiBufferStream): void;
}
declare class vmhdBox extends FullBox {
	graphicsmode: number;
	opcolor: Uint16Array | [
		number,
		number,
		number
	];
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	/** @bundle writing/vmhd.js */
	write(stream: MultiBufferStream): void;
}
declare class vp08SampleEntry extends vpcCSampleEntryBase {
	constructor(size?: number);
}
declare class vp09SampleEntry extends vpcCSampleEntryBase {
	constructor(size?: number);
}
declare class vpcCBox extends FullBox {
	profile: number;
	level: number;
	bitDepth: number;
	chromaSubsampling: number;
	videoFullRangeFlag: number;
	colourPrimaries: number;
	transferCharacteristics: number;
	matrixCoefficients: number;
	codecIntializationDataSize: number;
	codecIntializationData: Uint8Array;
	colorSpace: number;
	transferFunction: number;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class vpcCSampleEntryBase extends VisualSampleEntry {
	vpcC: vpcCBox;
	getCodec(): string;
}
declare class vttCBox extends Box {
	text: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class vttcBox extends ContainerBox {
	constructor(size?: number);
}
declare class vvc1SampleEntry extends vvcCSampleEntryBase {
	constructor(size?: number);
}
declare class vvcCBox extends FullBox {
	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$1>;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class vvcCSampleEntryBase extends VisualSampleEntry {
	vvcC: vvcCBox;
	getCodec(): string;
}
declare class vvcNSampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class vvi1SampleEntry extends vvcCSampleEntryBase {
	constructor(size?: number);
}
declare class vvnCBox extends FullBox {
	lengthSizeMinusOne: number | undefined;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class vvs1SampleEntry extends VisualSampleEntry {
	constructor(size?: number);
}
declare class wbbrBox extends EntityToGroup {
	constructor(size?: number);
}
declare class wvttSampleEntry extends MetadataSampleEntry {
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
}
declare class xmlBox extends FullBox {
	constructor(size?: number);
}
declare namespace MP4Box {
	interface BoxRegistry extends Partial<typeof BOXES> {
	}
	interface DescriptorRegistry extends Partial<typeof DESCRIPTORS> {
	}
}
export declare class Box extends BoxBase {
	static codes: Array<string>;
	has_unparsed_data?: boolean;
	constructor(type: string, size?: number);
	constructor(type: "uuid", size: number | undefined, uuid: string);
}
export declare class ContainerBox extends ContainerBoxBase {
	static codes: Array<string>;
	constructor(type: string, size?: number);
}
export declare class ContainerBoxBase extends BoxBase {
	boxes: Array<BoxBase>;
	subBoxNames?: readonly string[];
	/** @bundle box-write.js */
	write(stream: MultiBufferStream): void;
	/** @bundle box-print.js */
	print(output: Output): void;
	/** @bundle box-parse.js */
	parse(stream: MultiBufferStream): void;
}
export declare class DataStream {
	static DataStream: {};
	_buffer?: MP4BoxBuffer;
	_byteOffset?: number;
	_dataView?: DataView;
	endianness: boolean;
	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 DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN (the default).
	 */
	constructor(arrayBuffer?: ArrayBuffer | DataView | number, byteOffset?: number, endianness?: boolean | null);
	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;
	/**
	 * Big-endian const to use as default endianness.
	 */
	static BIG_ENDIAN: boolean;
	/**
	 * Little-endian const to use as default endianness.
	 */
	static LITTLE_ENDIAN: boolean;
	/**
	 * 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;
	set dataView(value: DataView);
	/**
	 *   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;
	/**
	 * 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 | null, endianness?: boolean | null): Int32Array;
	/**
	 * 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 | null, endianness?: boolean): Int16Array;
	/**
	 * 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 | null): Int8Array;
	/**
	 * 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 | null, endianness?: boolean | null): Uint32Array;
	/**
	 * 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 | null, endianness?: boolean): Uint16Array;
	/**
	 * 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 | null): Uint8Array;
	/**
	 * Reads a Float64Array 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 Float64Array.
	 */
	readFloat64Array(length: number | null, endianness?: boolean): Float64Array;
	/**
	 * Reads a Float32Array 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 Float32Array.
	 */
	readFloat32Array(length: number | null, endianness?: boolean): Float32Array;
	/**
	 * Reads a 32-bit int from the DataStream with the desired endianness.
	 *
	 * @param endianness Endianness of the number.
	 * @return The read number.
	 */
	readInt32(endianness?: boolean | null): number;
	/**
	 * Reads a 16-bit int from the DataStream with the desired endianness.
	 *
	 * @param endianness Endianness of the number.
	 * @return The read number.
	 */
	readInt16(endianness?: boolean): number;
	/**
	 * Reads an 8-bit int from the DataStream.
	 *
	 * @return The read number.
	 */
	readInt8(): number;
	/**
	 * Reads a 32-bit unsigned int from the DataStream with the desired endianness.
	 *
	 * @param endianness Endianness of the number.
	 * @return The read number.
	 */
	readUint32(endianness?: boolean | null): number;
	/**
	 * Reads a 16-bit unsigned int from the DataStream with the desired endianness.
	 *
	 * @param endianness Endianness of the number.
	 * @return The read number.
	 */
	readUint16(endianness?: boolean | null): number;
	/**
	 * Reads an 8-bit unsigned int from the DataStream.
	 *
	 * @return The read number.
	 */
	readUint8(): number;
	/**
	 * Reads a 32-bit float from the DataStream with the desired endianness.
	 *
	 * @param endianness Endianness of the number.
	 * @return The read number.
	 */
	readFloat32(endianness?: boolean | null): number;
	/**
	 * Reads a 64-bit float from the DataStream with the desired endianness.
	 *
	 * @param endianness Endianness of the number.
	 * @return The read number.
	 */
	readFloat64(endianness?: boolean | null): number;
	/**
	 * Native endianness. Either DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN
	 * depending on the platform endianness.
	 * @type {boolean}
	 */
	static endianness: boolean;
	/**
	 * Copies byteLength bytes from the src buffer at srcOffset to the
	 * dst buffer at dstOffset.
	 *
	 * @param dst Destination ArrayBuffer to write to.
	 * @param dstOffset Offset to the destination ArrayBuffer.
	 * @param src Source ArrayBuffer to read from.
	 * @param srcOffset Offset to the source ArrayBuffer.
	 * @param byteLength Number of bytes to copy.
	 */
	static memcpy(dst: ArrayBufferLike, dstOffset?: number, src?: ArrayBuffer, srcOffset?: number, byteLength?: number): void;
	/**
	 * Converts array to native endianness in-place.
	 *
	 * @param typedArray Typed array to convert.
	 * @param endianness True if the data in the array is
	 *                                      little-endian. Set false for big-endian.
	 * @return The converted typed array.
	 */
	static arrayToNative(typedArray: TypedArray, endianness?: boolean): TypedArray;
	/**
	 * Converts native endianness array to desired endianness in-place.
	 *
	 * @param typedArray Typed array to convert.
	 * @param littleEndian True if the converted array should be
	 *                               little-endian. Set false for big-endian.
	 * @return The converted typed array.
	 */
	static nativeToEndian(typedArray: TypedArray, littleEndian: boolean): TypedArray;
	/**
	 * Flips typed array endianness in-place.
	 *
	 * @param typedArray Typed array to flip.
	 * @return The converted typed array.
	 */
	static flipArrayEndianness(typedArray: TypedArray): TypedArray;
	/**
	 * Seek position where DataStream#readStruct ran into a problem.
	 * Useful for debugging struct parsing.
	 *
	 * @type {number}
	 */
	failurePosition: number;
	/**
	 * Read a string of desired length and encoding from the DataStream.
	 *
	 * @param length The length of the string to read in bytes.
	 * @param encoding The encoding of the string data in the DataStream.
	 *                           Defaults to ASCII.
	 * @return The read string.
	 */
	readString(length: number, encoding?: string | null): string;
	/**
	 * Read null-terminated string of desired length from the DataStream. Truncates
	 * the returned string so that the null byte is not a part of it.
	 *
	 * @param length The length of the string to read.
	 * @return The read string.
	 */
	readCString(length?: number | null): any;
	readInt64(): number;
	readUint64(): number;
	readUint24(): number;
	/**
	 * Saves the DataStream contents to the given filename.
	 * Uses Chrome's anchor download property to initiate download.
	 *
	 * @param filename Filename to save as.
	 * @return
	 * @bundle DataStream-write.js
	 */
	save(filename: string): void;
	/**
	 * Whether to extend DataStream buffer when trying to write beyond its size.
	 * If set, the buffer is reallocated to twice its current size until the
	 * requested write fits the buffer.
	 *
	 * @type {boolean}
	 * @bundle DataStream-write.js
	 */
	_dynamicSize: number;
	/** @bundle DataStream-write.js */
	get dynamicSize(): number;
	/** @bundle DataStream-write.js */
	set dynamicSize(v: number);
	/**
	 * Internal function to trim the DataStream buffer when required.
	 * Used for stripping out the first bytes when not needed anymore.
	 *
	 * @return
	 * @bundle DataStream-write.js
	 */
	shift(offset: number): void;
	/**
	 * Writes an Int32Array of specified endianness to the DataStream.
	 *
	 * @param array The array to write.
	 * @param endianness Endianness of the data to write.
	 * @bundle DataStream-write.js
	 */
	writeInt32Array(array: ArrayLike<number>, endianness?: boolean): void;
	/**
	 * Writes an Int16Array of specified endianness to the DataStream.
	 *
	 * @param array The array to write.
	 * @param endianness Endianness of the data to write.
	 * @bundle DataStream-write.js
	 */
	writeInt16Array(array: ArrayLike<number>, endianness?: boolean): void;
	/**
	 * Writes an Int8Array to the DataStream.
	 *
	 * @param array The array to write.
	 * @bundle DataStream-write.js
	 */
	writeInt8Array(array: ArrayLike<number>): void;
	/**
	 * Writes a Uint32Array of specified endianness to the DataStream.
	 *
	 * @param array The array to write.
	 * @param endianness Endianness of the data to write.
	 * @bundle DataStream-write.js
	 */
	writeUint32Array(array: ArrayLike<number>, endianness?: boolean): void;
	/**
	 * Writes a Uint16Array of specified endianness to the DataStream.
	 *
	 * @param array The array to write.
	 * @param endianness Endianness of the data to write.
	 * @bundle DataStream-write.js
	 */
	writeUint16Array(array: ArrayLike<number>, endianness?: boolean): void;
	/**
	 * Writes a Uint8Array to the DataStream.
	 *
	 * @param array The array to write.
	 * @bundle DataStream-write.js
	 */
	writeUint8Array(array: ArrayLike<number>): void;
	/**
	 * Writes a Float64Array of specified endianness to the DataStream.
	 *
	 * @param array The array to write.
	 * @param endianness Endianness of the data to write.
	 * @bundle DataStream-write.js
	 */
	writeFloat64Array(array: ArrayLike<number>, endianness?: boolean): void;
	/**
	 * Writes a Float32Array of specified endianness to the DataStream.
	 *
	 * @param array The array to write.
	 * @param endianness Endianness of the data to write.
	 * @bundle DataStream-write.js
	 */
	writeFloat32Array(array: ArrayLike<number>, endianness?: boolean): void;
	/**
	 * Writes a 32-bit int to the DataStream with the desired endianness.
	 *
	 * @param value Number to write.
	 * @param endianness Endianness of the number.
	 * @bundle DataStream-write.js
	 */
	writeInt32(value: number, endianness?: boolean | null): void;
	/**
	 * Writes a 16-bit int to the DataStream with the desired endianness.
	 *
	 * @param value Number to write.
	 * @param endianness Endianness of the number.
	 * @bundle DataStream-write.js
	 */
	writeInt16(value: number, endianness?: boolean | null): void;
	/**
	 * Writes an 8-bit int to the DataStream.
	 *
	 * @param value Number to write.
	 * @bundle DataStream-write.js
	 */
	writeInt8(value: number): void;
	/**
	 * Writes a 32-bit unsigned int to the DataStream with the desired endianness.
	 *
	 * @param value Number to write.
	 * @param endianness Endianness of the number.
	 * @bundle DataStream-write.js
	 */
	writeUint32(value: number, endianness?: boolean | null): void;
	/**
	 * Writes a 16-bit unsigned int to the DataStream with the desired endianness.
	 *
	 * @param value Number to write.
	 * @param endianness Endianness of the number.
	 * @bundle DataStream-write.js
	 */
	writeUint16(value: number, endianness?: boolean | null): void;
	/**
	 * Writes an 8-bit unsigned  int to the DataStream.
	 *
	 * @param value Number to write.
	 * @bundle DataStream-write.js
	 */
	writeUint8(value: number): void;
	/**
	 * Writes a 32-bit float to the DataStream with the desired endianness.
	 *
	 * @param value Number to write.
	 * @param endianness Endianness of the number.
	 * @bundle DataStream-write.js
	 */
	writeFloat32(value: number, endianness?: boolean | null): void;
	/**
	 * Writes a 64-bit float to the DataStream with the desired endianness.
	 *
	 * @param value Number to write.
	 * @param endianness Endianness of the number.
	 * @bundle DataStream-write.js
	 */
	writeFloat64(value: number, endianness?: boolean | null): void;
	/**
	 * Write a UCS-2 string of desired endianness to the DataStream. The
	 * lengthOverride argument lets you define the number of characters to write.
	 * If the string is shorter than lengthOverride, the extra space is padded with
	 * zeroes.
	 *
	 * @param value The string to write.
	 * @param endianness The endianness to use for the written string data.
	 * @param lengthOverride The number of characters to write.
	 * @bundle DataStream-write.js
	 */
	writeUCS2String(value: string, endianness: boolean, lengthOverride?: number): void;
	/**
	 * Writes a string of desired length and encoding to the DataStream.
	 *
	 * @param value The string to write.
	 * @param encoding The encoding for the written string data.
	 *                           Defaults to ASCII.
	 * @param length The number of characters to write.
	 * @bundle DataStream-write.js
	 */
	writeString(value: string, encoding?: string, length?: number): void;
	/**
	 * Writes a null-terminated string to DataStream and zero-pads it to length
	 * bytes. If length is not given, writes the string followed by a zero.
	 * If string is longer than length, the written part of the string does not have
	 * a trailing zero.
	 *
	 * @param value The string to write.
	 * @param length The number of characters to write.
	 * @bundle DataStream-write.js
	 */
	writeCString(value: string, length?: number): void;
	/**
	 * Writes a struct to the DataStream. Takes a structDefinition that gives the
	 * types and a struct object that gives the values. Refer to readStruct for the
	 * structure of structDefinition.
	 *
	 * @param structDefinition Type definition of the struct.
	 * @param struct The struct data object.
	 * @bundle DataStream-write.js
	 */
	writeStruct(structDefinition: StructDefinition, struct: Record<string, number>): void;
	/**
	 * Writes object v of type t to the DataStream.
	 *
	 * @param type Type of data to write.
	 * @param value Value of data to write.
	 * @param struct Struct to pass to write callback functions.
	 * @bundle DataStream-write.js
	 */
	writeType(type: StructType, value: number, struct?: Record<string, number>): number | void;
	/** @bundle DataStream-write.js */
	writeUint64(value: number): void;
	/** @bundle DataStream-write.js */
	writeUint24(value: number): void;
	/** @bundle DataStream-write.js */
	adjustUint32(position: number, value: number): void;
	/**
	 * Reads a struct of data from the DataStream. The struct is defined as
	 * a flat array of [name, type]-pairs. See the example below:
	 *
	 * ds.readStruct([
	 *   ['headerTag', 'uint32'], // Uint32 in DataStream endianness.
	 *   ['headerTag2', 'uint32be'], // Big-endian Uint32.
	 *   ['headerTag3', 'uint32le'], // Little-endian Uint32.
	 *   ['array', ['[]', 'uint32', 16]], // Uint32Array of length 16.
	 *   ['array2Length', 'uint32'],
	 *   ['array2', ['[]', 'uint32', 'array2Length']] // Uint32Array of length array2Length
	 * ]);
	 *
	 * The possible values for the type are as follows:
	 *
	 * // Number types
	 *
	 * // Unsuffixed number types use DataStream endianness.
	 * // To explicitly specify endianness, suffix the type with
	 * // 'le' for little-endian or 'be' for big-endian,
	 * // e.g. 'int32be' for big-endian int32.
	 *
	 * 'uint8' -- 8-bit unsigned int
	 * 'uint16' -- 16-bit unsigned int
	 * 'uint32' -- 32-bit unsigned int
	 * 'int8' -- 8-bit int
	 * 'int16' -- 16-bit int
	 * 'int32' -- 32-bit int
	 * 'float32' -- 32-bit float
	 * 'float64' -- 64-bit float
	 *
	 * // String types
	 * 'cstring' -- ASCII string terminated by a zero byte.
	 * 'string:N' -- ASCII string of length N.
	 * 'string,CHARSET:N' -- String of byteLength N encoded with given CHARSET.
	 * 'u16string:N' -- UCS-2 string of length N in DataStream endianness.
	 * 'u16stringle:N' -- UCS-2 string of length N in little-endian.
	 * 'u16stringbe:N' -- UCS-2 string of length N in big-endian.
	 *
	 * // Complex types
	 * [name, type, name_2, type_2, ..., name_N, type_N] -- Struct
	 * function(dataStream, struct) {} -- Callback function to read and return data.
	 * {get: function(dataStream, struct) {},
	 *  set: function(dataStream, struct) {}}
	 * -- Getter/setter functions to read and return data, handy for using the same
	 *    struct definition for reading and writing structs.
	 * ['[]', type, length] -- Array of given type and length. The length can be either
	 *                       a number, a string that references a previously-read
	 *                       field, or a callback function(struct, dataStream, type){}.
	 *                       If length is '*', reads in as many elements as it can.
	 *
	 * @param structDefinition Struct definition object.
	 * @return The read struct. Null if failed to read struct.
	 * @bundle DataStream-read-struct.js
	 */
	readStruct(structDefinition: StructDefinition): Record<string, string>;
	/**
	 * Read UCS-2 string of desired length and endianness from the DataStream.
	 *
	 * @param length The length of the string to read.
	 * @param endianness The endianness of the string data in the DataStream.
	 * @return The read string.
	 * @bundle DataStream-read-struct.js
	 */
	readUCS2String(length?: number, endianness?: boolean): any;
	/**
	 * Reads an object of type t from the DataStream, passing struct as the thus-far
	 * read struct to possible callbacks that refer to it. Used by readStruct for
	 * reading in the values, so the type is one of the readStruct types.
	 *
	 * @param type Type of the object to read.
	 * @param struct Struct to refer to when resolving length references
	 *                         and for calling callbacks.
	 * @return  Returns the object on successful read, null on unsuccessful.
	 * @bundle DataStream-read-struct.js
	 */
	readType(type: StructType, struct: Record<string, string>): any;
	/**
	 * Maps an Int32Array into the DataStream buffer, swizzling it to native
	 * endianness in-place. The current offset from the start of the buffer needs to
	 * be a multiple of element size, just like with typed array views.
	 *
	 * Nice for quickly reading in data. Warning: potentially modifies the buffer
	 * contents.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Int32Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapInt32Array(length: number, endianness?: boolean): Int32Array;
	/**
	 * Maps an Int16Array into the DataStream buffer, swizzling it to native
	 * endianness in-place. The current offset from the start of the buffer needs to
	 * be a multiple of element size, just like with typed array views.
	 *
	 * Nice for quickly reading in data. Warning: potentially modifies the buffer
	 * contents.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Int16Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapInt16Array(length: number, endianness: boolean): Int16Array;
	/**
	 * Maps an Int8Array into the DataStream buffer.
	 *
	 * Nice for quickly reading in data.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Int8Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapInt8Array(length: number, endianness?: boolean): Int8Array;
	/**
	 * Maps a Uint32Array into the DataStream buffer, swizzling it to native
	 * endianness in-place. The current offset from the start of the buffer needs to
	 * be a multiple of element size, just like with typed array views.
	 *
	 * Nice for quickly reading in data. Warning: potentially modifies the buffer
	 * contents.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Uint32Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapUint32Array(length: number, endianness?: boolean): Uint32Array;
	/**
	 * Maps a Uint16Array into the DataStream buffer, swizzling it to native
	 * endianness in-place. The current offset from the start of the buffer needs to
	 * be a multiple of element size, just like with typed array views.
	 *
	 * Nice for quickly reading in data. Warning: potentially modifies the buffer
	 * contents.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Uint16Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapUint16Array(length: number, endianness?: boolean): Uint16Array;
	/**
	 * Maps a Float64Array into the DataStream buffer, swizzling it to native
	 * endianness in-place. The current offset from the start of the buffer needs to
	 * be a multiple of element size, just like with typed array views.
	 *
	 * Nice for quickly reading in data. Warning: potentially modifies the buffer
	 * contents.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Float64Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapFloat64Array(length: number, endianness?: boolean): Float64Array;
	/**
	 * Maps a Float32Array into the DataStream buffer, swizzling it to native
	 * endianness in-place. The current offset from the start of the buffer needs to
	 * be a multiple of element size, just like with typed array views.
	 *
	 * Nice for quickly reading in data. Warning: potentially modifies the buffer
	 * contents.
	 *
	 * @param length Number of elements to map.
	 * @param endianness Endianness of the data to read.
	 * @return Float32Array to the DataStream backing buffer.
	 * @bundle DataStream-map.js
	 */
	mapFloat32Array(length: number, endianness?: boolean): Float32Array;
}
export declare class Descriptor {
	tag: unknown;
	size: number;
	descs: any[];
	data: Uint8Array;
	constructor(tag: unknown, size: number);
	parse(stream: DataStream): void;
	findDescriptor(tag: number): any;
	parseOneDescriptor?(stream: DataStream): DescriptorKinds;
	parseRemainingDescriptors(stream: DataStream): void;
}
export declare class ES_Descriptor extends Descriptor {
	dependsOn_ES_ID: number;
	ES_ID: number;
	flags: number;
	OCR_ES_ID: number;
	URL: string;
	constructor(size?: number);
	parse(stream: MultiBufferStream): void;
	getOTI(): any;
	getAudioConfig(): number;
}
export declare class FullBox extends FullBoxBase {
	static codes: Array<string>;
	constructor(type: string, size?: number);
	constructor(type: "uuid", size: number | undefined, uuid: string);
}
export declare class ISOFile {
	/** 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: any;
	/** Boolean keeping track of the call to onMoovStart, to avoid double calls */
	moovStartSent: boolean;
	/** Callback called when the moov is entirely parsed */
	onReady: any;
	/** 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: unknown, buffer: ArrayBuffer, nextSample: number, last: boolean) => void) | null;
	/** Callback to call when samples are ready */
	onSamples: ((id: unknown, user: unknown, samples: Array<Sample>) => void) | null;
	/** Callback to call when there is an error in the parsing or processing of samples */
	onError: (() => void) | null;
	onItem?: (() => void) | null;
	/** 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>;
	/** Array of Track objects for which extraction of samples is requested */
	extractedTracks: Array<ExtractedTrack>;
	/** 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: any;
	/** Boolean keeping track of the call to onSidx, to avoid double calls */
	sidxSent: boolean;
	moov: moovBox;
	nextSeekPosition: number;
	sidx: sidxBox;
	meta: metaBox;
	ftyp: ftypBox;
	static type: unknown;
	static boxes: Array<Box>;
	initial_duration: number;
	/** @bundle isofile-item-processing.js */
	items: Array<Item>;
	/** @bundle isofile-item-processing.js */
	entity_groups: Array<{
		id: number;
		entity_ids: Array<number>;
		type: string;
		properties?: {
			boxes: Array<Box>;
		};
	}>;
	/**
	 * size of the buffers allocated for samples
	 * @bundle isofile-item-processing.js
	 */
	itemsDataSize: number;
	constructor(stream?: MultiBufferStream);
	setSegmentOptions(id: number, user: unknown, { nbSamples: nb_samples, rapAlignement, }?: {
		nbSamples?: number;
		rapAlignement?: boolean;
	}): void;
	unsetSegmentOptions(id: number): void;
	setExtractionOptions(id: number, user?: unknown, { 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;
	getInfo(): Movie;
	setNextSeekPositionFromSample(sample: Sample): void;
	processSamples(last?: boolean): void;
	getBox(type: unknown): any;
	getBoxes(type: unknown, returnEarly: boolean): any[];
	static _sweep(type: boolean, result: Array<typeof ISOFile>, returnEarly: unknown): void;
	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: unknown, trak: trakBox): {
		offset: number;
		time: number;
	};
	getTrackDuration(trak: Track): number;
	seek(time: number, useRap: unknown): {
		offset: number;
		time: number;
	};
	equal(b: {
		boxes: Array<Box>;
	}): boolean;
	/**
	 * Rewrite the entire file
	 * @bundle isofile-write.js
	 */
	write(outstream: MultiBufferStream): void;
	/** @bundle isofile-write.js */
	createFragment(track_id: number, sampleNumber: number, _stream: DataStream): DataStream;
	/**
	 * Modify the file and create the initialization segment
	 * @bundle isofile-write.js
	 */
	static writeInitializationSegment(ftyp: ftypBox, moov: moovBox, total_duration: number, sample_duration: number): MP4BoxBuffer;
	/** @bundle isofile-write.js */
	save(name: string): void;
	/** @bundle isofile-write.js */
	getBuffer(): MP4BoxBuffer;
	/** @bundle isofile-write.js */
	initializeSegmentation(): any[];
	/**
	 * 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 | null, sbgps: Array<sbgpBox>, trak_sgpds: Array<sgpdBox>, traf_sgpds?: Array<sgpdBox>): void;
	/** @bundle isofile-sample-processing.js */
	static setSampleGroupProperties(trak: unknown, 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: unknown): 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;
	/**
	 * 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: Box | null;
	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;
	/** @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: unknown): void;
	/** @bundle isofile-advanced-creation.js */
	addBox: any;
	/** @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, { sample_description_index, duration, cts, dts, is_sync, is_leading, depends_on, is_depended_on, has_redundancy, degradation_priority, offset, subsamples, }?: {
		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?: SubSample[];
		offset?: number;
	}): {
		number: number;
		track_id: number;
		timescale: number;
		description_index: number;
		description: SampleEntry;
		data: Uint8Array;
		size: number;
		alreadyRead: 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;
		offset: number;
		subsamples: SubSample[];
	};
	/** @bundle isofile-advanced-creation.js */
	createSingleSampleMoof(sample: Sample): moofBox;
	/** @bundle box-print.js */
	print(output: Output): void;
}
export declare class Log {
	static setLogLevel(level: unknown): void;
	static debug(module: string, msg?: unknown): void;
	static log(module: {
		msg: string;
	}, msg?: unknown): void;
	static info(module: string, msg?: string): void;
	static warn(module: string, msg?: unknown): void;
	static error(module: string, msg?: unknown): void;
	static getDurationString(duration: number, _timescale?: number): string;
	static printRanges(ranges: {
		length: number;
		start: (index: number) => any;
		end: (index: number) => any;
	}): string;
}
export declare class MP4BoxBuffer extends ArrayBuffer {
	fileStart?: number;
	usedBytes?: number;
}
export declare class MP4BoxStream {
	buffer: ArrayBuffer;
	dataview: DataView;
	position: number;
	constructor(arrayBuffer: ArrayBuffer);
	/*************************************************************************
	 *         Common API between MultiBufferStream and SimpleStream         *
	 *************************************************************************/
	getPosition(): number;
	getEndPosition(): number;
	getLength(): number;
	seek(pos: number): boolean;
	isEos(): boolean;
	/*************************************************************************
	 *            Read methods, simimar to DataStream but simpler            *
	 *************************************************************************/
	readAnyInt(size: number, signed: boolean): number;
	readUint8(): number;
	readUint16(): number;
	readUint24(): number;
	readUint32(): number;
	readUint64(): number;
	readString(length: number): string;
	readCString(): string;
	readInt8(): number;
	readInt16(): number;
	readInt32(): number;
	readInt64(): number;
	readUint8Array(length: number): Uint8Array;
	readInt16Array(length: number): Int16Array;
	readUint16Array(length: number): Int16Array;
	readUint32Array(length: number): Uint32Array;
	readInt32Array(length: number): Int32Array;
}
export declare class MPEG4DescriptorParser {
	constructor();
	getDescriptorName(tag: number): any;
	parseOneDescriptor(stream: DataStream): DescriptorKinds;
}
/**
 * MultiBufferStream is a class that acts as a SimpleStream for parsing
 * It holds several, possibly non-contiguous ArrayBuffer objects, each with a fileStart property
 * containing the offset for the buffer data in an original/virtual file
 *
 * It inherits also from DataStream for all read/write/alloc operations
 */
export declare class MultiBufferStream extends DataStream {
	buffers: Array<MP4BoxBuffer>;
	bufferIndex: number;
	constructor(buffer?: MP4BoxBuffer);
	/***********************************************************************************
	 *                     Methods for the managnement of the buffers                  *
	 *                     (insertion, removal, concatenation, ...)                    *
	 ***********************************************************************************/
	initialized(): boolean;
	/**
	 * Reduces the size of a given buffer, but taking the part between offset and offset+newlength
	 * @param  {ArrayBuffer} buffer
	 * @param  {Number}      offset    the start of new buffer
	 * @param  {Number}      newLength the length of the new buffer
	 * @return {ArrayBuffer}           the new buffer
	 */
	reduceBuffer(buffer: MP4BoxBuffer, offset: number, newLength: number): MP4BoxBuffer;
	/**
	 * Inserts the new buffer in the sorted list of buffers,
	 *  making sure, it is not overlapping with existing ones (possibly reducing its size).
	 *  if the new buffer overrides/replaces the 0-th buffer (for instance because it is bigger),
	 *  updates the DataStream buffer for parsing
	 */
	insertBuffer(ab: MP4BoxBuffer): void;
	/**
	 * Displays the status of the buffers (number and used bytes)
	 * @param  {Object} info callback method for display
	 */
	logBufferLevel(info?: boolean): void;
	cleanBuffers(): void;
	mergeNextBuffer(): boolean;
	/*************************************************************************
	 *                        Seek-related functions                         *
	 *************************************************************************/
	/**
	 * Finds the buffer that holds the given file position
	 * @param  {Boolean} fromStart    indicates if the search should start from the current buffer (false)
	 *                                or from the first buffer (true)
	 * @param  {Number}  filePosition position in the file to seek to
	 * @param  {Boolean} markAsUsed   indicates if the bytes in between the current position and the seek position
	 *                                should be marked as used for garbage collection
	 * @return {Number}               the index of the buffer holding the seeked file position, -1 if not found.
	 */
	findPosition(fromStart: boolean, filePosition: number, markAsUsed: boolean): number;
	/**
	 * Finds the largest file position contained in a buffer or in the next buffers if they are contiguous (no gap)
	 * starting from the given buffer index or from the current buffer if the index is not given
	 *
	 * @param  {Number} inputindex Index of the buffer to start from
	 * @return {Number}            The largest file position found in the buffers
	 */
	findEndContiguousBuf(inputindex?: number): number;
	/**
	 * Returns the largest file position contained in the buffers, larger than the given position
	 * @param  {Number} pos the file position to start from
	 * @return {Number}     the largest position in the current buffer or in the buffer and the next contiguous
	 *                      buffer that holds the given position
	 */
	getEndFilePositionAfter(pos: number): number;
	/*************************************************************************
	 *                  Garbage collection related functions                 *
	 *************************************************************************/
	/**
	 * Marks a given number of bytes as used in the current buffer for garbage collection
	 * @param {Number} nbBytes
	 */
	addUsedBytes(nbBytes: number): void;
	/**
	 * Marks the entire current buffer as used, ready for garbage collection
	 */
	setAllUsedBytes(): void;
	/*************************************************************************
	 *          Common API between MultiBufferStream and SimpleStream        *
	 *************************************************************************/
	/**
	 * Tries to seek to a given file position
	 * if possible, repositions the parsing from there and returns true
	 * if not possible, does not change anything and returns false
	 * @param  {Number}  filePosition position in the file to seek to
	 * @param  {Boolean} fromStart    indicates if the search should start from the current buffer (false)
	 *                                or from the first buffer (true)
	 * @param  {Boolean} markAsUsed   indicates if the bytes in between the current position and the seek position
	 *                                should be marked as used for garbage collection
	 * @return {Boolean}              true if the seek succeeded, false otherwise
	 */
	seek(filePosition: number, fromStart?: boolean, markAsUsed?: boolean): boolean;
	/**
	 * Returns the current position in the file
	 * @return {Number} the position in the file
	 */
	getPosition(): number;
	/**
	 * Returns the length of the current buffer
	 * @return {Number} the length of the current buffer
	 */
	getLength(): number;
	getEndPosition(): number;
}
export declare class SampleEntry extends SampleEntryBase {
	static codes: Record<SampleEntryType, Array<string>>;
	constructor(type: string, size: number | undefined, sampleEntryType: SampleEntryType);
}
export declare class SampleGroupEntry {
	grouping_type: string;
	static codes: Array<string>;
	data: ArrayLike<number>;
	description_length: number;
	constructor(grouping_type: string);
	/** @bundle writing/samplegroups/samplegroup.js */
	write(stream: MultiBufferStream): void;
	/** @bundle parsing/samplegroups/samplegroup.js */
	parse(stream: MultiBufferStream): void;
}
export declare class SampleGroupInfo {
	grouping_type: unknown;
	grouping_type_parameter: unknown;
	sbgp?: sbgpBox;
	last_sample_in_run: number;
	entry_index: number;
	description: Description;
	fragment_description: Description;
	is_fragment: boolean;
	constructor(grouping_type: unknown, grouping_type_parameter: unknown, sbgp?: sbgpBox);
}
/** @bundle parsing/singleitemtypereference.js */
export declare class SingleItemTypeReferenceBox extends BoxBase {
	hdr_size: number;
	start: number;
	from_item_ID: number;
	references: Array<{
		to_item_ID: number;
	}>;
	constructor(type: string, size: number, hdr_size: number, start: number);
	parse(stream: MultiBufferStream): void;
}
/** @bundle parsing/singleitemtypereferencelarge.js */
export declare class SingleItemTypeReferenceBoxLarge extends BoxBase {
	hdr_size: number;
	start: number;
	from_item_ID: number;
	references: Array<{
		to_item_ID: number;
	}>;
	constructor(type: string, size: number, hdr_size: number, start: number);
	parse(stream: MultiBufferStream): void;
}
export declare class Textin4Parser {
	parseSample(sample: Sample): string;
	parseConfig(data: TypedArray): string;
}
export declare class TrackGroupTypeBox extends FullBoxBase {
	track_group_id: number;
	static codes: Array<string>;
	constructor(type: string, size: number);
	/** @bundle parsing/TrackGroup.js */
	parse(stream: MultiBufferStream): void;
}
/** @bundle parsing/TrakReference.js */
export declare class TrackReferenceTypeBox extends BoxBase {
	hdr_size: number;
	start: number;
	constructor(type: string, size: number, hdr_size: number, start: number);
	parse(stream: DataStream): void;
	/** @bundle box-write.js */
	write(stream: DataStream): void;
}
export declare class UUIDBox extends FullBoxBase {
	static codes: Record<string, typeof UUIDBox>;
	constructor(uuid: string, size?: number);
}
export declare class VTTin4Parser {
	parseSample(data: TypedArray): Box[];
	getText(startTime: number, endTime: number, data: TypedArray): string;
}
export declare class XMLSubtitlein4Parser {
	parseSample(sample: Sample): {
		resources: Array<Uint8Array>;
		documentString: string;
		document: undefined | Document;
	};
}
export declare const BoxParser: {
	a5d40b30e81411ddba2f0800200c9a66: {
		new (size?: number): {
			LiveServerManifest: string;
			parse(stream: MultiBufferStream): void;
			flags: number;
			version: number;
			writeHeader(stream: MultiBufferStream): void;
			printHeader(output: Output): void;
			parseDataAndRewind(stream: MultiBufferStream): void;
			parseFullHeader(stream: MultiBufferStream): void;
			boxes: Array<{
				boxes: Array<any>;
				data: Array<number> | Uint8Array;
				hdr_size?: number;
				language: number;
				languageString?: string;
				sizePosition?: number;
				start?: number;
				track_ids?: Uint32Array;
				type: string;
				size: number;
				uuid?: string;
				addBox<T extends Box>(box: T): T;
				set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
				addEntry(value: Box, _prop?: string): any;
				writeHeader(stream: DataStream, msg?: string): void;
				write(stream: DataStream): void;
				printHeader(output: Output): void;
				print(output: Output): void;
				parse(stream: MultiBufferStream): void;
				parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
				parseLanguage(stream: MultiBufferStream): void;
				computeSize(stream_?: MultiBufferStream): void;
			}>;
			data: Array<number> | Uint8Array;
			hdr_size?: number;
			language: number;
			languageString?: string;
			sizePosition?: number;
			start?: number;
			track_ids?: Uint32Array;
			type: string;
			size: number;
			uuid?: string;
			addBox<T extends Box>(box: T): T;
			set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
			addEntry(value: Box, _prop?: string): any;
			write(stream: DataStream): void;
			print(output: Output): void;
			parseLanguage(stream: MultiBufferStream): void;
			computeSize(stream_?: MultiBufferStream): void;
		};
		codes: Record<string, typeof UUIDBox>;
	};
	d08a4f1810f34a82b6c832d8aba183d3: {
		new (size?: number): {
			system_id: string;
			parse(stream: MultiBufferStream): void;
			flags: number;
			version: number;
			writeHeader(stream: MultiBufferStream): void;
			printHeader(output: Output): void;
			parseDataAndRewind(stream: MultiBufferStream): void;
			parseFullHeader(stream: MultiBufferStream): void;
			boxes: Array<{
				boxes: Array<any>;
				data: Array<number> | Uint8Array;
				hdr_size?: number;
				language: number;
				languageString?: string;
				sizePosition?: number;
				start?: number;
				track_ids?: Uint32Array;
				type: string;
				size: number;
				uuid?: string;
				addBox<T extends Box>(box: T): T;
				set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
				addEntry(value: Box, _prop?: string): any;
				writeHeader(stream: DataStream, msg?: string): void;
				write(stream: DataStream): void;
				printHeader(output: Output): void;
				print(output: Output): void;
				parse(stream: MultiBufferStream): void;
				parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
				parseLanguage(stream: MultiBufferStream): void;
				computeSize(stream_?: MultiBufferStream): void;
			}>;
			data: Array<number> | Uint8Array;
			hdr_size?: number;
			language: number;
			languageString?: string;
			sizePosition?: number;
			start?: number;
			track_ids?: Uint32Array;
			type: string;
			size: number;
			uuid?: string;
			addBox<T extends Box>(box: T): T;
			set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
			addEntry(value: Box, _prop?: string): any;
			write(stream: DataStream): void;
			print(output: Output): void;
			parseLanguage(stream: MultiBufferStream): void;
			computeSize(stream_?: MultiBufferStream): void;
		};
		codes: Record<string, typeof UUIDBox>;
	};
	a2394f525a9b4f14a2446c427c648df4: {
		new (size?: number): {
			flags: number;
			version: number;
			writeHeader(stream: MultiBufferStream): void;
			printHeader(output: Output): void;
			parseDataAndRewind(stream: MultiBufferStream): void;
			parseFullHeader(stream: MultiBufferStream): void;
			parse(stream: MultiBufferStream): void;
			boxes: Array<{
				boxes: Array<any>;
				data: Array<number> | Uint8Array;
				hdr_size?: number;
				language: number;
				languageString?: string;
				sizePosition?: number;
				start?: number;
				track_ids?: Uint32Array;
				type: string;
				size: number;
				uuid?: string;
				addBox<T extends Box>(box: T): T;
				set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
				addEntry(value: Box, _prop?: string): any;
				writeHeader(stream: DataStream, msg?: string): void;
				write(stream: DataStream): void;
				printHeader(output: Output): void;
				print(output: Output): void;
				parse(stream: MultiBufferStream): void;
				parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
				parseLanguage(stream: MultiBufferStream): void;
				computeSize(stream_?: MultiBufferStream): void;
			}>;
			data: Array<number> | Uint8Array;
			hdr_size?: number;
			language: number;
			languageString?: string;
			sizePosition?: number;
			start?: number;
			track_ids?: Uint32Array;
			type: string;
			size: number;
			uuid?: string;
			addBox<T extends Box>(box: T): T;
			set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
			addEntry(value: Box, _prop?: string): any;
			write(stream: DataStream): void;
			print(output: Output): void;
			parseLanguage(stream: MultiBufferStream): void;
			computeSize(stream_?: MultiBufferStream): void;
		};
		codes: Record<string, typeof UUIDBox>;
	};
	"8974dbce7be74c5184f97148f9882554": {
		new (size?: number): {
			default_AlgorithmID: number;
			default_IV_size: number;
			default_KID: string;
			parse(stream: MultiBufferStream): void;
			flags: number;
			version: number;
			writeHeader(stream: MultiBufferStream): void;
			printHeader(output: Output): void;
			parseDataAndRewind(stream: MultiBufferStream): void;
			parseFullHeader(stream: MultiBufferStream): void;
			boxes: Array<{
				boxes: Array<any>;
				data: Array<number> | Uint8Array;
				hdr_size?: number;
				language: number;
				languageString?: string;
				sizePosition?: number;
				start?: number;
				track_ids?: Uint32Array;
				type: string;
				size: number;
				uuid?: string;
				addBox<T extends Box>(box: T): T;
				set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
				addEntry(value: Box, _prop?: string): any;
				writeHeader(stream: DataStream, msg?: string): void;
				write(stream: DataStream): void;
				printHeader(output: Output): void;
				print(output: Output): void;
				parse(stream: MultiBufferStream): void;
				parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
				parseLanguage(stream: MultiBufferStream): void;
				computeSize(stream_?: MultiBufferStream): void;
			}>;
			data: Array<number> | Uint8Array;
			hdr_size?: number;
			language: number;
			languageString?: string;
			sizePosition?: number;
			start?: number;
			track_ids?: Uint32Array;
			type: string;
			size: number;
			uuid?: string;
			addBox<T extends Box>(box: T): T;
			set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
			addEntry(value: Box, _prop?: string): any;
			write(stream: DataStream): void;
			print(output: Output): void;
			parseLanguage(stream: MultiBufferStream): void;
			computeSize(stream_?: MultiBufferStream): void;
		};
		codes: Record<string, typeof UUIDBox>;
	};
	d4807ef2ca3946958e5426cb9e46a79f: {
		new (size?: number): {
			fragment_count: number;
			entries: {
				absolute_time: number;
				absolute_duration: number;
			}[];
			parse(stream: MultiBufferStream): void;
			flags: number;
			version: number;
			writeHeader(stream: MultiBufferStream): void;
			printHeader(output: Output): void;
			parseDataAndRewind(stream: MultiBufferStream): void;
			parseFullHeader(stream: MultiBufferStream): void;
			boxes: Array<{
				boxes: Array<any>;
				data: Array<number> | Uint8Array;
				hdr_size?: number;
				language: number;
				languageString?: string;
				sizePosition?: number;
				start?: number;
				track_ids?: Uint32Array;
				type: string;
				size: number;
				uuid?: string;
				addBox<T extends Box>(box: T): T;
				set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
				addEntry(value: Box, _prop?: string): any;
				writeHeader(stream: DataStream, msg?: string): void;
				write(stream: DataStream): void;
				printHeader(output: Output): void;
				print(output: Output): void;
				parse(stream: MultiBufferStream): void;
				parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
				parseLanguage(stream: MultiBufferStream): void;
				computeSize(stream_?: MultiBufferStream): void;
			}>;
			data: Array<number> | Uint8Array;
			hdr_size?: number;
			language: number;
			languageString?: string;
			sizePosition?: number;
			start?: number;
			track_ids?: Uint32Array;
			type: string;
			size: number;
			uuid?: string;
			addBox<T extends Box>(box: T): T;
			set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
			addEntry(value: Box, _prop?: string): any;
			write(stream: DataStream): void;
			print(output: Output): void;
			parseLanguage(stream: MultiBufferStream): void;
			computeSize(stream_?: MultiBufferStream): void;
		};
		codes: Record<string, typeof UUIDBox>;
	};
	"6d1d9b0542d544e680e2141daff757b2": {
		new (size?: number): {
			absolute_time: number;
			duration: number;
			parse(stream: MultiBufferStream): void;
			flags: number;
			version: number;
			writeHeader(stream: MultiBufferStream): void;
			printHeader(output: Output): void;
			parseDataAndRewind(stream: MultiBufferStream): void;
			parseFullHeader(stream: MultiBufferStream): void;
			boxes: Array<{
				boxes: Array<any>;
				data: Array<number> | Uint8Array;
				hdr_size?: number;
				language: number;
				languageString?: string;
				sizePosition?: number;
				start?: number;
				track_ids?: Uint32Array;
				type: string;
				size: number;
				uuid?: string;
				addBox<T extends Box>(box: T): T;
				set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
				addEntry(value: Box, _prop?: string): any;
				writeHeader(stream: DataStream, msg?: string): void;
				write(stream: DataStream): void;
				printHeader(output: Output): void;
				print(output: Output): void;
				parse(stream: MultiBufferStream): void;
				parseDataAndRewind(stream: MultiBufferStream | MP4BoxStream): void;
				parseLanguage(stream: MultiBufferStream): void;
				computeSize(stream_?: MultiBufferStream): void;
			}>;
			data: Array<number> | Uint8Array;
			hdr_size?: number;
			language: number;
			languageString?: string;
			sizePosition?: number;
			start?: number;
			track_ids?: Uint32Array;
			type: string;
			size: number;
			uuid?: string;
			addBox<T extends Box>(box: T): T;
			set<TProp extends keyof any>(prop: TProp, value: any[TProp]): any;
			addEntry(value: Box, _prop?: string): any;
			write(stream: DataStream): void;
			print(output: Output): void;
			parseLanguage(stream: MultiBufferStream): void;
			computeSize(stream_?: MultiBufferStream): void;
		};
		codes: Record<string, typeof UUIDBox>;
	};
	a1lxBox: typeof BOXES.a1lxBox;
	a1opBox: typeof BOXES.a1opBox;
	auxCBox: typeof BOXES.auxCBox;
	av1CBox: typeof BOXES.av1CBox;
	avcCBox: typeof BOXES.avcCBox;
	btrtBox: typeof BOXES.btrtBox;
	ccstBox: typeof BOXES.ccstBox;
	cdefBox: typeof BOXES.cdefBox;
	clapBox: typeof BOXES.clapBox;
	clliBox: typeof BOXES.clliBox;
	cmexBox: typeof BOXES.cmexBox;
	cminBox: typeof BOXES.cminBox;
	cmpdBox: typeof BOXES.cmpdBox;
	co64Box: typeof BOXES.co64Box;
	CoLLBox: typeof BOXES.CoLLBox;
	colrBox: typeof BOXES.colrBox;
	cprtBox: typeof BOXES.cprtBox;
	cslgBox: typeof BOXES.cslgBox;
	cttsBox: typeof BOXES.cttsBox;
	dac3Box: typeof BOXES.dac3Box;
	dec3Box: typeof BOXES.dec3Box;
	mdatBox: typeof BOXES.mdatBox;
	idatBox: typeof BOXES.idatBox;
	freeBox: typeof BOXES.freeBox;
	skipBox: typeof BOXES.skipBox;
	hmhdBox: typeof BOXES.hmhdBox;
	nmhdBox: typeof BOXES.nmhdBox;
	iodsBox: typeof BOXES.iodsBox;
	xmlBox: typeof BOXES.xmlBox;
	bxmlBox: typeof BOXES.bxmlBox;
	iproBox: typeof BOXES.iproBox;
	moovBox: typeof BOXES.moovBox;
	trakBox: typeof BOXES.trakBox;
	edtsBox: typeof BOXES.edtsBox;
	mdiaBox: typeof BOXES.mdiaBox;
	minfBox: typeof BOXES.minfBox;
	dinfBox: typeof BOXES.dinfBox;
	stblBox: typeof BOXES.stblBox;
	mvexBox: typeof BOXES.mvexBox;
	moofBox: typeof BOXES.moofBox;
	trafBox: typeof BOXES.trafBox;
	vttcBox: typeof BOXES.vttcBox;
	mfraBox: typeof BOXES.mfraBox;
	mecoBox: typeof BOXES.mecoBox;
	hntiBox: typeof BOXES.hntiBox;
	hinfBox: typeof BOXES.hinfBox;
	strkBox: typeof BOXES.strkBox;
	strdBox: typeof BOXES.strdBox;
	sinfBox: typeof BOXES.sinfBox;
	rinfBox: typeof BOXES.rinfBox;
	schiBox: typeof BOXES.schiBox;
	trgrBox: typeof BOXES.trgrBox;
	udtaBox: typeof BOXES.udtaBox;
	iprpBox: typeof BOXES.iprpBox;
	ipcoBox: typeof BOXES.ipcoBox;
	grplBox: typeof BOXES.grplBox;
	j2kHBox: typeof BOXES.j2kHBox;
	etypBox: typeof BOXES.etypBox;
	dfLaBox: typeof BOXES.dfLaBox;
	dimmBox: typeof BOXES.dimmBox;
	dmax: typeof BOXES.dmax;
	dmedBox: typeof BOXES.dmedBox;
	dOpsBox: typeof BOXES.dOpsBox;
	drefBox: typeof BOXES.drefBox;
	drepBox: typeof BOXES.drepBox;
	elngBox: typeof BOXES.elngBox;
	elstBox: typeof BOXES.elstBox;
	emsgBox: typeof BOXES.emsgBox;
	EntityToGroup: typeof BOXES.EntityToGroup;
	aebrBox: typeof BOXES.aebrBox;
	afbrBox: typeof BOXES.afbrBox;
	albcBox: typeof BOXES.albcBox;
	altrBox: typeof BOXES.altrBox;
	brstBox: typeof BOXES.brstBox;
	dobrBox: typeof BOXES.dobrBox;
	eqivBox: typeof BOXES.eqivBox;
	favcBox: typeof BOXES.favcBox;
	fobrBox: typeof BOXES.fobrBox;
	iaugBox: typeof BOXES.iaugBox;
	panoBox: typeof BOXES.panoBox;
	slidBox: typeof BOXES.slidBox;
	sterBox: typeof BOXES.sterBox;
	tsynBox: typeof BOXES.tsynBox;
	wbbrBox: typeof BOXES.wbbrBox;
	prgrBox: typeof BOXES.prgrBox;
	pymdBox: typeof BOXES.pymdBox;
	esdsBox: typeof BOXES.esdsBox;
	fielBox: typeof BOXES.fielBox;
	frmaBox: typeof BOXES.frmaBox;
	ftypBox: typeof BOXES.ftypBox;
	hdlrBox: typeof BOXES.hdlrBox;
	hvcCBox: typeof BOXES.hvcCBox;
	iinfBox: typeof BOXES.iinfBox;
	ilocBox: typeof BOXES.ilocBox;
	imirBox: typeof BOXES.imirBox;
	infeBox: typeof BOXES.infeBox;
	ipmaBox: typeof BOXES.ipmaBox;
	irefBox: typeof BOXES.irefBox;
	irotBox: typeof BOXES.irotBox;
	ispeBox: typeof BOXES.ispeBox;
	kindBox: typeof BOXES.kindBox;
	levaBox: typeof BOXES.levaBox;
	lhvCBox: typeof BOXES.lhvCBox;
	lselBox: typeof BOXES.lselBox;
	maxrBox: typeof BOXES.maxrBox;
	mdcvBox: typeof BOXES.mdcvBox;
	mdhdBox: typeof BOXES.mdhdBox;
	mehdBox: typeof BOXES.mehdBox;
	metaBox: typeof BOXES.metaBox;
	mfhdBox: typeof BOXES.mfhdBox;
	mfroBox: typeof BOXES.mfroBox;
	mskCBox: typeof BOXES.mskCBox;
	mvhdBox: typeof BOXES.mvhdBox;
	npckBox: typeof BOXES.npckBox;
	numpBox: typeof BOXES.numpBox;
	padbBox: typeof BOXES.padbBox;
	paspBox: typeof BOXES.paspBox;
	paylBox: typeof BOXES.paylBox;
	paytBox: typeof BOXES.paytBox;
	pdinBox: typeof BOXES.pdinBox;
	pitmBox: typeof BOXES.pitmBox;
	pixiBox: typeof BOXES.pixiBox;
	pmaxBox: typeof BOXES.pmaxBox;
	prdiBox: typeof BOXES.prdiBox;
	prftBox: typeof BOXES.prftBox;
	psshBox: typeof BOXES.psshBox;
	clefBox: typeof BOXES.clefBox;
	enofBox: typeof BOXES.enofBox;
	profBox: typeof BOXES.profBox;
	taptBox: typeof BOXES.taptBox;
	rtpBox: typeof BOXES.rtpBox;
	saioBox: typeof BOXES.saioBox;
	saizBox: typeof BOXES.saizBox;
	mettSampleEntry: typeof BOXES.mettSampleEntry;
	metxSampleEntry: typeof BOXES.metxSampleEntry;
	HintSampleEntry: typeof BOXES.HintSampleEntry;
	MetadataSampleEntry: typeof BOXES.MetadataSampleEntry;
	SubtitleSampleEntry: typeof BOXES.SubtitleSampleEntry;
	SystemSampleEntry: typeof BOXES.SystemSampleEntry;
	TextSampleEntry: typeof BOXES.TextSampleEntry;
	VisualSampleEntry: typeof BOXES.VisualSampleEntry;
	AudioSampleEntry: typeof BOXES.AudioSampleEntry;
	avc1SampleEntry: typeof BOXES.avc1SampleEntry;
	avc2SampleEntry: typeof BOXES.avc2SampleEntry;
	avc3SampleEntry: typeof BOXES.avc3SampleEntry;
	avc4SampleEntry: typeof BOXES.avc4SampleEntry;
	av01SampleEntry: typeof BOXES.av01SampleEntry;
	dav1SampleEntry: typeof BOXES.dav1SampleEntry;
	hvc1SampleEntry: typeof BOXES.hvc1SampleEntry;
	hev1SampleEntry: typeof BOXES.hev1SampleEntry;
	hvt1SampleEntry: typeof BOXES.hvt1SampleEntry;
	lhe1SampleEntry: typeof BOXES.lhe1SampleEntry;
	dvh1SampleEntry: typeof BOXES.dvh1SampleEntry;
	dvheSampleEntry: typeof BOXES.dvheSampleEntry;
	vvc1SampleEntry: typeof BOXES.vvc1SampleEntry;
	vvi1SampleEntry: typeof BOXES.vvi1SampleEntry;
	vvs1SampleEntry: typeof BOXES.vvs1SampleEntry;
	vvcNSampleEntry: typeof BOXES.vvcNSampleEntry;
	vp08SampleEntry: typeof BOXES.vp08SampleEntry;
	vp09SampleEntry: typeof BOXES.vp09SampleEntry;
	avs3SampleEntry: typeof BOXES.avs3SampleEntry;
	j2kiSampleEntry: typeof BOXES.j2kiSampleEntry;
	mjp2SampleEntry: typeof BOXES.mjp2SampleEntry;
	mjpgSampleEntry: typeof BOXES.mjpgSampleEntry;
	uncvSampleEntry: typeof BOXES.uncvSampleEntry;
	mp4aSampleEntry: typeof BOXES.mp4aSampleEntry;
	ac_3SampleEntry: typeof BOXES.ac_3SampleEntry;
	ac_4SampleEntry: typeof BOXES.ac_4SampleEntry;
	ec_3SampleEntry: typeof BOXES.ec_3SampleEntry;
	OpusSampleEntry: typeof BOXES.OpusSampleEntry;
	mha1SampleEntry: typeof BOXES.mha1SampleEntry;
	mha2SampleEntry: typeof BOXES.mha2SampleEntry;
	mhm1SampleEntry: typeof BOXES.mhm1SampleEntry;
	mhm2SampleEntry: typeof BOXES.mhm2SampleEntry;
	fLaCSampleEntry: typeof BOXES.fLaCSampleEntry;
	encvSampleEntry: typeof BOXES.encvSampleEntry;
	encaSampleEntry: typeof BOXES.encaSampleEntry;
	encuSampleEntry: typeof BOXES.encuSampleEntry;
	encsSampleEntry: typeof BOXES.encsSampleEntry;
	enctSampleEntry: typeof BOXES.enctSampleEntry;
	encmSampleEntry: typeof BOXES.encmSampleEntry;
	sbttSampleEntry: typeof BOXES.sbttSampleEntry;
	stppSampleEntry: typeof BOXES.stppSampleEntry;
	stxtSampleEntry: typeof BOXES.stxtSampleEntry;
	tx3gSampleEntry: typeof BOXES.tx3gSampleEntry;
	wvttSampleEntry: typeof BOXES.wvttSampleEntry;
	sbgpBox: typeof BOXES.sbgpBox;
	sbpmBox: typeof BOXES.sbpmBox;
	schmBox: typeof BOXES.schmBox;
	sdpBox: typeof BOXES.sdpBox;
	sdtpBox: typeof BOXES.sdtpBox;
	sencBox: typeof BOXES.sencBox;
	sgpdBox: typeof BOXES.sgpdBox;
	sidxBox: typeof BOXES.sidxBox;
	SmDmBox: typeof BOXES.SmDmBox;
	smhdBox: typeof BOXES.smhdBox;
	ssixBox: typeof BOXES.ssixBox;
	stcoBox: typeof BOXES.stcoBox;
	stdpBox: typeof BOXES.stdpBox;
	sthdBox: typeof BOXES.sthdBox;
	striBox: typeof BOXES.striBox;
	stscBox: typeof BOXES.stscBox;
	stsdBox: typeof BOXES.stsdBox;
	stsgBox: typeof BOXES.stsgBox;
	stshBox: typeof BOXES.stshBox;
	stssBox: typeof BOXES.stssBox;
	stszBox: typeof BOXES.stszBox;
	sttsBox: typeof BOXES.sttsBox;
	stviBox: typeof BOXES.stviBox;
	stypBox: typeof BOXES.stypBox;
	stz2Box: typeof BOXES.stz2Box;
	subsBox: typeof BOXES.subsBox;
	tencBox: typeof BOXES.tencBox;
	tfdtBox: typeof BOXES.tfdtBox;
	tfraBox: typeof BOXES.tfraBox;
	tkhdBox: typeof BOXES.tkhdBox;
	tmaxBox: typeof BOXES.tmaxBox;
	tminBox: typeof BOXES.tminBox;
	totlBox: typeof BOXES.totlBox;
	tpayBox: typeof BOXES.tpayBox;
	tpylBox: typeof BOXES.tpylBox;
	msrcTrackGroupTypeBox: typeof BOXES.msrcTrackGroupTypeBox;
	trefBox: typeof BOXES.trefBox;
	trepBox: typeof BOXES.trepBox;
	trexBox: typeof BOXES.trexBox;
	trpyBox: typeof BOXES.trpyBox;
	trunBox: typeof BOXES.trunBox;
	tselBox: typeof BOXES.tselBox;
	txtcBox: typeof BOXES.txtcBox;
	tycoBox: typeof BOXES.tycoBox;
	udesBox: typeof BOXES.udesBox;
	uncCBox: typeof BOXES.uncCBox;
	urlBox: typeof BOXES.urlBox;
	urnBox: typeof BOXES.urnBox;
	vmhdBox: typeof BOXES.vmhdBox;
	vpcCBox: typeof BOXES.vpcCBox;
	vttCBox: typeof BOXES.vttCBox;
	vvcCBox: typeof BOXES.vvcCBox;
	vvnCBox: typeof BOXES.vvnCBox;
	alstSampleGroupEntry: typeof BOXES.alstSampleGroupEntry;
	avllSampleGroupEntry: typeof BOXES.avllSampleGroupEntry;
	avssSampleGroupEntry: typeof BOXES.avssSampleGroupEntry;
	dtrtSampleGroupEntry: typeof BOXES.dtrtSampleGroupEntry;
	mvifSampleGroupEntry: typeof BOXES.mvifSampleGroupEntry;
	prolSampleGroupEntry: typeof BOXES.prolSampleGroupEntry;
	rapSampleGroupEntry: typeof BOXES.rapSampleGroupEntry;
	rashSampleGroupEntry: typeof BOXES.rashSampleGroupEntry;
	rollSampleGroupEntry: typeof BOXES.rollSampleGroupEntry;
	scifSampleGroupEntry: typeof BOXES.scifSampleGroupEntry;
	scnmSampleGroupEntry: typeof BOXES.scnmSampleGroupEntry;
	seigSampleGroupEntry: typeof BOXES.seigSampleGroupEntry;
	stsaSampleGroupEntry: typeof BOXES.stsaSampleGroupEntry;
	syncSampleGroupEntry: typeof BOXES.syncSampleGroupEntry;
	teleSampleGroupEntry: typeof BOXES.teleSampleGroupEntry;
	tsasSampleGroupEntry: typeof BOXES.tsasSampleGroupEntry;
	tsclSampleGroupEntry: typeof BOXES.tsclSampleGroupEntry;
	viprSampleGroupEntry: typeof BOXES.viprSampleGroupEntry;
};
export declare const DIFF_BOXES_PROP_NAMES: readonly [
	"boxes",
	"entries",
	"references",
	"subsamples",
	"items",
	"item_infos",
	"extents",
	"associations",
	"subsegments",
	"ranges",
	"seekLists",
	"seekPoints",
	"esd",
	"levels"
];
export declare const DIFF_PRIMITIVE_ARRAY_PROP_NAMES: readonly [
	"compatible_brands",
	"matrix",
	"opcolor",
	"sample_counts",
	"sample_counts",
	"sample_deltas",
	"first_chunk",
	"samples_per_chunk",
	"sample_sizes",
	"chunk_offsets",
	"sample_offsets",
	"sample_description_index",
	"sample_duration"
];
export declare function boxEqual(box_a: KindOf<MP4Box.BoxRegistry>, box_b: KindOf<MP4Box.BoxRegistry>): boolean;
/** @bundle box-diff.js */
export declare function boxEqualFields(box_a: KindOf<MP4Box.BoxRegistry>, box_b: KindOf<MP4Box.BoxRegistry>): boolean;
export declare function createFile(keepMdatData?: boolean, stream?: MultiBufferStream): ISOFile;
export declare function parseHex16(stream: MultiBufferStream | MP4BoxStream): string;
export declare function parseOneBox(stream: MultiBufferStream | MP4BoxStream, headerOnly: boolean, parentSize?: number): {
	code: number;
	box?: undefined;
	size?: undefined;
	type?: undefined;
	hdr_size?: undefined;
	start?: undefined;
} | {
	code: number;
	box: Box;
	size: number;
	type?: undefined;
	hdr_size?: undefined;
	start?: undefined;
} | {
	code: number;
	type: string;
	size: number;
	hdr_size: number;
	start: number;
	box?: undefined;
};
/**********************************************************************************/
/**********************************************************************************/
export declare function parseUUID(stream: MultiBufferStream | MP4BoxStream): string;
export interface Assocation {
	id: number;
	props: Array<{
		property_index: number;
		essential: boolean;
	}>;
}
export interface Description {
	used: boolean;
	default_group_description_index: number;
	entries: Array<unknown>;
	version: number;
}
export interface Entry {
	segment_duration: number;
	media_time: number;
	media_rate_integer: number;
	media_rate_fraction: number;
}
export interface Extent {
	extent_index: number;
	extent_offset: number;
	extent_length: number;
}
export interface ExtractedTrack {
	id: number;
	user: unknown;
	trak: trakBox;
	nb_samples: number;
	samples: Array<Sample>;
}
export interface FragmentedTrack {
	id: number;
	user: unknown;
	trak: trakBox;
	segmentStream: DataStream;
	nb_samples: number;
	rapAlignement: boolean;
}
export interface IndSub {
	fscod: number;
	bsid: number;
	bsmod: number;
	acmod: number;
	lfeon: number;
	num_dep_sub: number;
	chan_loc?: number;
}
export interface IsoFileOptions {
	brands?: Array<string>;
	description_boxes?: Array<Box>;
	duration?: number;
	height?: number;
	id?: number;
	language?: string;
	layer?: number;
	media_duration?: number;
	rate?: number;
	timescale?: number;
	type?: unknown;
	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;
}
export interface Item {
	id?: number;
	ref_to?: Array<{
		type: unknown;
		id: unknown;
	}>;
	name?: string;
	protection?: unknown;
	type?: string;
	content_type?: string;
	content_encoding?: string;
	source?: unknown;
	extents?: Array<{
		alreadyRead?: number;
		length: number;
		offset: number;
	}>;
	size?: number;
	properties?: {
		boxes: Array<Box>;
	};
	alreadyRead?: number;
	data?: Uint8Array;
	primary?: boolean;
	sent?: boolean;
}
export interface Level {
	padding_flag: number;
	track_ID: number;
	assignment_type: number;
	grouping_type: string;
	grouping_type_parameter: number;
	sub_track_id: number;
}
export interface Movie {
	hasMoov?: boolean;
	duration?: number;
	timescale?: number;
	isFragmented?: boolean;
	fragment_duration?: unknown;
	isProgressive?: boolean;
	hasIOD?: boolean;
	brands?: Array<string>;
	created?: unknown;
	modified?: unknown;
	tracks?: Array<Track>;
	audioTracks?: Array<Track>;
	videoTracks?: Array<Track>;
	subtitleTracks?: Array<Track>;
	metadataTracks?: Array<Track>;
	hintTracks?: Array<Track>;
	otherTracks?: Array<Track>;
	mime: string;
}
export interface Nalu {
	data: Uint8Array;
	length?: number;
}
export interface Output {
	log: (message: string) => void;
	indent: string;
}
export interface Reference {
	reference_type: number;
	referenced_size: number;
	subsegment_duration: number;
	starts_with_SAP: number;
	SAP_type: number;
	SAP_delta_time: number;
}
export interface Sample {
	alreadyRead?: number;
	cts?: number;
	data?: Uint8Array;
	degradation_priority?: number;
	depends_on?: number;
	description_index?: number;
	description?: Description["entries"][number];
	dts?: number;
	pts?: number;
	duration?: number;
	has_redundancy?: number;
	is_depended_on?: number;
	is_leading?: number;
	is_sync?: boolean;
	moof_number?: number;
	number_in_traf?: number;
	number?: number;
	offset?: number;
	size?: number;
	subsamples?: Array<SubSample>;
	timescale?: number;
	track_id?: number;
	sample_groups?: Array<SampleGroup>;
	chunk_index?: number;
	chunk_run_index?: number;
}
export interface SampleGroup {
	grouping_type: unknown;
	grouping_type_parameter: unknown;
	group_description_index: number;
	description: Description["entries"][number];
}
export interface SampleInfo {
	size: number;
	sample_delta: number;
	subsamples: SubSample[];
}
export interface SubSample {
	size: number;
	priority: number;
	discardable: number;
	codec_specific_parameters: number;
}
export interface SubSegment {
	ranges: Array<Range$1>;
}
export interface Track {
	alternate_group?: unknown;
	audio?: {
		sample_rate: number;
		channel_count: number;
		sample_size: number;
	};
	bitrate?: unknown;
	codec?: unknown;
	created?: unknown;
	cts_shift?: unknown;
	duration?: unknown;
	edits?: unknown;
	id?: unknown;
	kind?: unknown;
	language?: unknown;
	layer?: unknown;
	matrix?: unknown;
	modified?: unknown;
	movie_duration?: number;
	movie_timescale?: number;
	name?: string;
	nb_samples?: number;
	references?: Array<{
		track_ids: ArrayLike<number>;
		type: string;
	}>;
	samples_duration?: number;
	samples?: Array<Sample>;
	size?: number;
	timescale?: number;
	track_height?: number;
	track_width?: number;
	type?: unknown;
	video?: {
		width: number;
		height: number;
	};
	volume?: number;
}
export type ArrayType = [
	"[]",
	PrimitiveType | EndianType,
	number | string | ((struct: unknown, dataStream: unknown, type: unknown) => number)
];
export type ComplexType = {
	get(dataStream: unknown, struct: unknown): unknown;
	set?(dataStream: unknown, struct: unknown): void;
} | [
	name: string,
	type: StructDefinition
];
export type DescriptorKinds = Descriptor | ES_Descriptor | DecoderConfigDescriptor | DecoderSpecificInfo | SLConfigDescriptor;
export type EndianType = `${"uint" | "int" | "float"}${64 | 32 | 16 | 8}${"le" | "be"}`;
export type FnType = (dataStream: DataStream, struct: Record<string, unknown>) => number;
export type IncompleteBox = {
	code: number;
	box?: Box;
	size?: number;
	type?: unknown;
	hdr_size?: number;
	start?: number;
};
export type InstanceUnion<T> = T extends new (...args: any[]) => infer R ? R : never;
export type KindOf<T> = InstanceUnion<ValueOf<T>>;
export type Matrix = Int32Array | Uint32Array | [
	number,
	number,
	number,
	number,
	number,
	number,
	number,
	number,
	number
];
export type NaluArray = Array<{
	data: Uint8Array;
}> & {
	completeness: number;
	nalu_type: number;
};
/**********************************************************************************/
/**********************************************************************************/
export type PrimitiveType = "uint8" | "uint16" | "uint32" | "int8" | "int16" | "int32" | "float32" | "float64" | `u16string${"le" | "be" | ""}` | "cstring" | "string" | `string:${number}` | `cstring:${number}` | `u16string${"" | "le" | "be"}:${number}`;
export type SampleEntryType = "Visual" | "Audio" | "Hint" | "Metadata" | "Subtitle" | "System" | "Text";
export type StructDefinition = Array<[
	name: string,
	type: StructType
]>;
export type StructType = PrimitiveType | EndianType | ComplexType | ArrayType | FnType;
export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
export type ValueOf<T> = T[keyof T];
interface Entry$1 {
	sample_count: number;
	group_description_index: number;
}
interface Range$1 {
	level: number;
	range_size: number;
}
type NaluArray$1 = Array<Nalu> & {
	completeness: number;
	nalu_type: number;
	length: number;
};

declare namespace BOXES {
	export { Assocation, AudioSampleEntry, CoLLBox, EntityToGroup, Extent, HintSampleEntry, MetadataSampleEntry, OpusSampleEntry, SmDmBox, SubSample, SubtitleSampleEntry, SystemSampleEntry, TextSampleEntry, VisualSampleEntry, a1lxBox, a1opBox, ac_3SampleEntry, ac_4SampleEntry, aebrBox, afbrBox, albcBox, alstSampleGroupEntry, altrBox, auxCBox, av01SampleEntry, av1CBox, avc1SampleEntry, avc2SampleEntry, avc3SampleEntry, avc4SampleEntry, avcCBox, avllSampleGroupEntry, avs3SampleEntry, avssSampleGroupEntry, brstBox, btrtBox, bxmlBox, ccstBox, cdefBox, clapBox, clefBox, clliBox, cmexBox, cminBox, cmpdBox, co64Box, colrBox, cprtBox, cslgBox, cttsBox, dOpsBox, dac3Box, dav1SampleEntry, dec3Box, dfLaBox, dimmBox, dinfBox, dmax, dmedBox, dobrBox, drefBox, drepBox, dtrtSampleGroupEntry, dvh1SampleEntry, dvheSampleEntry, ec_3SampleEntry, edtsBox, elngBox, elstBox, emsgBox, encaSampleEntry, encmSampleEntry, encsSampleEntry, enctSampleEntry, encuSampleEntry, encvSampleEntry, enofBox, eqivBox, esdsBox, etypBox, fLaCSampleEntry, favcBox, fielBox, fobrBox, freeBox, frmaBox, ftypBox, grplBox, hdlrBox, hev1SampleEntry, hinfBox, hmhdBox, hntiBox, hvc1SampleEntry, hvcCBox, hvt1SampleEntry, iaugBox, idatBox, iinfBox, ilocBox, imirBox, infeBox, iodsBox, ipcoBox, ipmaBox, iproBox, iprpBox, irefBox, irotBox, ispeBox, j2kHBox, j2kiSampleEntry, kindBox, levaBox, lhe1SampleEntry, lhvCBox, lselBox, maxrBox, mdatBox, mdcvBox, mdhdBox, mdiaBox, mecoBox, mehdBox, metaBox, mettSampleEntry, metxSampleEntry, mfhdBox, mfraBox, mfroBox, mha1SampleEntry, mha2SampleEntry, mhm1SampleEntry, mhm2SampleEntry, minfBox, mjp2SampleEntry, mjpgSampleEntry, moofBox, moovBox, mp4aSampleEntry, mskCBox, msrcTrackGroupTypeBox, mvexBox, mvhdBox, mvifSampleGroupEntry, nmhdBox, npckBox, numpBox, padbBox, panoBox, paspBox, paylBox, paytBox, pdinBox, pitmBox, pixiBox, pmaxBox, prdiBox, prftBox, prgrBox, profBox, prolSampleGroupEntry, psshBox, pymdBox, rapSampleGroupEntry, rashSampleGroupEntry, rinfBox, rollSampleGroupEntry, rtpBox, saioBox, saizBox, sbgpBox, sbpmBox, sbttSampleEntry, schiBox, schmBox, scifSampleGroupEntry, scnmSampleGroupEntry, sdpBox, sdtpBox, seigSampleGroupEntry, sencBox, sgpdBox, sidxBox, sinfBox, skipBox, slidBox, smhdBox, ssixBox, stblBox, stcoBox, stdpBox, sterBox, sthdBox, stppSampleEntry, strdBox, striBox, strkBox, stsaSampleGroupEntry, stscBox, stsdBox, stsgBox, stshBox, stssBox, stszBox, sttsBox, stviBox, stxtSampleEntry, stypBox, stz2Box, subsBox, syncSampleGroupEntry, taptBox, teleSampleGroupEntry, tencBox, tfdtBox, tfraBox, tkhdBox, tmaxBox, tminBox, totlBox, tpayBox, tpylBox, trafBox, trakBox, trefBox, trepBox, trexBox, trgrBox, trpyBox, trunBox, tsasSampleGroupEntry, tsclSampleGroupEntry, tselBox, tsynBox, tx3gSampleEntry, txtcBox, tycoBox, udesBox, udtaBox, uncCBox, uncvSampleEntry, urlBox, urnBox, viprSampleGroupEntry, vmhdBox, vp08SampleEntry, vp09SampleEntry, vpcCBox, vttCBox, vttcBox, vvc1SampleEntry, vvcCBox, vvcNSampleEntry, vvi1SampleEntry, vvnCBox, vvs1SampleEntry, wbbrBox, wvttSampleEntry, xmlBox };
}

export {};