@rhyster/wow-casc-dbc/dist/index.d.cts

Fetch World of Warcraft data files from CASC and parse DBC/DB2 files.

interface HotfixEntry {
    regionID: number;
    pushID: number;
    uniqueID: number;
    tableHash: number;
    recordID: number;
    dataSize: number;
    recordState: number;
    data: Buffer;
}
declare class ADBReader {
    build: number;
    entries: HotfixEntry[];
    tableEntries: Map<number, HotfixEntry[]>;
    constructor(buffer: Buffer);
}

interface MissingKeyBlock {
    offset: number;
    size: number;
    blockIndex: number;
    keyName: string;
}

interface ArchiveIndex {
    key: string;
    size: number;
    offset: number;
}

interface EncodingData {
    eSpec: string[];
    cKey2FileSize: Map<string, number>;
    cKey2EKey: Map<string, string | string[]>;
    eKey2ESpecIndex: Map<string, number>;
    eKey2FileSize: Map<string, number>;
}

interface InstallTag {
    name: string;
    type: number;
    files: boolean[];
}
interface InstallFile {
    name: string;
    hash: string;
    size: number;
    tags: InstallTag[];
}
interface InstallData {
    tags: InstallTag[];
    files: InstallFile[];
}

interface Version {
    Region: string;
    BuildConfig: string;
    CDNConfig: string;
    KeyRing: string;
    BuildId: string;
    VersionsName: string;
    ProductConfig: string;
}

interface FileInfo {
    cKey: string;
    contentFlags: number;
    localeFlags: number;
}
interface RootData {
    fileDataID2CKey: Map<number, FileInfo[]>;
    nameHash2FileDataID: Map<string, number>;
}

interface ClientPreloadData {
    prefixes: string[];
    archives: Map<string, ArchiveIndex>;
    encoding: EncodingData;
    rootFile: RootData;
    install: InstallData;
}
interface FileFetchResultFull {
    type: 'full';
    buffer: Buffer;
    blocks: undefined;
}
interface FileFetchResultPartial {
    type: 'partial';
    buffer: Buffer;
    blocks: MissingKeyBlock[];
}
type FileFetchResult = FileFetchResultFull | FileFetchResultPartial;
declare enum LogLevel {
    error = 0,
    warn = 1,
    info = 2,
    debug = 3
}
declare class CASCClient {
    readonly region: string;
    readonly product: string;
    readonly version: Version;
    readonly name2FileDataID: Map<string, number>;
    readonly keys: Map<string, Uint8Array<ArrayBufferLike>>;
    preload?: ClientPreloadData;
    static getProductVersion(region: string, product: string): Promise<Version | undefined>;
    static LocaleFlags: {
        readonly enUS: 2;
        readonly koKR: 4;
        readonly frFR: 16;
        readonly deDE: 32;
        readonly zhCN: 64;
        readonly esES: 128;
        readonly zhTW: 256;
        readonly enGB: 512;
        readonly esMX: 4096;
        readonly ruRU: 8192;
        readonly ptBR: 16384;
        readonly itIT: 32768;
        readonly ptPT: 65536;
    };
    static ContentFlags: {
        readonly Install: 4;
        readonly LoadOnWindows: 8;
        readonly LoadOnMacOS: 16;
        readonly x86_32: 32;
        readonly x86_64: 64;
        readonly LowViolence: 128;
        readonly DoNotLoad: 256;
        readonly UpdatePlugin: 2048;
        readonly ARM64: 32768;
        readonly Encrypted: 134217728;
        readonly NoNameHash: 268435456;
        readonly UncommonResolution: 536870912;
        readonly Bundle: 1073741824;
        readonly NoCompression: 2147483648;
    };
    static LogLevel: typeof LogLevel;
    logLevel: LogLevel;
    constructor(region: string, product: string, version: Version, logLevel?: LogLevel);
    private log;
    init(): Promise<void>;
    loadRemoteListFile(): Promise<void>;
    loadRemoteTACTKeys(): Promise<void>;
    loadTACTKeys(): Promise<void>;
    loadBroadcastTACTKeys(adb: ADBReader): void;
    getFileDataIDByName(name: string): number | undefined;
    getContentKeysByFileDataID(fileDataID: number): FileInfo[] | undefined;
    getContentKeysFromInstall(name: string): InstallFile[] | undefined;
    getFileByContentKey(cKey: string, allowMissingKey?: false): Promise<FileFetchResultFull>;
    getFileByContentKey(cKey: string, allowMissingKey: true): Promise<FileFetchResult>;
}

