openclaw-multi-auto 1.2.7 → 1.2.9

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/APEv2Parser.js

@@ -1,176 +0,0 @@
-import initDebug from 'debug';
-import * as strtok3 from 'strtok3';
-import { StringType } from 'token-types';
-import * as util from '../common/Util.js';
-import { BasicParser } from '../common/BasicParser.js';
-import { DataType, DescriptorParser, Header, TagFooter, TagItemHeader } from './APEv2Token.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-import { textDecode } from '@borewit/text-codec';
-const debug = initDebug('music-metadata:parser:APEv2');
-const tagFormat = 'APEv2';
-const preamble = 'APETAGEX';
-export class ApeContentError extends makeUnexpectedFileContentError('APEv2') {
-}
-export function tryParseApeHeader(metadata, tokenizer, options) {
-    const apeParser = new APEv2Parser(metadata, tokenizer, options);
-    return apeParser.tryParseApeHeader();
-}
-export class APEv2Parser extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.ape = {};
-    }
-    /**
-     * Calculate the media file duration
-     * @param ah ApeHeader
-     * @return {number} duration in seconds
-     */
-    static calculateDuration(ah) {
-        let duration = ah.totalFrames > 1 ? ah.blocksPerFrame * (ah.totalFrames - 1) : 0;
-        duration += ah.finalFrameBlocks;
-        return duration / ah.sampleRate;
-    }
-    /**
-     * Calculates the APEv1 / APEv2 first field offset
-     * @param tokenizer
-     * @param offset
-     */
-    static async findApeFooterOffset(tokenizer, offset) {
-        // Search for APE footer header at the end of the file
-        const apeBuf = new Uint8Array(TagFooter.len);
-        const position = tokenizer.position;
-        if (offset <= TagFooter.len) {
-            debug(`Offset is too small to read APE footer: offset=${offset}`);
-            return undefined;
-        }
-        if (offset > TagFooter.len) {
-            await tokenizer.readBuffer(apeBuf, { position: offset - TagFooter.len });
-            tokenizer.setPosition(position);
-            const tagFooter = TagFooter.get(apeBuf, 0);
-            if (tagFooter.ID === 'APETAGEX') {
-                if (tagFooter.flags.isHeader) {
-                    debug(`APE Header found at offset=${offset - TagFooter.len}`);
-                }
-                else {
-                    debug(`APE Footer found at offset=${offset - TagFooter.len}`);
-                    offset -= tagFooter.size;
-                }
-                return { footer: tagFooter, offset };
-            }
-        }
-    }
-    static parseTagFooter(metadata, buffer, options) {
-        const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
-        if (footer.ID !== preamble)
-            throw new ApeContentError('Unexpected APEv2 Footer ID preamble value');
-        strtok3.fromBuffer(buffer);
-        const apeParser = new APEv2Parser(metadata, strtok3.fromBuffer(buffer), options);
-        return apeParser.parseTags(footer);
-    }
-    /**
-     * Parse APEv1 / APEv2 header if header signature found
-     */
-    async tryParseApeHeader() {
-        if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < TagFooter.len) {
-            debug("No APEv2 header found, end-of-file reached");
-            return;
-        }
-        const footer = await this.tokenizer.peekToken(TagFooter);
-        if (footer.ID === preamble) {
-            await this.tokenizer.ignore(TagFooter.len);
-            return this.parseTags(footer);
-        }
-        debug(`APEv2 header not found at offset=${this.tokenizer.position}`);
-        if (this.tokenizer.fileInfo.size) {
-            // Try to read the APEv2 header using just the footer-header
-            const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position; // ToDo: take ID3v1 into account
-            const buffer = new Uint8Array(remaining);
-            await this.tokenizer.readBuffer(buffer);
-            return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
-        }
-    }
-    async parse() {
-        const descriptor = await this.tokenizer.readToken(DescriptorParser);
-        if (descriptor.ID !== 'MAC ')
-            throw new ApeContentError('Unexpected descriptor ID');
-        this.ape.descriptor = descriptor;
-        const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
-        const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
-        this.metadata.setAudioOnly();
-        await this.tokenizer.ignore(header.forwardBytes);
-        return this.tryParseApeHeader();
-    }
-    async parseTags(footer) {
-        const keyBuffer = new Uint8Array(256); // maximum tag key length
-        let bytesRemaining = footer.size - TagFooter.len;
-        debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
-        for (let i = 0; i < footer.fields; i++) {
-            if (bytesRemaining < TagItemHeader.len) {
-                this.metadata.addWarning(`APEv2 Tag-header: ${footer.fields - i} items remaining, but no more tag data to read.`);
-                break;
-            }
-            // Only APEv2 tag has tag item headers
-            const tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
-            bytesRemaining -= TagItemHeader.len + tagItemHeader.size;
-            await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
-            let zero = util.findZero(keyBuffer);
-            const key = await this.tokenizer.readToken(new StringType(zero, 'ascii'));
-            await this.tokenizer.ignore(1);
-            bytesRemaining -= key.length + 1;
-            switch (tagItemHeader.flags.dataType) {
-                case DataType.text_utf8: { // utf-8 text-string
-                    const value = await this.tokenizer.readToken(new StringType(tagItemHeader.size, 'utf8'));
-                    const values = value.split(/\x00/g);
-                    await Promise.all(values.map(val => this.metadata.addTag(tagFormat, key, val)));
-                    break;
-                }
-                case DataType.binary: // binary (probably artwork)
-                    if (this.options.skipCovers) {
-                        await this.tokenizer.ignore(tagItemHeader.size);
-                    }
-                    else {
-                        const picData = new Uint8Array(tagItemHeader.size);
-                        await this.tokenizer.readBuffer(picData);
-                        zero = util.findZero(picData);
-                        const description = textDecode(picData.subarray(0, zero), 'utf-8');
-                        const data = picData.subarray(zero + 1);
-                        await this.metadata.addTag(tagFormat, key, {
-                            description,
-                            data
-                        });
-                    }
-                    break;
-                case DataType.external_info:
-                    debug(`Ignore external info ${key}`);
-                    await this.tokenizer.ignore(tagItemHeader.size);
-                    break;
-                case DataType.reserved:
-                    debug(`Ignore external info ${key}`);
-                    this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`);
-                    await this.tokenizer.ignore(tagItemHeader.size);
-                    break;
-            }
-        }
-    }
-    async parseDescriptorExpansion(lenExp) {
-        await this.tokenizer.ignore(lenExp);
-        return this.parseHeader();
-    }
-    async parseHeader() {
-        const header = await this.tokenizer.readToken(Header);
-        // ToDo before
-        this.metadata.setFormat('lossless', true);
-        this.metadata.setFormat('container', 'Monkey\'s Audio');
-        this.metadata.setFormat('bitsPerSample', header.bitsPerSample);
-        this.metadata.setFormat('sampleRate', header.sampleRate);
-        this.metadata.setFormat('numberOfChannels', header.channel);
-        this.metadata.setFormat('duration', APEv2Parser.calculateDuration(header));
-        if (!this.ape.descriptor) {
-            throw new ApeContentError('Missing APE descriptor');
-        }
-        return {
-            forwardBytes: this.ape.descriptor.seekTableBytes + this.ape.descriptor.headerDataBytes +
-                this.ape.descriptor.apeFrameDataBytes + this.ape.descriptor.terminatingDataBytes
-        };
-    }
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/APEv2TagMapper.d.ts

@@ -1,4 +0,0 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-export declare class APEv2TagMapper extends CaseInsensitiveTagMap {
-    constructor();
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/APEv2TagMapper.js

@@ -1,83 +0,0 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-/**
- * ID3v2.2 tag mappings
- */
-const apev2TagMap = {
-    Title: 'title',
-    Artist: 'artist',
-    Artists: 'artists',
-    'Album Artist': 'albumartist',
-    Album: 'album',
-    Year: 'date',
-    Originalyear: 'originalyear',
-    Originaldate: 'originaldate',
-    Releasedate: 'releasedate',
-    Comment: 'comment',
-    Track: 'track',
-    Disc: 'disk',
-    DISCNUMBER: 'disk', // ToDo: backwards compatibility', valid tag?
-    Genre: 'genre',
-    'Cover Art (Front)': 'picture',
-    'Cover Art (Back)': 'picture',
-    Composer: 'composer',
-    Lyrics: 'lyrics',
-    ALBUMSORT: 'albumsort',
-    TITLESORT: 'titlesort',
-    WORK: 'work',
-    ARTISTSORT: 'artistsort',
-    ALBUMARTISTSORT: 'albumartistsort',
-    COMPOSERSORT: 'composersort',
-    Lyricist: 'lyricist',
-    Writer: 'writer',
-    Conductor: 'conductor',
-    // 'Performer=artist (instrument)': 'performer:instrument',
-    MixArtist: 'remixer',
-    Arranger: 'arranger',
-    Engineer: 'engineer',
-    Producer: 'producer',
-    DJMixer: 'djmixer',
-    Mixer: 'mixer',
-    Label: 'label',
-    Grouping: 'grouping',
-    Subtitle: 'subtitle',
-    DiscSubtitle: 'discsubtitle',
-    Compilation: 'compilation',
-    BPM: 'bpm',
-    Mood: 'mood',
-    Media: 'media',
-    CatalogNumber: 'catalognumber',
-    MUSICBRAINZ_ALBUMSTATUS: 'releasestatus',
-    MUSICBRAINZ_ALBUMTYPE: 'releasetype',
-    RELEASECOUNTRY: 'releasecountry',
-    Script: 'script',
-    Language: 'language',
-    Copyright: 'copyright',
-    LICENSE: 'license',
-    EncodedBy: 'encodedby',
-    EncoderSettings: 'encodersettings',
-    Barcode: 'barcode',
-    ISRC: 'isrc',
-    ASIN: 'asin',
-    musicbrainz_trackid: 'musicbrainz_recordingid',
-    musicbrainz_releasetrackid: 'musicbrainz_trackid',
-    MUSICBRAINZ_ALBUMID: 'musicbrainz_albumid',
-    MUSICBRAINZ_ARTISTID: 'musicbrainz_artistid',
-    MUSICBRAINZ_ALBUMARTISTID: 'musicbrainz_albumartistid',
-    MUSICBRAINZ_RELEASEGROUPID: 'musicbrainz_releasegroupid',
-    MUSICBRAINZ_WORKID: 'musicbrainz_workid',
-    MUSICBRAINZ_TRMID: 'musicbrainz_trmid',
-    MUSICBRAINZ_DISCID: 'musicbrainz_discid',
-    Acoustid_Id: 'acoustid_id',
-    ACOUSTID_FINGERPRINT: 'acoustid_fingerprint',
-    MUSICIP_PUID: 'musicip_puid',
-    Weblink: 'website',
-    REPLAYGAIN_TRACK_GAIN: 'replaygain_track_gain',
-    REPLAYGAIN_TRACK_PEAK: 'replaygain_track_peak',
-    MP3GAIN_MINMAX: 'replaygain_track_minmax',
-    MP3GAIN_UNDO: 'replaygain_undo'
-};
-export class APEv2TagMapper extends CaseInsensitiveTagMap {
-    constructor() {
-        super(['APEv2'], apev2TagMap);
-    }
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/APEv2Token.d.ts

@@ -1,99 +0,0 @@
-import type { IGetToken } from 'strtok3';
-/**
- * APETag versionIndex history / supported formats
- *
- * 1.0 (1000) - Original APE tag spec.  Fully supported by this code.
- * 2.0 (2000) - Refined APE tag spec (better streaming support, UTF StringEncoding). Fully supported by this code.
- *
- * Notes:
- * - also supports reading of ID3v1.1 tags
- * - all saving done in the APE Tag format using CURRENT_APE_TAG_VERSION
- *
- * APE File Format Overview: (pieces in order -- only valid for the latest versionIndex APE files)
- *
- * JUNK - any amount of "junk" before the APE_DESCRIPTOR (so people that put ID3v2 tags on the files aren't hosed)
- * APE_DESCRIPTOR - defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
- * APE_HEADER - describes all of the necessary information about the APE file
- * SEEK TABLE - the table that represents seek offsets [optional]
- * HEADER DATA - the pre-audio data from the original file [optional]
- * APE FRAMES - the actual compressed audio (broken into frames for seekability)
- * TERMINATING DATA - the post-audio data from the original file [optional]
- * TAG - describes all the properties of the file [optional]
- */
-export interface IDescriptor {
-    ID: string;
-    version: number;
-    descriptorBytes: number;
-    headerBytes: number;
-    seekTableBytes: number;
-    headerDataBytes: number;
-    apeFrameDataBytes: number;
-    apeFrameDataBytesHigh: number;
-    terminatingDataBytes: number;
-    fileMD5: Uint8Array;
-}
-/**
- * APE_HEADER: describes all of the necessary information about the APE file
- */
-export interface IHeader {
-    compressionLevel: number;
-    formatFlags: number;
-    blocksPerFrame: number;
-    finalFrameBlocks: number;
-    totalFrames: number;
-    bitsPerSample: number;
-    channel: number;
-    sampleRate: number;
-}
-export interface IFooter {
-    ID: string;
-    version: number;
-    size: number;
-    fields: number;
-    flags: ITagFlags;
-}
-export declare const DataType: {
-    text_utf8: number;
-    binary: number;
-    external_info: number;
-    reserved: number;
-};
-export type DataType = typeof DataType[keyof typeof DataType];
-/**
- * APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
- */
-export declare const DescriptorParser: IGetToken<IDescriptor>;
-/**
- * APE_HEADER: describes all of the necessary information about the APE file
- */
-export declare const Header: IGetToken<IHeader>;
-/**
- * APE Tag Header/Footer Version 2.0
- * TAG: describes all the properties of the file [optional]
- */
-export declare const TagFooter: IGetToken<IFooter>;
-/**
- * APE Tag v2.0 Item Header
- */
-export interface ITagItemHeader {
-    size: number;
-    flags: ITagFlags;
-}
-/**
- * APE Tag v2.0 Item Header
- */
-export declare const TagItemHeader: IGetToken<ITagItemHeader>;
-export interface ITagFlags {
-    containsHeader: boolean;
-    containsFooter: boolean;
-    isHeader: boolean;
-    readOnly: boolean;
-    dataType: DataType;
-}
-export declare function parseTagFlags(flags: number): ITagFlags;
-/**
- * @param num {number}
- * @param bit 0 is least significant bit (LSB)
- * @return {boolean} true if bit is 1; otherwise false
- */
-export declare function isBitSet(num: number, bit: number): boolean;

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/APEv2Token.js

@@ -1,116 +0,0 @@
-import * as Token from 'token-types';
-import { FourCcToken } from '../common/FourCC.js';
-export const DataType = {
-    text_utf8: 0,
-    binary: 1,
-    external_info: 2,
-    reserved: 3
-};
-/**
- * APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
- */
-export const DescriptorParser = {
-    len: 52,
-    get: (buf, off) => {
-        return {
-            // should equal 'MAC '
-            ID: FourCcToken.get(buf, off),
-            // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
-            version: Token.UINT32_LE.get(buf, off + 4) / 1000,
-            // the number of descriptor bytes (allows later expansion of this header)
-            descriptorBytes: Token.UINT32_LE.get(buf, off + 8),
-            // the number of header APE_HEADER bytes
-            headerBytes: Token.UINT32_LE.get(buf, off + 12),
-            // the number of header APE_HEADER bytes
-            seekTableBytes: Token.UINT32_LE.get(buf, off + 16),
-            // the number of header data bytes (from original file)
-            headerDataBytes: Token.UINT32_LE.get(buf, off + 20),
-            // the number of bytes of APE frame data
-            apeFrameDataBytes: Token.UINT32_LE.get(buf, off + 24),
-            // the high order number of APE frame data bytes
-            apeFrameDataBytesHigh: Token.UINT32_LE.get(buf, off + 28),
-            // the terminating data of the file (not including tag data)
-            terminatingDataBytes: Token.UINT32_LE.get(buf, off + 32),
-            // the MD5 hash of the file (see notes for usage... it's a little tricky)
-            fileMD5: new Token.Uint8ArrayType(16).get(buf, off + 36)
-        };
-    }
-};
-/**
- * APE_HEADER: describes all of the necessary information about the APE file
- */
-export const Header = {
-    len: 24,
-    get: (buf, off) => {
-        return {
-            // the compression level (see defines I.E. COMPRESSION_LEVEL_FAST)
-            compressionLevel: Token.UINT16_LE.get(buf, off),
-            // any format flags (for future use)
-            formatFlags: Token.UINT16_LE.get(buf, off + 2),
-            // the number of audio blocks in one frame
-            blocksPerFrame: Token.UINT32_LE.get(buf, off + 4),
-            // the number of audio blocks in the final frame
-            finalFrameBlocks: Token.UINT32_LE.get(buf, off + 8),
-            // the total number of frames
-            totalFrames: Token.UINT32_LE.get(buf, off + 12),
-            // the bits per sample (typically 16)
-            bitsPerSample: Token.UINT16_LE.get(buf, off + 16),
-            // the number of channels (1 or 2)
-            channel: Token.UINT16_LE.get(buf, off + 18),
-            // the sample rate (typically 44100)
-            sampleRate: Token.UINT32_LE.get(buf, off + 20)
-        };
-    }
-};
-/**
- * APE Tag Header/Footer Version 2.0
- * TAG: describes all the properties of the file [optional]
- */
-export const TagFooter = {
-    len: 32,
-    get: (buf, off) => {
-        return {
-            // should equal 'APETAGEX'
-            ID: new Token.StringType(8, 'ascii').get(buf, off),
-            // equals CURRENT_APE_TAG_VERSION
-            version: Token.UINT32_LE.get(buf, off + 8),
-            // the complete size of the tag, including this footer (excludes header)
-            size: Token.UINT32_LE.get(buf, off + 12),
-            // the number of fields in the tag
-            fields: Token.UINT32_LE.get(buf, off + 16),
-            // reserved for later use (must be zero),
-            flags: parseTagFlags(Token.UINT32_LE.get(buf, off + 20))
-        };
-    }
-};
-/**
- * APE Tag v2.0 Item Header
- */
-export const TagItemHeader = {
-    len: 8,
-    get: (buf, off) => {
-        return {
-            // Length of assigned value in bytes
-            size: Token.UINT32_LE.get(buf, off),
-            // reserved for later use (must be zero),
-            flags: parseTagFlags(Token.UINT32_LE.get(buf, off + 4))
-        };
-    }
-};
-export function parseTagFlags(flags) {
-    return {
-        containsHeader: isBitSet(flags, 31),
-        containsFooter: isBitSet(flags, 30),
-        isHeader: isBitSet(flags, 29),
-        readOnly: isBitSet(flags, 0),
-        dataType: (flags & 6) >> 1
-    };
-}
-/**
- * @param num {number}
- * @param bit 0 is least significant bit (LSB)
- * @return {boolean} true if bit is 1; otherwise false
- */
-export function isBitSet(num, bit) {
-    return (num & 1 << bit) !== 0;
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/Apev2Loader.d.ts

@@ -1,2 +0,0 @@
-import type { IParserLoader } from '../ParserFactory.js';
-export declare const apeParserLoader: IParserLoader;

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/apev2/Apev2Loader.js

@@ -1,8 +0,0 @@
-export const apeParserLoader = {
-    parserType: 'apev2',
-    extensions: ['.ape'],
-    mimeTypes: ['audio/ape', 'audio/monkeys-audio'],
-    async load() {
-        return (await import('./APEv2Parser.js')).APEv2Parser;
-    }
-};

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/asf/AsfGuid.d.ts

@@ -1,83 +0,0 @@
-/**
- * Ref:
- * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
- *
- * ASF File Structure:
- * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
- *
- * ASF GUIDs:
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
- * - https://github.com/dji-sdk/FFmpeg/blob/master/libavformat/asf.c
- */
-export default class AsfGuid {
-    static HeaderObject: AsfGuid;
-    static DataObject: AsfGuid;
-    static SimpleIndexObject: AsfGuid;
-    static IndexObject: AsfGuid;
-    static MediaObjectIndexObject: AsfGuid;
-    static TimecodeIndexObject: AsfGuid;
-    static FilePropertiesObject: AsfGuid;
-    static StreamPropertiesObject: AsfGuid;
-    static HeaderExtensionObject: AsfGuid;
-    static CodecListObject: AsfGuid;
-    static ScriptCommandObject: AsfGuid;
-    static MarkerObject: AsfGuid;
-    static BitrateMutualExclusionObject: AsfGuid;
-    static ErrorCorrectionObject: AsfGuid;
-    static ContentDescriptionObject: AsfGuid;
-    static ExtendedContentDescriptionObject: AsfGuid;
-    static ContentBrandingObject: AsfGuid;
-    static StreamBitratePropertiesObject: AsfGuid;
-    static ContentEncryptionObject: AsfGuid;
-    static ExtendedContentEncryptionObject: AsfGuid;
-    static DigitalSignatureObject: AsfGuid;
-    static PaddingObject: AsfGuid;
-    static ExtendedStreamPropertiesObject: AsfGuid;
-    static AdvancedMutualExclusionObject: AsfGuid;
-    static GroupMutualExclusionObject: AsfGuid;
-    static StreamPrioritizationObject: AsfGuid;
-    static BandwidthSharingObject: AsfGuid;
-    static LanguageListObject: AsfGuid;
-    static MetadataObject: AsfGuid;
-    static MetadataLibraryObject: AsfGuid;
-    static IndexParametersObject: AsfGuid;
-    static MediaObjectIndexParametersObject: AsfGuid;
-    static TimecodeIndexParametersObject: AsfGuid;
-    static CompatibilityObject: AsfGuid;
-    static AdvancedContentEncryptionObject: AsfGuid;
-    static AudioMedia: AsfGuid;
-    static VideoMedia: AsfGuid;
-    static CommandMedia: AsfGuid;
-    static JFIF_Media: AsfGuid;
-    static Degradable_JPEG_Media: AsfGuid;
-    static FileTransferMedia: AsfGuid;
-    static BinaryMedia: AsfGuid;
-    static ASF_Index_Placeholder_Object: AsfGuid;
-    static fromBin(bin: Uint8Array, offset?: number): AsfGuid;
-    /**
-     * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
-     * @param objectId Binary GUID
-     * @param offset Read offset in bytes, default 0
-     * @returns GUID as dashed hexadecimal representation
-     */
-    static decode(objectId: Uint8Array, offset?: number): string;
-    /**
-     * Decode stream type
-     * @param mediaType Media type GUID
-     * @returns Media type
-     */
-    static decodeMediaType(mediaType: AsfGuid): 'audio' | 'video' | 'command' | 'degradable-jpeg' | 'file-transfer' | 'binary' | undefined;
-    /**
-     * Encode GUID
-     * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
-     * @returns Encoded Binary GUID
-     */
-    static encode(guid: string): Uint8Array;
-    str: string;
-    constructor(str: string);
-    equals(guid: AsfGuid): boolean;
-    toBin(): Uint8Array;
-}