@hotbunny/hackhub-content-sdk 0.1.0

package/index.d.ts

@@ -0,0 +1,1460 @@
+// HackHub ContentSDK Type Declarations
+// Package: @hotbunny/hackhub-content-sdk
+// Auto-generated — do not edit manually
+
+export interface QuestRewards {
+	money: number;
+	xp?: number;
+}
+export interface QuestEmployer {
+	firstName: string;
+	lastName: string;
+	email: string;
+	avatar?: string;
+}
+export interface QuestObjectiveDefinition {
+	name: string;
+	description: string;
+	info?: string;
+	hint?: string;
+	terminalCommand?: string;
+	hidden?: boolean;
+	unlocksAfter?: string[];
+	trigger?: QuestObjectiveTrigger;
+}
+export interface QuestObjectiveTrigger {
+	event: string;
+	condition: (data: any) => boolean;
+}
+export interface QuestDefinition {
+	name: string;
+	title: string;
+	description?: string;
+	icon?: string;
+	autoStart?: boolean;
+	autoComplete?: boolean;
+	rewards?: QuestRewards;
+	employer?: Partial<QuestEmployer>;
+	objectives: QuestObjectiveDefinition[];
+	questsToComplete?: string[];
+	maxClaim?: number;
+	maxClaimPerDay?: number;
+	abandonable?: boolean;
+	hasCompleteButton?: boolean;
+}
+export interface WebsitePageDefinition {
+	path: string;
+	title: string;
+	html: string;
+	seo?: boolean;
+}
+export interface WebsiteDefinition {
+	siteName: string;
+	host: string;
+	icon: string;
+	popular?: boolean;
+	pages: WebsitePageDefinition[];
+}
+export type AutoCompleteType = "IP" | "PORT" | "STRING" | "DOMAIN" | "MAC" | "FILE";
+export interface CommandAutoComplete {
+	label: string;
+	type: AutoCompleteType;
+	extension?: string;
+	isFolder?: boolean;
+}
+export interface CommandDefinition {
+	command: string;
+	description: string;
+	packageName?: string;
+	autocomplete?: CommandAutoComplete[];
+}
+export interface CommandTools {
+	println(text: string): void;
+	printError(text: string): void;
+	newLine(): void;
+	clear(): void;
+	prompt(label: string): Promise<string>;
+	sleep(ms: number): Promise<void>;
+	getArgs(): string[];
+	exec(command: string): Promise<void>;
+	isLocked(): boolean;
+	lock(): void;
+	unlock(): void;
+}
+export interface AppSize {
+	width: number;
+	height: number;
+}
+export interface AppDefinition {
+	name: string;
+	title: string;
+	icon: string;
+	html: string;
+	defaultSize: AppSize;
+	minSize?: AppSize;
+	maxSize?: AppSize;
+	maxOpen?: number;
+	disableMaximize?: boolean;
+	disableMinimize?: boolean;
+	store?: {
+		title: string;
+		ratings: number;
+		description: string;
+		price?: number;
+	};
+}
+/**
+ * Game events that mods can listen to.
+ * This is a curated subset of the internal GameEvents, exposing only
+ * safe and stable events to mod authors.
+ */
+export interface NmapScanEvent {
+	ip: string;
+	versionScan?: boolean;
+}
+export interface NslookupEvent {
+	domain: string;
+	ip: string;
+}
+export interface PingEvent {
+	ip: string;
+	isUp: boolean;
+}
+export interface SSHConnectedEvent {
+	ip: string;
+}
+export interface SSHFileDownloadEvent {
+	id: string;
+	name: string;
+	extension?: string;
+}
+export interface HydraEvent {
+	ip: string;
+	port: number;
+	wordlistFile: string;
+	credentials?: {
+		username: string;
+		password: string;
+	};
+}
+export interface WhoisEvent {
+	domain: string;
+	whois: any;
+}
+export interface FTPConnectEvent {
+	ip: string;
+	port?: number;
+}
+export interface DigEvent {
+	target: string;
+}
+export interface DirhunterEvent {
+	host: string;
+	results: string[];
+}
+export interface GeoipEvent {
+	ip: string;
+}
+export interface CatEvent {
+	id: string;
+	name: string;
+	extension?: string;
+	data?: string;
+}
+export interface ExplorerEvent {
+	ip: string;
+}
+export interface FileOpenEvent {
+	app: string;
+	data: any;
+}
+export interface FileTransferEvent {
+	type: "DOWNLOAD" | "UPLOAD";
+	file: {
+		id: string;
+		name: string;
+		extension?: string;
+	};
+}
+export interface BrowserWebsiteOpenedEvent {
+	siteName: string;
+	url: string;
+}
+export interface TerminalInstallPackageEvent {
+	cId: string;
+	pkg: string;
+}
+export interface DatabaseConnectedEvent {
+	ip: string;
+	database?: string;
+}
+export interface DatabaseDataUpdateEvent {
+	table: string;
+	data: any;
+}
+interface MailEvent {
+	from: string;
+	to: string;
+	subject: string;
+}
+export interface MailAccountCreatedEvent {
+	email: string;
+	password: string;
+}
+export interface MailAccountLoggedInEvent {
+	email: string;
+}
+export interface BankTransferEvent {
+	amount: number;
+	from: string;
+	to: string;
+}
+export interface BankAccountCreatedEvent {
+	id: string;
+	IBAN: string;
+	owner?: string;
+}
+export interface BankLogoutEvent {
+	id: string;
+	IBAN: string;
+}
+export interface QuestClaimedEvent {
+	name: string;
+	id: string;
+}
+export interface MetasploitEvent {
+	type: string;
+	data: any;
+}
+export interface MetasploitSearchEvent {
+	search: string;
+	matchedModules: any[];
+}
+export interface MetasploitUseEvent {
+	name: string;
+	type: string;
+}
+export interface MeterpreterConnectedEvent {
+	ip: string;
+	session: any;
+}
+export interface TwotterAccountCreatedEvent {
+	id: string;
+	username: string;
+}
+export interface TwotterAccountLoginEvent {
+	id: string;
+	username: string;
+}
+export interface TwotterPostSeenEvent {
+	id: string;
+	userId: string;
+}
+export interface TwotterPostEvent {
+	questId: string;
+	tweetIndex: number;
+}
+export interface TwotterProfileSeenEvent {
+	id: string;
+	username: string;
+}
+export interface KisscordFriendAddedEvent {
+	id: string;
+	username: string;
+	isFriend: boolean;
+}
+export interface KisscordMessagingEvent {
+	channel: string;
+	isMine?: boolean;
+}
+export interface WeeChatConnectedEvent {
+	host: string;
+}
+export interface WeeChatDisconnectedEvent {
+	host: string;
+}
+export interface WeeChatMessageEvent {
+	host: string;
+	username: string;
+	message: any;
+}
+export interface NetworkPortChangesEvent {
+	ip: string;
+	port: number;
+	active: boolean;
+}
+export interface NetworkUserActivityEvent {
+	userId: string;
+	online: boolean;
+}
+export interface NetworkWifiConnectedEvent {
+	ip: string;
+	ssid?: string;
+}
+export interface PFSenseLoginEvent {
+	ip: string;
+}
+export interface PFSenseChangesEvent {
+	old: any;
+	new: any;
+}
+export interface SqlmapListTablesEvent {
+	host: string;
+}
+export interface SqlmapDumpTableEvent {
+	host: string;
+	tableName: string;
+}
+export interface RemoteConnectionEstablishedEvent {
+	ip: string;
+	service?: string;
+}
+export interface RemoteConnectionDisconnectedEvent {
+	ip: string;
+	service?: string;
+}
+/**
+ * Map of event names to their payload types.
+ * Mod authors use these as: Events.on("Terminal.NmapScan", (data) => { ... })
+ *
+ * Supports declaration merging — mods can extend this interface
+ * to add custom events with full type safety:
+ * ```ts
+ * declare module "@hotbunny/hackhub-content-sdk" {
+ *     interface ModEventMap {
+ *         "MyMod.CustomEvent": { score: number };
+ *     }
+ * }
+ * ```
+ */
+export interface ModEventMap {
+	"Terminal.NmapScan": NmapScanEvent;
+	"Terminal.Nslookup": NslookupEvent;
+	"Terminal.Ping": PingEvent;
+	"Terminal.InstallPackage": TerminalInstallPackageEvent;
+	"Terminal.SSH.Connected": SSHConnectedEvent;
+	"Terminal.SSH.Disconnected": SSHConnectedEvent;
+	"Terminal.SSH.FileDownload": SSHFileDownloadEvent;
+	"Terminal.Hydra": HydraEvent;
+	"Terminal.Whois": WhoisEvent;
+	"Terminal.FTP.Connect": FTPConnectEvent;
+	"Terminal.Dig": DigEvent;
+	"Terminal.Dirhunter": DirhunterEvent;
+	"Terminal.Geoip": GeoipEvent;
+	"Terminal.Cat": CatEvent;
+	"Terminal.Explorer": ExplorerEvent;
+	"Files.Open": FileOpenEvent;
+	"Files.Transfer": FileTransferEvent;
+	"Files.Deleted": {
+		id: string;
+		name: string;
+	};
+	"Browser.WebsiteOpened": BrowserWebsiteOpenedEvent;
+	"Database.Connected": DatabaseConnectedEvent;
+	"Database.DataUpdate": DatabaseDataUpdateEvent;
+	"Mail.Received": MailEvent;
+	"Mail.Read": MailEvent;
+	"Mail.AccountCreated": MailAccountCreatedEvent;
+	"Mail.AccountLoggedIn": MailAccountLoggedInEvent;
+	"Bank.Transfer": BankTransferEvent;
+	"Bank.AccountCreated": BankAccountCreatedEvent;
+	"Bank.Logout": BankLogoutEvent;
+	"Quest.Claimed": QuestClaimedEvent;
+	"Metasploit.Event": MetasploitEvent;
+	"Metasploit.Search": MetasploitSearchEvent;
+	"Metasploit.Use": MetasploitUseEvent;
+	"Metasploit.Meterpreter.Connected": MeterpreterConnectedEvent;
+	"Twotter.AccountCreated": TwotterAccountCreatedEvent;
+	"Twotter.AccountLogin": TwotterAccountLoginEvent;
+	"Twotter.PostSeen": TwotterPostSeenEvent;
+	"Twotter.Post": TwotterPostEvent;
+	"Twotter.ProfileSeen": TwotterProfileSeenEvent;
+	"Kisscord.FriendAdded": KisscordFriendAddedEvent;
+	"Kisscord.Messaging": KisscordMessagingEvent;
+	"WeeChat.Connected": WeeChatConnectedEvent;
+	"WeeChat.Disconnected": WeeChatDisconnectedEvent;
+	"WeeChat.Message": WeeChatMessageEvent;
+	"Network.PortChanges": NetworkPortChangesEvent;
+	"Network.UserActivity": NetworkUserActivityEvent;
+	"Network.WifiConnected": NetworkWifiConnectedEvent;
+	"PFSense.Login": PFSenseLoginEvent;
+	"PFSense.Changes": PFSenseChangesEvent;
+	"Sqlmap.ListTables": SqlmapListTablesEvent;
+	"Sqlmap.DumpTable": SqlmapDumpTableEvent;
+	"RemoteConnection.Established": RemoteConnectionEstablishedEvent;
+	"RemoteConnection.Disconnected": RemoteConnectionDisconnectedEvent;
+	"AppStore.Downloaded": string;
+}
+export type ModEventName = keyof ModEventMap;
+export type ModEventCallback<T extends ModEventName> = (data: ModEventMap[T]) => void;
+export interface FileDefinition {
+	name: string;
+	extension?: string;
+	data?: string;
+	isFolder?: boolean;
+	children?: FileDefinition[];
+	readonly?: boolean;
+	hidden?: boolean;
+}
+export interface FileInfo {
+	id: string;
+	name: string;
+	extension?: string;
+	isFolder?: boolean;
+	data?: string;
+	parent?: string;
+	readonly?: boolean;
+	hidden?: boolean;
+}
+export interface FileCreateOptions {
+	name: string;
+	extension?: string;
+	data?: string;
+	parentPath?: string;
+	isFolder?: boolean;
+}
+/** Network device type. */
+export declare enum NetworkDeviceType {
+	Router = "ROUTER",
+	Device = "DEVICE",
+	Firewall = "FIREWALL",
+	Splitter = "SPLITTER",
+	Printer = "PRINTER"
+}
+/** Port definition for a network device. */
+export interface NetworkPort {
+	external: number;
+	internal: number;
+	active?: boolean;
+	locked?: boolean;
+	service?: string;
+	version?: string;
+}
+/** Firewall rule definition. */
+export interface FirewallRule {
+	allowed: boolean;
+	port: number;
+	source?: string;
+	destination?: string;
+	locked?: boolean;
+}
+/** Domain attached to a network device. */
+export interface NetworkDomain {
+	name: string;
+	vulnerabilities?: NetworkVulnerability[];
+}
+export interface NetworkVulnerability {
+	type: "SQL_INJECTION" | "XSS" | "CORS" | "SSRF" | "LFI" | "RFI" | "RCE";
+	version?: string;
+}
+/** User account on a network device. */
+export interface NetworkUser {
+	username: string;
+	password?: string;
+	firstName?: string;
+	lastName?: string;
+	online?: boolean;
+	files?: NetworkFileMap[];
+	acceptReverseTCP?: boolean;
+	email?: {
+		address: string;
+		password: string;
+	};
+}
+/** File definition for a network device's file system. */
+export interface NetworkFileMap {
+	name: string;
+	extension?: string;
+	data?: string;
+	isFolder?: boolean;
+	children?: NetworkFileMap[];
+	readonly?: boolean;
+	hidden?: boolean;
+	locked?: boolean;
+}
+/** Location info for a network device. */
+export interface NetworkLocation {
+	latitude: string;
+	longitude: string;
+	city?: string;
+	country?: string;
+}
+/**
+ * Child subnet in a Router or Splitter's hierarchy.
+ * This is the type used inside `children` arrays.
+ */
+export type ChildSubnetDefinition = {
+	id?: string;
+	ip: string;
+	users: NetworkUser[];
+	name?: string;
+	domain?: NetworkDomain;
+	lanIp?: string;
+	ports?: NetworkPort[];
+	location?: NetworkLocation;
+	isIpHidden?: boolean;
+	ssh?: boolean;
+} & ({
+	type: NetworkDeviceType.Router;
+	model?: string;
+	accessable?: boolean;
+	children: ChildSubnetDefinition[];
+} | {
+	type: NetworkDeviceType.Device;
+} | {
+	type: NetworkDeviceType.Firewall;
+	rules: FirewallRule[];
+} | {
+	type: NetworkDeviceType.Splitter;
+	children: ChildSubnetDefinition[];
+} | {
+	type: NetworkDeviceType.Printer;
+});
+/**
+ * Top-level network creation definition.
+ * Passed to `Network.createSubnetNetwork()`.
+ *
+ * Typically a Router with children:
+ * ```ts
+ * Network.createSubnetNetwork({
+ *     ip: "45.33.32.156",
+ *     type: NetworkDeviceType.Router,
+ *     ports: [{ external: 80, internal: 80, active: true, service: "http" }],
+ *     users: [],
+ *     children: [
+ *         { ip: "10.0.0.2", type: NetworkDeviceType.Device, users: [...], ports: [...] },
+ *     ],
+ * });
+ * ```
+ */
+export type SubnetNetworkDefinition = {
+	id?: string;
+	ip: string;
+	users: NetworkUser[];
+	name?: string;
+	domain?: NetworkDomain;
+	lanIp?: string;
+	ports: NetworkPort[];
+	location?: NetworkLocation;
+	isIpHidden?: boolean;
+} & ({
+	type: NetworkDeviceType.Router;
+	model?: string;
+	accessable?: boolean;
+	children: ChildSubnetDefinition[];
+} | {
+	type: NetworkDeviceType.Device;
+} | {
+	type: NetworkDeviceType.Firewall;
+	rules: FirewallRule[];
+} | {
+	type: NetworkDeviceType.Splitter;
+	children: ChildSubnetDefinition[];
+} | {
+	type: NetworkDeviceType.Printer;
+});
+/** Simplified read-only subnet info returned by query methods. */
+export interface SubnetInfo {
+	ip: string;
+	lanIp?: string;
+	type: string;
+	hostname?: string;
+	domain?: string;
+	online?: boolean;
+	ports: {
+		port: number;
+		service?: string;
+		version?: string;
+		active?: boolean;
+	}[];
+	users: {
+		username: string;
+	}[];
+}
+/** Domain resolution result. */
+export interface DomainInfo {
+	domain: string;
+	ip: string;
+	subdomains?: string[];
+}
+/** Read-only firewall info returned by query methods. */
+export interface FirewallInfo {
+	ip: string;
+	rules: FirewallRule[];
+}
+export interface WifiNetwork {
+	ssid: string;
+	bssid: string;
+	channel: string;
+	encryption: string;
+	signal: number;
+}
+export interface MailDefinition {
+	subject: string;
+	content: string;
+	from?: string;
+	to?: string;
+	attachments?: MailAttachment[];
+}
+export interface MailAttachment {
+	name: string;
+	extension: string;
+	data?: string;
+}
+export interface MailInfo {
+	id: string;
+	from: string;
+	to: string;
+	subject: string;
+	read: boolean;
+	sentAt: number;
+}
+export interface BankTransactionOptions {
+	amount: number;
+	description: string;
+	from?: {
+		IBAN: string;
+		name: string;
+	};
+	to?: string;
+}
+export interface BankAccountInfo {
+	id: string;
+	IBAN: string;
+	balance: number;
+	owner: string;
+}
+export interface ModManifest {
+	id: string;
+	name: string;
+	version: string;
+	author: string;
+	description: string;
+	gameVersion?: string;
+	dependencies?: string[];
+	permissions?: ModPermission[];
+	icon?: string;
+}
+export type ModPermission = "filesystem" | "network" | "events" | "mail" | "bank" | "shell" | "ui";
+export interface ModInfo {
+	id: string;
+	name: string;
+	version: string;
+	author: string;
+	description: string;
+	icon?: string;
+	enabled: boolean;
+	error?: string;
+}
+export declare enum ModStatus {
+	Pending = "PENDING",
+	Loading = "LOADING",
+	Loaded = "LOADED",
+	Error = "ERROR",
+	Disabled = "DISABLED"
+}
+export interface TwotterCreateUserOptions {
+	id?: string;
+	username?: string;
+	firstName?: string;
+	lastName?: string;
+	avatar?: string;
+	banner?: string;
+	bio?: string;
+	gender?: "male" | "female";
+	verified?: boolean;
+	password?: string;
+	followers?: number;
+	following?: number;
+	isMine?: boolean;
+}
+export interface TwotterUser {
+	id: string;
+	username: string;
+	name: string;
+	surname: string;
+	avatar: string;
+	banner: string;
+	bio?: string;
+	joinedAt: string;
+	followers: number;
+	following: number;
+	verified?: boolean;
+	password: string;
+	isMine?: boolean;
+}
+export interface TwotterTweetInteraction {
+	comments: number;
+	share: number;
+	likes: number;
+	views: number;
+}
+export interface TwotterTweet {
+	id: string;
+	userId: string;
+	content: string;
+	sendedAt?: string;
+	interaction: TwotterTweetInteraction;
+	showInTimeline?: boolean;
+}
+export declare enum KisscordStatus {
+	Online = "ONLINE",
+	Offline = "OFFLINE",
+	Idle = "IDLE"
+}
+export interface KisscordCreateUserOptions {
+	id?: string;
+	username?: string;
+	firstName?: string;
+	lastName?: string;
+	avatar?: string;
+	isFriend?: boolean;
+	status?: KisscordStatus;
+}
+export interface KisscordUser {
+	id: string;
+	username: string;
+	name: string;
+	surname: string;
+	avatar: string;
+	isFriend?: boolean;
+	status: KisscordStatus;
+}
+export interface KisscordMessagePayload {
+	channel: string;
+	content: string;
+	isMine?: boolean;
+}
+export interface KisscordMessageInfo {
+	channel: string;
+	content: string;
+	isMine?: boolean;
+	sendedAt: string;
+	read?: boolean;
+}
+export interface WeeChatMessage {
+	host: string;
+	username: string;
+	message: string;
+}
+export interface WeeChatServer {
+	host: string;
+	password: string;
+}
+/**
+ * Base class for a mod package entry point. Every mod must have exactly
+ * one class extending Bootstrap, decorated with @RegisterModPackage.
+ *
+ * @example
+ * ```ts
+ * import { Bootstrap, RegisterModPackage } from "@hotbunny/hackhub-content-sdk";
+ *
+ * @RegisterModPackage
+ * export class MyMod extends Bootstrap {
+ *     OnModPackageLoaded() {
+ *         console.log("My mod has been loaded!");
+ *     }
+ *
+ *     OnModPackageUnloaded() {
+ *         console.log("My mod has been unloaded.");
+ *     }
+ * }
+ * ```
+ */
+export declare abstract class Bootstrap {
+	/** The parsed manifest.json of this mod. Set by the loader at runtime. */
+	Manifest: ModManifest;
+	/** Called after the mod package and all its registered content are loaded. */
+	OnModPackageLoaded(): void | Promise<void>;
+	/** Called when the mod is being unloaded (e.g. disabled by user). */
+	OnModPackageUnloaded(): void;
+}
+/**
+ * Base class for mod quests. Mod authors extend this to create custom quests.
+ *
+ * @example
+ * ```ts
+ * import { Quest, RegisterQuest } from "@hotbunny/hackhub-content-sdk";
+ *
+ * @RegisterQuest
+ * export class HackThePlanet extends Quest {
+ *     Name = "HackThePlanet";
+ *     Title = "Hack the Planet";
+ *     Rewards = { money: 5000 };
+ *     Objectives = [
+ *         { name: "scan", description: "Scan the target with nmap" },
+ *         { name: "exploit", description: "Exploit the vulnerability", unlocksAfter: ["scan"] },
+ *     ];
+ *
+ *     OnStart() {
+ *         Events.on("Terminal.NmapScan", (data) => {
+ *             if (data.ip === "192.168.1.50") this.completeObjective("scan");
+ *         });
+ *     }
+ * }
+ * ```
+ */
+export declare abstract class Quest {
+	abstract Name: string;
+	abstract Title: string;
+	abstract Objectives: QuestObjectiveDefinition[];
+	Description?: string;
+	Icon?: string;
+	Rewards?: QuestRewards;
+	Employer?: Partial<QuestEmployer>;
+	AutoStart?: boolean;
+	AutoComplete?: boolean;
+	QuestsToComplete?: string[];
+	MaxClaim?: number;
+	MaxClaimPerDay?: number;
+	Abandonable?: boolean;
+	HasCompleteButton?: boolean;
+	/**
+	 * Called when the quest is first claimed/started.
+	 * Use this to set up event listeners for objective completion.
+	 */
+	OnStart(): void | Promise<void>;
+	/** Called when all objectives are completed and the quest finishes. */
+	OnComplete(): void | Promise<void>;
+	/** Called when the quest is abandoned by the player. */
+	OnAbandon(): void;
+	/** Called when the quest's objectives listener starts (e.g. after game load). */
+	OnObjectivesStart(): void;
+	/** Return initial quest data. Override to provide custom data storage. */
+	CreateData(): any;
+	/** Complete an objective by its name. */
+	completeObjective(name: string): void;
+}
+/**
+ * Base class for mod websites. Mod authors extend this to create
+ * in-game websites accessible through the FirebearBrowser.
+ *
+ * Pages use HTML content which is rendered inside a sandboxed iframe.
+ *
+ * @example
+ * ```ts
+ * import { Website, RegisterWebsite } from "@hotbunny/hackhub-content-sdk";
+ * import homePage from "./pages/home.html";
+ * import aboutPage from "./pages/about.html";
+ *
+ * @RegisterWebsite
+ * export class HackerForum extends Website {
+ *     SiteName = "Hacker Forum";
+ *     Host = "hackerforum.net";
+ *     Icon = "./assets/forum-icon.png";
+ *     Pages = [
+ *         { path: "/", title: "Home", html: homePage },
+ *         { path: "/about", title: "About", html: aboutPage },
+ *     ];
+ * }
+ * ```
+ */
+export declare abstract class Website {
+	abstract SiteName: string;
+	abstract Host: string;
+	abstract Icon: string;
+	abstract Pages: WebsitePageDefinition[];
+	Popular?: boolean;
+}
+/**
+ * Base class for mod terminal commands. Mod authors extend this to
+ * create custom terminal commands that players can run.
+ *
+ * @example
+ * ```ts
+ * import { Command, RegisterCommand } from "@hotbunny/hackhub-content-sdk";
+ *
+ * @RegisterCommand
+ * export class PingTool extends Command {
+ *     CommandName = "myping";
+ *     Description = "Custom ping tool";
+ *     Autocomplete = [
+ *         { label: "myping", type: "STRING" },
+ *         { label: "<target>", type: "IP" },
+ *     ];
+ *
+ *     async Run(tools: CommandTools) {
+ *         const args = tools.getArgs();
+ *         if (args.length === 0) {
+ *             tools.printError("Usage: myping <ip>");
+ *             return;
+ *         }
+ *         tools.println(`Pinging ${args[0]}...`);
+ *         await tools.sleep(1000);
+ *         tools.println("Reply received.");
+ *     }
+ * }
+ * ```
+ */
+export declare abstract class Command {
+	abstract CommandName: string;
+	abstract Description: string;
+	Autocomplete: CommandAutoComplete[];
+	PackageName?: string;
+	abstract Run(tools: CommandTools): Promise<void> | void;
+}
+/**
+ * Base class for mod desktop applications. Mod authors extend this
+ * to create custom apps that appear on the in-game desktop.
+ *
+ * App UI is defined via HTML, rendered inside a sandboxed iframe
+ * within the game's window manager.
+ *
+ * @example
+ * ```ts
+ * import { App, RegisterApp } from "@hotbunny/hackhub-content-sdk";
+ * import appHTML from "./app.html";
+ *
+ * @RegisterApp
+ * export class PasswordGenerator extends App {
+ *     AppName = "PasswordGenerator";
+ *     Title = "Password Generator";
+ *     Icon = "./assets/icon.png";
+ *     HTML = appHTML;
+ *     DefaultSize = { width: 400, height: 300 };
+ *     Store = {
+ *         title: "Password Generator",
+ *         ratings: 4.5,
+ *         description: "Generate secure passwords",
+ *     };
+ * }
+ * ```
+ */
+export declare abstract class App {
+	abstract AppName: string;
+	abstract Title: string;
+	abstract Icon: string;
+	abstract HTML: string;
+	abstract DefaultSize: AppSize;
+	MinSize?: AppSize;
+	MaxSize?: AppSize;
+	MaxOpen?: number;
+	DisableMaximize?: boolean;
+	DisableMinimize?: boolean;
+	Store?: {
+		title: string;
+		ratings: number;
+		description: string;
+		price?: number;
+	};
+}
+/**
+ * Game events API. Allows mods to listen to in-game events
+ * such as terminal commands, file operations, network events, etc.
+ *
+ * Also supports cross-mod custom events via `register`, `emit`, and
+ * declaration merging on `ModEventMap`.
+ *
+ * @example
+ * ```ts
+ * import { Events } from "@hotbunny/hackhub-content-sdk";
+ *
+ * // Listen to a built-in game event
+ * Events.on("Terminal.NmapScan", (data) => {
+ *     console.log(`Player scanned ${data.ip}`);
+ * });
+ *
+ * // Register + emit a custom cross-mod event
+ * Events.register("MyMod.BossDefeated");
+ * Events.emit("MyMod.BossDefeated", { bossName: "Hydra", reward: 500 });
+ *
+ * // Another mod can listen
+ * Events.on("MyMod.BossDefeated", (data) => { ... });
+ * ```
+ */
+export declare namespace Events {
+	/**
+	 * Register a custom event name for cross-mod communication.
+	 * This is optional but recommended for discoverability.
+	 */
+	export function register(name: string): void;
+	/**
+	 * Listen to a game event or a custom mod event.
+	 * Returns an unsubscribe function.
+	 *
+	 * For known `ModEventMap` keys, the callback is fully typed.
+	 * For custom string events, the callback receives `any`.
+	 */
+	export function on<T extends string>(event: T, callback: (data: T extends keyof ModEventMap ? ModEventMap[T] : any) => void): () => void;
+	/** Remove a specific event listener. */
+	export function off(event: string, callback: Function): void;
+	/**
+	 * Emit an event.
+	 * - Known `ModEventMap` keys are dispatched through the game's
+	 *   event system AND the custom event bus.
+	 * - Unknown/custom event names go only through the custom event bus,
+	 *   enabling cross-mod communication without polluting game internals.
+	 */
+	export function emit<T extends string>(event: T, data?: T extends keyof ModEventMap ? ModEventMap[T] : any): void;
+	export {};
+}
+/**
+ * Virtual file system API. Allows mods to create, read, and manage
+ * files in the in-game file system.
+ *
+ * @example
+ * ```ts
+ * import { Files } from "@hotbunny/hackhub-content-sdk";
+ *
+ * await Files.create({ name: "readme", extension: "txt", data: "Hello world" });
+ * const file = await Files.getByPath("~/readme.txt");
+ * ```
+ */
+export declare namespace Files {
+	/** Create a new file or folder. */
+	export function create(options: FileCreateOptions): Promise<FileInfo>;
+	/** Create a file tree from a nested definition. */
+	export function createTree(parentPath: string, tree: FileDefinition[]): Promise<void>;
+	/** Get a file by its virtual path. */
+	export function getByPath(path: string): Promise<FileInfo | null>;
+	/** Get a file by its internal ID. */
+	export function getById(id: string): FileInfo | null;
+	/** Get all children of a folder. */
+	export function getChildren(folderId: string): Promise<FileInfo[]>;
+	/** Delete a file by ID. */
+	export function remove(id: string): void;
+	/** Rename a file. */
+	export function rename(id: string, newName: string): void;
+	/** Move a file to a different folder. */
+	export function move(id: string, newParentId: string): void;
+	/** Read file content as string. */
+	export function read(id: string): string | undefined;
+	/** Write string content to a file. */
+	export function write(id: string, data: string): void;
+	/** Check if a file or folder exists at the given path. */
+	export function exists(path: string): Promise<boolean>;
+	/** Get the user's home directory path. */
+	export function getHomePath(): string;
+	/** Get the user's desktop directory path. */
+	export function getDesktopPath(): string;
+	export {};
+}
+/**
+ * Network API. Allows mods to interact with the in-game network
+ * simulation — routers, devices, firewalls, ports, domains, and users.
+ *
+ * The network uses a hierarchical structure:
+ * Router → Firewall / Device / Splitter / Printer
+ *
+ * @example
+ * ```ts
+ * import { Network, NetworkDeviceType } from "@hotbunny/hackhub-content-sdk";
+ *
+ * Network.createSubnetNetwork({
+ *     ip: "45.33.32.156",
+ *     type: NetworkDeviceType.Router,
+ *     users: [],
+ *     ports: [{ external: 80, internal: 80, active: true, service: "http" }],
+ *     children: [
+ *         {
+ *             ip: "10.0.0.2",
+ *             type: NetworkDeviceType.Device,
+ *             users: [Network.createUser({ username: "admin" })],
+ *             ports: [{ external: 22, internal: 22, active: true, service: "ssh" }],
+ *         },
+ *     ],
+ * });
+ * ```
+ */
+export declare namespace Network {
+	/**
+	 * Create a full subnet network (Router with children hierarchy).
+	 * This is equivalent to the game's `Network.CreateSubnetNetwork()`.
+	 */
+	export function createSubnetNetwork(definition: SubnetNetworkDefinition): void;
+	/** Destroy an entire network by its router IP. Removes all child subnets and files. */
+	export function destroyNetwork(ip: string): Promise<void>;
+	/** Get subnet info by IP address. */
+	export function getSubnet(ip: string): SubnetInfo | null;
+	/** Get all subnets in the game network. */
+	export function getAllSubnets(): SubnetInfo[];
+	/** Find a subnet by its domain name. */
+	export function getSubnetByDomain(domain: string): SubnetInfo | null;
+	/** Get all child subnets of a router. */
+	export function getChildSubnets(routerIp: string): SubnetInfo[];
+	/** Register a domain name pointing to an IP. */
+	export function registerDomain(domain: string, ip: string): void;
+	/** Remove a registered domain. */
+	export function removeDomain(domain: string): void;
+	/** Resolve a domain to its IP and info. */
+	export function resolveDomain(domain: string): DomainInfo | null;
+	/** Get the player's current IP address. */
+	export function getPlayerIp(): string;
+	/** Get the firewall protecting a given IP. Returns rules and the firewall's IP. */
+	export function getFirewall(ip: string): FirewallInfo | null;
+	/** Add a firewall rule to the firewall protecting the given IP. */
+	export function addFirewallRule(ip: string, rule: FirewallRule): void;
+	/** Remove a firewall rule by port from the firewall protecting the given IP. */
+	export function removeFirewallRule(ip: string, port: number): void;
+	/** Check if a request to the given IP and port would be blocked by the firewall. */
+	export function isRequestBlocked(ip: string, port: number): boolean;
+	/** Open a port on a router (set active=true). */
+	export function openPort(routerIp: string, portExternal: number): void;
+	/** Close a port on a router (set active=false). */
+	export function closePort(routerIp: string, portExternal: number): void;
+	/** Add a new port to a subnet. */
+	export function addPort(routerIp: string, port: NetworkPort): void;
+	/** Remove a port from a subnet by its external port number. */
+	export function removePort(routerIp: string, portExternal: number): void;
+	/**
+	 * Helper: Create a user object with sensible defaults.
+	 * Missing fields are filled with random values at runtime.
+	 */
+	export function createUser(options?: Partial<NetworkUser>): NetworkUser;
+	/**
+	 * Helper: Create a default user schema with root + optional guest + custom users.
+	 * Matches the game's `Network.CreateDefaultUserSchema()`.
+	 */
+	export function createDefaultUserSchema(users: NetworkUser[], options?: {
+		guest?: boolean;
+	}): NetworkUser[];
+	/** Re-export the device type enum for convenience. */
+	export const Type: typeof NetworkDeviceType;
+	export {};
+}
+/**
+ * Mail API. Allows mods to send and read in-game emails.
+ *
+ * @example
+ * ```ts
+ * import { Mail } from "@hotbunny/hackhub-content-sdk";
+ *
+ * Mail.send({
+ *     from: "boss@company.com",
+ *     subject: "New assignment",
+ *     content: "Your target is 192.168.1.50. Good luck.",
+ * });
+ * ```
+ */
+export declare namespace Mail {
+	/** Send an email to the player's inbox. */
+	export function send(mail: MailDefinition): void;
+	/** Get all emails in the player's inbox. */
+	export function getInbox(): MailInfo[];
+	/** Mark an email as read. */
+	export function markAsRead(id: string): void;
+	/** Get the player's email address. */
+	export function getPlayerEmail(): string;
+	export {};
+}
+/**
+ * Bank API. Allows mods to interact with the in-game banking system.
+ *
+ * @example
+ * ```ts
+ * import { Bank } from "@hotbunny/hackhub-content-sdk";
+ *
+ * Bank.transaction({
+ *     amount: 5000,
+ *     description: "Quest reward payment",
+ *     from: { IBAN: "DE89370400440532013000", name: "Anonymous Employer" },
+ * });
+ *
+ * const account = Bank.getPlayerAccount();
+ * console.log(`Balance: ${account.balance}`);
+ * ```
+ */
+export declare namespace Bank {
+	/** Create a bank transaction (deposit money to the player). */
+	export function transaction(options: BankTransactionOptions): void;
+	/** Get the player's bank account info. */
+	export function getPlayerAccount(): BankAccountInfo;
+	/** Get the player's current balance. */
+	export function getBalance(): number;
+	export {};
+}
+/**
+ * UI API. Allows mods to show notifications, toasts and dialogs.
+ *
+ * @example
+ * ```ts
+ * import { UI } from "@hotbunny/hackhub-content-sdk";
+ *
+ * UI.notify("Quest updated!");
+ * UI.toast("File downloaded successfully", "success");
+ * ```
+ */
+export declare namespace UI {
+	/** Show a notification popup. */
+	export function notify(message: string): void;
+	/** Show a toast message. */
+	export function toast(message: string, type?: "success" | "error" | "warning" | "info"): void;
+	export {};
+}
+/**
+ * Persistent storage API scoped to the current mod.
+ * Data persists across game sessions (saved to disk).
+ * Each mod has its own isolated namespace — other mods
+ * cannot read or write your storage.
+ *
+ * For sharing data between mods, use {@link SharedStorage}.
+ * For session-only data, use {@link Variables}.
+ *
+ * @example
+ * ```ts
+ * import { Storage } from "@hotbunny/hackhub-content-sdk";
+ *
+ * Storage.set("highScore", 42);
+ * const score = Storage.get<number>("highScore"); // 42
+ * ```
+ */
+declare namespace Storage$1 {
+	/** Get a value by key. Returns undefined if not found. */
+	export function get<T = any>(key: string): T | undefined;
+	/** Set a value by key. Value must be JSON-serializable. */
+	export function set(key: string, value: any): void;
+	/** Remove a key from storage. */
+	export function remove(key: string): void;
+	/** Clear all data in this mod's storage. */
+	export function clear(): void;
+	/** Get all stored key-value pairs. */
+	export function getAll(): Record<string, any>;
+	export {};
+}
+/**
+ * In-memory variables API scoped to the current mod.
+ * Data is lost when the game is closed (session-only).
+ *
+ * @example
+ * ```ts
+ * import { Variables } from "@hotbunny/hackhub-content-sdk";
+ *
+ * Variables.set("targetFound", true);
+ * const found = Variables.get<boolean>("targetFound"); // true
+ * ```
+ */
+export declare namespace Variables {
+	/** Get a value by key. Returns undefined if not found. */
+	export function get<T = any>(key: string): T | undefined;
+	/** Set a value by key. */
+	export function set(key: string, value: any): void;
+	/** Remove a key. */
+	export function remove(key: string): void;
+	/** Clear all variables for this mod. */
+	export function clear(): void;
+	/** Get all stored key-value pairs. */
+	export function getAll(): Record<string, any>;
+	export {};
+}
+/**
+ * Persistent shared storage accessible by all mods.
+ * Data persists across game sessions.
+ *
+ * Use this for inter-mod data sharing. All mods read/write
+ * from the same key space, so choose descriptive key names
+ * to avoid collisions (e.g. "mymod.leaderboard").
+ *
+ * @example
+ * ```ts
+ * import { SharedStorage } from "@hotbunny/hackhub-content-sdk";
+ *
+ * SharedStorage.set("mymod.leaderboard", [{ name: "Player1", score: 100 }]);
+ * const board = SharedStorage.get("mymod.leaderboard");
+ * ```
+ */
+export declare namespace SharedStorage {
+	/** Get a shared value by key. Returns undefined if not found. */
+	export function get<T = any>(key: string): T | undefined;
+	/** Set a shared value by key. Value must be JSON-serializable. */
+	export function set(key: string, value: any): void;
+	/** Remove a shared key. */
+	export function remove(key: string): void;
+	/** Get all shared key-value pairs. */
+	export function getAll(): Record<string, any>;
+	export {};
+}
+/**
+ * In-memory shared variables accessible by all mods.
+ * Data is lost when the game is closed (session-only).
+ *
+ * Use this for runtime inter-mod communication.
+ * All mods share the same key space.
+ *
+ * @example
+ * ```ts
+ * import { SharedVariables } from "@hotbunny/hackhub-content-sdk";
+ *
+ * SharedVariables.set("globalDifficulty", "hard");
+ * const diff = SharedVariables.get<string>("globalDifficulty");
+ * ```
+ */
+export declare namespace SharedVariables {
+	/** Get a shared variable by key. Returns undefined if not found. */
+	export function get<T = any>(key: string): T | undefined;
+	/** Set a shared variable by key. */
+	export function set(key: string, value: any): void;
+	/** Remove a shared variable. */
+	export function remove(key: string): void;
+	/** Get all shared variables. */
+	export function getAll(): Record<string, any>;
+	export {};
+}
+/**
+ * Shell API. Allows mods to interact with the in-game terminal.
+ *
+ * @example
+ * ```ts
+ * import { Shell } from "@hotbunny/hackhub-content-sdk";
+ *
+ * const username = Shell.getUsername();
+ * const hostname = Shell.getHostname();
+ * await Shell.exec("nmap 192.168.1.1");
+ * ```
+ */
+export declare namespace Shell {
+	/** Execute a terminal command programmatically. */
+	export function exec(command: string): Promise<void>;
+	/** Get the player's OS username. */
+	export function getUsername(): string;
+	/** Get the computer's hostname. */
+	export function getHostname(): string;
+	/** Get the player's IP address. */
+	export function getPlayerIp(): string;
+	/** Get list of installed terminal packages. */
+	export function getInstalledPackages(): string[];
+	/** Check if a specific package is installed. */
+	export function isPackageInstalled(pkg: string): boolean;
+	export {};
+}
+/**
+ * Twotter API. Allows mods to interact with the in-game
+ * Twitter-like social media platform.
+ *
+ * @example
+ * ```ts
+ * import { Twotter } from "@hotbunny/hackhub-content-sdk";
+ *
+ * const user = Twotter.createUser({
+ *     username: "darknet_hacker",
+ *     bio: "I hack things.",
+ *     verified: true,
+ * });
+ * Twotter.addUser(user);
+ *
+ * Twotter.postTweet({
+ *     id: "my-tweet-1",
+ *     userId: user.id,
+ *     content: "Just hacked the mainframe!",
+ *     interaction: { comments: 5, share: 2, likes: 42, views: 1000 },
+ *     showInTimeline: true,
+ * });
+ * ```
+ */
+export declare namespace Twotter {
+	/** Create a new Twotter user with sensible defaults for missing fields. */
+	export function createUser(options?: TwotterCreateUserOptions): TwotterUser;
+	/** Add a user to the Twotter platform. */
+	export function addUser(user: TwotterUser): void;
+	/** Post a tweet. */
+	export function postTweet(tweet: TwotterTweet): void;
+	/** Remove a tweet by its ID. */
+	export function removeTweet(id: string): void;
+	/** Find a user by their username. */
+	export function getUserByUsername(username: string): TwotterUser | undefined;
+	/** Find a user by their ID. */
+	export function getUserById(id: string): TwotterUser | undefined;
+	/** Toggle like on a tweet. */
+	export function toggleLike(postId: string, userId: string): void;
+	export {};
+}
+/**
+ * Kisscord API. Allows mods to interact with the in-game
+ * Discord-like messaging application.
+ *
+ * @example
+ * ```ts
+ * import { Kisscord, KisscordStatus } from "@hotbunny/hackhub-content-sdk";
+ *
+ * const npc = Kisscord.createUser({
+ *     username: "informant",
+ *     firstName: "John",
+ *     lastName: "Doe",
+ *     isFriend: true,
+ *     status: KisscordStatus.Online,
+ * });
+ * Kisscord.addUser(npc);
+ *
+ * Kisscord.sendMessage(npc.id, "I have the files you need.");
+ * ```
+ */
+export declare namespace Kisscord {
+	/** Create a new Kisscord user with sensible defaults. */
+	export function createUser(options?: KisscordCreateUserOptions): KisscordUser;
+	/** Add a user to the Kisscord system. */
+	export function addUser(user: KisscordUser): void;
+	/** Remove a user and their messages from Kisscord. */
+	export function removeUser(userId: string): void;
+	/** Mark a user as a friend. Returns true if successful. */
+	export function addFriend(username: string): boolean;
+	/** Send a message in a channel (channel = user ID). */
+	export function sendMessage(channelUserId: string, content: string, isMine?: boolean): void;
+	/** Change a user's online status. */
+	export function changeStatus(userId: string, status: KisscordStatus): void;
+	/** Get all messages in a channel. */
+	export function getMessages(channelUserId: string): KisscordMessageInfo[];
+	/** Re-export status enum for convenience. */
+	export const Status: typeof KisscordStatus;
+	export {};
+}
+/**
+ * WeeChat API. Allows mods to interact with the in-game
+ * IRC-like terminal chat system.
+ *
+ * @example
+ * ```ts
+ * import { WeeChat } from "@hotbunny/hackhub-content-sdk";
+ *
+ * WeeChat.createServer("irc.darknet.org", "secret123");
+ *
+ * WeeChat.sendMessage({
+ *     host: "irc.darknet.org",
+ *     username: "informant",
+ *     message: "The target IP is 45.33.32.156",
+ * });
+ *
+ * const history = WeeChat.getHistory("irc.darknet.org");
+ * ```
+ */
+export declare namespace WeeChat {
+	/** Register a WeeChat IRC server that the player can connect to. */
+	export function createServer(host: string, password: string): void;
+	/** Remove a registered WeeChat server. */
+	export function removeServer(host: string, password: string): void;
+	/** Send a message in a WeeChat channel. */
+	export function sendMessage(message: WeeChatMessage): void;
+	/** Get message history, optionally filtered by host. */
+	export function getHistory(host?: string): WeeChatMessage[];
+	export {};
+}
+/**
+ * Marks a class as the mod's entry point.
+ * Each mod must have exactly one @RegisterModPackage class extending Bootstrap.
+ */
+export declare function RegisterModPackage<T extends new (...args: any[]) => Bootstrap>(target: T): T;
+/**
+ * Registers a Quest class with the mod system.
+ * The quest will be available in the game once the mod is loaded.
+ */
+export declare function RegisterQuest<T extends new (...args: any[]) => Quest>(target: T): T;
+/**
+ * Registers a Website class with the mod system.
+ * The website will be accessible through the in-game browser once loaded.
+ */
+export declare function RegisterWebsite<T extends new (...args: any[]) => Website>(target: T): T;
+/**
+ * Registers a terminal Command class with the mod system.
+ * The command will be available in the terminal once loaded.
+ */
+export declare function RegisterCommand<T extends new (...args: any[]) => Command>(target: T): T;
+/**
+ * Registers a desktop App class with the mod system.
+ * The app will be available for installation via AppStore once loaded.
+ */
+export declare function RegisterApp<T extends new (...args: any[]) => App>(target: T): T;
+
+export {
+	MailEvent as MailEventPayload,
+	Storage$1 as Storage,
+};
+
+export {};