interface FieldStructure {
    size: number;
    position: number;
}
interface FieldStorageInfoCompressionNone {
    fieldOffsetBits: number;
    fieldSizeBits: number;
    additionalDataSize: number;
    storageType: 'none';
}
interface FieldStorageInfoCompressionBitpacked {
    fieldOffsetBits: number;
    fieldSizeBits: number;
    additionalDataSize: number;
    storageType: 'bitpacked';
    bitpackingOffsetBits: number;
    bitpackingSizeBits: number;
    flags: number;
}
interface FieldStorageInfoCompressionCommonData {
    fieldOffsetBits: number;
    fieldSizeBits: number;
    additionalDataSize: number;
    storageType: 'commonData';
    defaultValue: number;
}
interface FieldStorageInfoCompressionBitpackedIndexed {
    fieldOffsetBits: number;
    fieldSizeBits: number;
    additionalDataSize: number;
    storageType: 'bitpackedIndexed';
    bitpackingOffsetBits: number;
    bitpackingSizeBits: number;
}
interface FieldStorageInfoCompressionBitpackedIndexedArray {
    fieldOffsetBits: number;
    fieldSizeBits: number;
    additionalDataSize: number;
    storageType: 'bitpackedIndexedArray';
    bitpackingOffsetBits: number;
    bitpackingSizeBits: number;
    arrayCount: number;
}
interface FieldStorageInfoCompressionBitpackedSigned {
    fieldOffsetBits: number;
    fieldSizeBits: number;
    additionalDataSize: number;
    storageType: 'bitpackedSigned';
    bitpackingOffsetBits: number;
    bitpackingSizeBits: number;
    flags: number;
}
type FieldStorageInfo = FieldStorageInfoCompressionNone | FieldStorageInfoCompressionBitpacked | FieldStorageInfoCompressionCommonData | FieldStorageInfoCompressionBitpackedIndexed | FieldStorageInfoCompressionBitpackedIndexedArray | FieldStorageInfoCompressionBitpackedSigned;
interface ParsedFieldNone {
    type: 'none';
    data: number | bigint;
    string?: string;
}
interface ParsedFieldCommonData {
    type: 'commonData';
    data: number;
}
interface ParsedFieldBitpacked {
    type: 'bitpacked';
    data: number;
}
interface ParsedFieldBitpackedArray {
    type: 'bitpackedArray';
    data: number[];
}
type ParsedField = ParsedFieldNone | ParsedFieldCommonData | ParsedFieldBitpacked | ParsedFieldBitpackedArray;
interface SparseRow {
    type: 'sparse';
    data: Buffer;
}
interface HotfixModify {
    type: 'modify';
    data: Buffer;
}
interface HotfixDelete {
    type: 'delete';
}
type Hotfix = HotfixModify | HotfixDelete;
declare class WDCReader {
    readonly tableHash: number;
    readonly layoutHash: number;
    readonly locale: number;
    readonly isNormal: boolean;
    readonly hasRelationshipData: boolean;
    readonly fields: FieldStructure[];
    readonly fieldsInfo: FieldStorageInfo[];
    readonly rows: Map<number, SparseRow | ParsedField[]>;
    readonly relationships: Map<number, number>;
    readonly copyTable: Map<number, number>;
    readonly hotfixes: Map<number, Hotfix>;
    constructor(buffer: Buffer, blocks?: MissingKeyBlock[], adb?: ADBReader);
    getAllIDs(): number[];
    getRowData(id: number): ParsedField[] | SparseRow | undefined;
    getRowRelationship(id: number): number | undefined;
}

interface Column {
    name: string;
    type: string;
    isID: boolean;
    isInline: boolean;
    isRelation: boolean;
    isSigned: boolean;
    size?: number;
    arraySize?: number;
}
type BasicColumnData = number | bigint | string | undefined;
type ColumnData = BasicColumnData | BasicColumnData[];
declare class DBDParser {
    readonly wdc: WDCReader;
    readonly definitions: Map<string, string>;
    columns: Column[];
    private cache;
    private constructor();
    private init;
    static parse(wdc: WDCReader): Promise<DBDParser>;
    getAllIDs(): number[];
    getRowData(id: number): Record<string, ColumnData> | undefined;
}

export { ADBReader, CASCClient, DBDParser, WDCReader };
export type { ArchiveIndex, BasicColumnData, ClientPreloadData, Column, ColumnData, EncodingData, FieldStorageInfo, FieldStorageInfoCompressionBitpacked, FieldStorageInfoCompressionBitpackedIndexed, FieldStorageInfoCompressionBitpackedIndexedArray, FieldStorageInfoCompressionBitpackedSigned, FieldStorageInfoCompressionCommonData, FieldStorageInfoCompressionNone, FieldStructure, FileFetchResult, FileFetchResultFull, FileFetchResultPartial, FileInfo, Hotfix, HotfixDelete, HotfixEntry, HotfixModify, InstallData, InstallFile, MissingKeyBlock, ParsedField, ParsedFieldBitpacked, ParsedFieldBitpackedArray, ParsedFieldCommonData, ParsedFieldNone, RootData, SparseRow, Version };