unreal.js
Version:
A pak reader for games like VALORANT & Fortnite written in Node.JS
164 lines (163 loc) • 5.53 kB
TypeScript
/// <reference types="node" />
/// <reference types="ref-napi" />
import { IJson, Package, ResolvedLoadedObject, ResolvedObject } from "./Package";
import { FPackageStore, FScriptObjectEntry } from "../asyncloading2/FPackageStore";
import { FExportBundleEntry, FExportBundleHeader, FExportMapEntry, FPackageObjectIndex } from "../asyncloading2/AsyncLoading2";
import { FNameMap } from "../asyncloading2/FNameMap";
import { UObject } from "./exports/UObject";
import { FArchive } from "../reader/FArchive";
import { FileProvider } from "../../fileprovider/FileProvider";
import { FName } from "../objects/uobject/FName";
import { FPackageIndex } from "../objects/uobject/ObjectResource";
import { Locres } from "../locres/Locres";
import { Lazy } from "../../util/Lazy";
import { VersionContainer } from "../versions/VersionContainer";
import { FFilePackageStoreEntry } from "../io/IoContainerHeader";
/**
* UE4 I/O Package
* @extends {Package}
*/
export declare class IoPackage extends Package {
/**
* Package ID
* @type {bigint}
* @public
*/
packageId: bigint;
/**
* Package Store
* @type {FPackageStore}
* @public
*/
globalPackageStore: FPackageStore;
/**
* Name Map
* @type {FNameMap}
* @public
*/
nameMap: FNameMap;
/**
* Imported Export Hashes
* @type {Array<bigint>}
* @public
*/
importedPublicExportHashes?: bigint[];
/**
* Import Map
* @type {Array<FPackageObjectIndex>}
* @public
*/
importMap: FPackageObjectIndex[];
/**
* Export Map
* @type {Array<FExportMapEntry>}
* @public
*/
exportMap: FExportMapEntry[];
/**
* Export Bundle Headers
* @type {Array<FExportBundleHeader>}
* @public
*/
exportBundleHeaders: FExportBundleHeader[];
/**
* Export Bundle Entries
* @type {Array<FExportBundleEntry>}
* @public
*/
exportBundleEntries: FExportBundleEntry[];
/**
* Imported Packages
* @type {Lazy<Array<IoPackage>>}
* @public
*/
importedPackages: Lazy<IoPackage[]>;
/**
* Lazy Exports
* @type {Array<Lazy<UObject>>}
* @public
*/
exportsLazy: Lazy<UObject>[];
/**
* Offset start of bulk data
* @type {number}
* @public
*/
bulkDataStartOffset: number;
/**
* Creates an instance
* @param {Buffer} uasset Uasset data of package
* @param {bigint} packageId ID of package
* @param {FFilePackageStoreEntry} storeEntry Store entry
* @param {FPackageStore} globalPackageStore Package store
* @param {FileProvider} provider Instance of file provider
* @param {VersionContainer} versions Version of package
*/
constructor(uasset: Buffer, packageId: bigint, storeEntry: FFilePackageStoreEntry, globalPackageStore: FPackageStore, provider: FileProvider, versions?: VersionContainer);
/**
* Resolves an object index
* @param {FPackageObjectIndex} index Object index to resolve
* @param {boolean} throwIfNotFound (default: true) Whether to throw an error if it wasn't found
* @returns {ResolvedExportObject | ResolvedScriptObject | null} Object
* @public
*/
resolveObjectIndex(index: FPackageObjectIndex, throwIfNotFound?: boolean): ResolvedExportObject | ResolvedScriptObject;
/**
* Finds an object by FPackageIndex
* @param {FPackageIndex} index Index to look for
* @returns {?any} Object or null
* @public
*/
findObject<T>(index?: FPackageIndex): Lazy<T>;
/**
* Finds an object by name
* @param {string} objectName Name of object
* @param {?string} className Class name of object
* @returns {?Lazy<UObject>} Object or null
* @public
*/
findObjectByName(objectName: string, className?: string): Lazy<UObject>;
/**
* Turns this package into json
* @param {?Locres} locres Locres to use
* @returns {Array<IJson>} Json data
* @public
*/
toJson(locres?: Locres): IJson[];
/**
* Finds an object minimal
* @param {?FPackageIndex} index Index to look for
* @returns {ResolvedExportObject | ResolvedScriptObject} Object
* @public
*/
findObjectMinimal(index?: FPackageIndex): ResolvedExportObject | ResolvedScriptObject;
}
export declare class FImportedPackage {
importedPackageId: bigint;
externalArcs: FArc[];
constructor(Ar: FArchive);
}
export declare class FArc {
fromExportBundleIndex: number;
toExportBundleIndex: number;
constructor(Ar: FArchive);
}
declare class ResolvedExportObject extends ResolvedObject {
exportIndex: number;
exportMapEntry: FExportMapEntry;
exportObject: Lazy<UObject>;
constructor(exportIndex: number, pkg: IoPackage);
get name(): FName;
getOuter(): ResolvedExportObject | ResolvedScriptObject | ResolvedLoadedObject;
getClazz(): ResolvedExportObject | ResolvedScriptObject;
getSuper(): ResolvedExportObject | ResolvedScriptObject;
getObject(): Lazy<UObject>;
}
declare class ResolvedScriptObject extends ResolvedObject {
scriptImport: FScriptObjectEntry;
constructor(scriptImport: FScriptObjectEntry, pkg: IoPackage);
get name(): FName;
getOuter(): ResolvedExportObject | ResolvedScriptObject;
getObject(): Lazy<UObject>;
}
export {};