export interface BRColor {
	r: number;
	b: number;
	g: number;
	a: number;
}
export interface BRVector {
	x: number;
	y: number;
	z: number;
}
export interface BRBanListEntry {
	bannerId: string;
	created: string;
	expires: string;
	reason: string;
}
export interface BRBanList {
	banList: Record<string, BRBanListEntry>;
}
export interface BRRolePermission {
	name: string;
	state: "Allowed" | "Unchanged" | "Forbidden";
}
export interface BRRoleSetupEntry {
	name: string;
	permissions: BRRolePermission[];
	color: BRColor;
	bHasColor: boolean;
}
export interface BRRoleSetup {
	roles: BRRoleSetupEntry[];
	defaultRole: BRRoleSetupEntry;
	ownerRoleColor: BRColor;
	bOwnerRoleHasColor: boolean;
	version: string;
}
export interface BRRoleAssignments {
	savedPlayerRoles: Record<string, {
		roles: string[];
	}>;
}
export interface BRPlayerNameCache {
	savedPlayerNames: Record<string, string>;
}
export type Preset<T extends string, D> = {
	formatVersion?: "1";
	presetVersion?: "1";
	type?: T;
	data?: D;
};
export type EnvironmentPreset = Preset<"Environment", {
	groups?: {
		Sky?: {
			timeOfDay?: number;
			timeChangeSpeed?: number;
			sunAngle?: number;
			sunScale?: number;
			sunHorizonScaleMultiplier?: number;
			sunlightColor?: BRColor;
			skyIntensity?: number;
			skyColor?: BRColor;
			moonScale?: number;
			moonlightIntensity?: number;
			moonlightColor?: BRColor;
			starsIntensity?: number;
			starsColor?: BRColor;
			auroraIntensity?: number;
			weatherIntensity?: number;
			rainSnow?: number;
			cloudCoverage?: number;
			cloudSpeedMultiplier?: number;
			precipitationParticleAmount?: number;
			bCloseLightning?: boolean;
			rainVolume?: number;
			closeThunderVolume?: number;
			distantThunderVolume?: number;
			windVolume?: number;
			clearFogDensity?: number;
			cloudyFogDensity?: number;
			clearFogHeightFalloff?: number;
			cloudyFogHeightFalloff?: number;
			fogColor?: BRColor;
		};
		GroundPlate?: {
			variance?: number;
			varianceBrickSize?: number;
			groundColor?: BRColor;
			groundAccentColor?: BRColor;
			isVisible?: boolean;
			bUseStudTexture?: boolean;
		};
		Water?: {
			waterHeight?: number;
			waterAbsorption?: BRVector;
			waterScattering?: BRVector;
			waterFogIntensity?: number;
			waterFogAmbientColor?: BRColor;
			waterFogAmbientScale?: number;
			waterFogScatteringColor?: BRColor;
			waterFogScatteringScale?: number;
		};
		Ambience?: {
			selectedAmbienceTypeInt?: number;
			ambienceVolume?: number;
			reverbEffect?: string;
		};
	};
}>;
declare class ConsoleCommand {
	private readonly versions;
	/** CL version at which the game removed this command, if it was ever removed. */
	removedAt?: number;
	/** @param versions [sinceVersion, name] pairs in ascending version order */
	constructor(versions: readonly [
		number,
		string
	][]);
	/** Resolve the command name for a given game CL version. */
	resolve(version: number): string;
	/** Mark this command as removed from the game at `version` (fluent). */
	removedIn(version: number): this;
	/**
	 * Whether this command no longer exists at the given game version. An unknown
	 * version (server not started / not detected yet, `<= 0`) is treated as still
	 * present so we never warn on commands sent before the version is known.
	 */
	isRemovedAt(version: number): boolean;
	/** every name this command has gone by, across versions */
	get names(): readonly string[];
}
declare const COMMAND_TABLE: {
	Bricks: {
		ActuallyReduce: ConsoleCommand;
		Clear: ConsoleCommand;
		ClearAll: ConsoleCommand;
		ClearRegion: ConsoleCommand;
		Cluster: {
			EnableMergingDynamicGrids: ConsoleCommand;
			EnableMergingGlobalGrid: ConsoleCommand;
			MaxClusterHalfExtent: ConsoleCommand;
			MaxClusterWeight: ConsoleCommand;
			MaxSplitWeight: ConsoleCommand;
			MinCollapseWeight: ConsoleCommand;
			MinMergeThreshold: ConsoleCommand;
			MinRootHalfExtent: ConsoleCommand;
		};
		ClusterMesh: {
			CardCaching: ConsoleCommand;
			DrawDistance: ConsoleCommand;
			Hysteresis: ConsoleCommand;
			Lod0KeepBias: ConsoleCommand;
			MaxTransitionsPerFrame: ConsoleCommand;
			MemoryBudgetBucketSize: ConsoleCommand;
			MemoryBudgetMB: ConsoleCommand;
			Residency: ConsoleCommand;
			ResidencyConeHysteresis: ConsoleCommand;
			ResidencyConeMargin: ConsoleCommand;
			ResidencyWideFOV: ConsoleCommand;
			ResidencyZoomHysteresisKillRate: ConsoleCommand;
		};
		DebugSaveFileScreenshots: ConsoleCommand;
		DisableLoadWiresForLegacySave: ConsoleCommand;
		DrawDebugOctree: ConsoleCommand;
		DumpChunkStats: ConsoleCommand;
		DumpCoverageStats: ConsoleCommand;
		DumpGeometryStats: ConsoleCommand;
		DumpGroupStats: ConsoleCommand;
		EnableExtendedSort: ConsoleCommand;
		EnableLumenCards: ConsoleCommand;
		ExportModel: ConsoleCommand;
		GenerateGates: ConsoleCommand;
		GenerateMathTables: ConsoleCommand;
		GetOctreeStats: ConsoleCommand;
		Load: ConsoleCommand;
		LoadTemplate: ConsoleCommand;
		LODScreenSizeScale: ConsoleCommand;
		LogClusterBuildTime: ConsoleCommand;
		LogStreamSizes: ConsoleCommand;
		MaxChunkClusterEntriesPerTick: ConsoleCommand;
		MaxChunkEntries: ConsoleCommand;
		MaxChunkUpdatesPerTick: ConsoleCommand;
		MaxChunkUpdateTimePerTick: ConsoleCommand;
		MaxClusterResultsToApplyPerTick: ConsoleCommand;
		MaxSubscribed: ConsoleCommand;
		OptimizeVertexCache: ConsoleCommand;
		PrintOctreeLeafStats: ConsoleCommand;
		RebuildClusters: ConsoleCommand;
		RebuildMeshes: ConsoleCommand;
		Save: ConsoleCommand;
		SaveFileCompressionLevel: ConsoleCommand;
		SaveFileReadBrickLimit: ConsoleCommand;
		SaveFileReadComponentInstanceLimit: ConsoleCommand;
		SaveFileReadComponentTypeLimit: ConsoleCommand;
		SaveFileReadDimensionLimit: ConsoleCommand;
		SaveFileReadOwnerLimit: ConsoleCommand;
		SaveFileReadSizeLimit: ConsoleCommand;
		SaveRegion: ConsoleCommand;
		ValidateMathTables: ConsoleCommand;
		Vehicle: {
			AntiRollScale: ConsoleCommand;
			ClientFullSim: ConsoleCommand;
			DebugDraw: ConsoleCommand;
		};
		WheelEngine: {
			VisualiseTurningCircles: ConsoleCommand;
		};
		WipeMirrorTables: ConsoleCommand;
	};
	BundleCompressionLevel: ConsoleCommand;
	Bundles: {
		AutoCloseDelay: ConsoleCommand;
	};
	Catalog: {
		ClearCache: ConsoleCommand;
		HideBlacklisted: ConsoleCommand;
	};
	Chat: {
		Broadcast: ConsoleCommand;
		Command: ConsoleCommand;
		MessageForUnknownCommands: ConsoleCommand;
		StatusMessage: ConsoleCommand;
		Whisper: ConsoleCommand;
	};
	ComplexityWarning: {
		BrickCount: ConsoleCommand;
		FrozenEntityCount: ConsoleCommand;
		UnfrozenEntityCount: ConsoleCommand;
	};
	Debug: {
		CauseEnsure: ConsoleCommand;
		CauseHang: ConsoleCommand;
		ChangeBundleOwner: ConsoleCommand;
		Crash: ConsoleCommand;
		ListBundleOwners: ConsoleCommand;
		TestMarkdown: ConsoleCommand;
		TestMarkup: ConsoleCommand;
	};
	DrawDebug: {
		BrickClusters: {
			$: ConsoleCommand;
			Neighbors: ConsoleCommand;
			OctreeBounds: ConsoleCommand;
		};
		BrickClusterSplitTree: ConsoleCommand;
		BrickLumenCards: ConsoleCommand;
		ClientUpdates: ConsoleCommand;
		Colliders: {
			$: ConsoleCommand;
			DrawCOM: ConsoleCommand;
			DrawCustomMass: ConsoleCommand;
		};
		Constraints: ConsoleCommand;
		Entities: {
			$: ConsoleCommand;
			Boxes: ConsoleCommand;
			Dots: ConsoleCommand;
		};
		Lights: {
			$: ConsoleCommand;
			RedThreshold: ConsoleCommand;
		};
		Texts: ConsoleCommand;
	};
	EnableImgui: ConsoleCommand;
	EOS: {
		AttemptLogin: ConsoleCommand;
		Disable: ConsoleCommand;
		SetSocketName: ConsoleCommand;
	};
	GPUMappedArray: {
		MinBlocks: ConsoleCommand;
		ReservedHeadroomBlocks: ConsoleCommand;
	};
	Inspector: {
		ShowFloatTest: ConsoleCommand;
		ShowGraphics: ConsoleCommand;
	};
	Interview: ConsoleCommand;
	Iris: {
		EnableMapDeltaSerialization: ConsoleCommand;
	};
	LagIndicator: {
		MinLatency: ConsoleCommand;
		MinTimeSincePacket: ConsoleCommand;
	};
	Lua: {
		Execute: ConsoleCommand;
		ExecuteScript: ConsoleCommand;
	};
	Msgpack: {
		Default: {
			MaxContainerSize: ConsoleCommand;
			MaxDepth: ConsoleCommand;
			MaxEnumValueCount: ConsoleCommand;
			MaxFieldCount: ConsoleCommand;
			MaxFieldNameLength: ConsoleCommand;
			MaxFlatArraySize: ConsoleCommand;
			MaxNameLength: ConsoleCommand;
			MaxStringLength: ConsoleCommand;
			MaxTypeCount: ConsoleCommand;
		};
	};
	NudgePhysicsObject: ConsoleCommand;
	Permissions: {
		GrantRole: ConsoleCommand;
		RevokeRole: ConsoleCommand;
		Save: ConsoleCommand;
	};
	Physics: {
		ForceFreezeDynamicGrids: ConsoleCommand;
	};
	Placer: {
		LogRowTests: ConsoleCommand;
	};
	PlayerParts: {
		UseFastRender: ConsoleCommand;
	};
	Prefab: {
		GiveToPlayer: ConsoleCommand;
		Load: ConsoleCommand;
		SaveRegion: ConsoleCommand;
	};
	Resizer: {
		LogTests: ConsoleCommand;
	};
	RunHardwareBenchmark: ConsoleCommand;
	Server: {
		Environment: {
			LoadPreset: ConsoleCommand;
			Reset: ConsoleCommand;
			SavePreset: ConsoleCommand;
		};
		GameMode: {
			EndRound: ConsoleCommand;
			NextRound: ConsoleCommand;
			PrintLeaderboard: ConsoleCommand;
			Reset: ConsoleCommand;
		};
		Minigames: {
			Delete: ConsoleCommand;
			List: ConsoleCommand;
			LoadPreset: ConsoleCommand;
			NextRound: ConsoleCommand;
			Reset: ConsoleCommand;
			SavePreset: ConsoleCommand;
		};
		PlayerPositions: ConsoleCommand;
		Players: {
			Damage: ConsoleCommand;
			GiveItem: ConsoleCommand;
			Kill: ConsoleCommand;
			PrintAllLeaderboardValues: ConsoleCommand;
			PrintLeaderboardValue: ConsoleCommand;
			RemoveItem: ConsoleCommand;
			SetLeaderboardValue: ConsoleCommand;
			SetMinigame: ConsoleCommand;
			SetTeam: ConsoleCommand;
		};
		Status: ConsoleCommand;
		Teams: {
			PrintAllLeaderboardValues: ConsoleCommand;
			PrintLeaderboardValue: ConsoleCommand;
		};
	};
	Text: {
		FlushRecoveryFrames: ConsoleCommand;
		MaxCharsPolledPerFrame: ConsoleCommand;
		MaxCharsShapedPerFrame: ConsoleCommand;
	};
	Thumbnails: {
		WipeCache: ConsoleCommand;
	};
	Voice: {
		DebugDecode: ConsoleCommand;
		SyntheticInput: ConsoleCommand;
		TestJitter: ConsoleCommand;
	};
	Weapons: {
		DebugFiringVectors: ConsoleCommand;
		DebugHitValidation: ConsoleCommand;
		EnableHitValidation: ConsoleCommand;
		LatencyCompensationDelayMethod: ConsoleCommand;
		LatencyCompensationLimit: ConsoleCommand;
		LatencyCompensationOffset: ConsoleCommand;
		ProjectileClientLatencyCompensationEnabled: ConsoleCommand;
		ProjectileLatencyCompensationEnabled: ConsoleCommand;
		ProjectilePredictionEnabled: ConsoleCommand;
	};
	WireFuzzer: {
		ClearBreakpoints: ConsoleCommand;
		ComponentsPerTick: ConsoleCommand;
		DisconnectBeforeConnect: ConsoleCommand;
		GatesPerTick: ConsoleCommand;
		MaxComponents: ConsoleCommand;
		MaxGates: ConsoleCommand;
		MaxWires: ConsoleCommand;
		ModificationsPerTick: ConsoleCommand;
		RerouteDuplication: ConsoleCommand;
		Start: ConsoleCommand;
		StartWithSeed: ConsoleCommand;
		Stop: ConsoleCommand;
		WiresPerTick: ConsoleCommand;
	};
	WireGraphViz: ConsoleCommand;
	WireRenderer: {
		EnablePorts: ConsoleCommand;
		EnableWires: ConsoleCommand;
	};
	World: {
		ClearAll: ConsoleCommand;
		ClearRegion: ConsoleCommand;
		CreateEmpty: ConsoleCommand;
		ListRevisions: ConsoleCommand;
		Load: ConsoleCommand;
		LoadAdditive: ConsoleCommand;
		LoadRevision: ConsoleCommand;
		Save: ConsoleCommand;
		SaveAs: ConsoleCommand;
	};
	WorldSerializer: {
		LogPrefabLoads: ConsoleCommand;
		RedirectLegacyWheelJoints: ConsoleCommand;
		WipeOwnershipOnLoad: ConsoleCommand;
	};
};
/** Recursively turn a {@link CommandTree} into resolved command-name strings. */
export type Resolved<T> = T extends ConsoleCommand ? string : {
	[K in keyof T]: Resolved<T[K]>;
};
/**
 * Version-resolved console command names, nested by namespace.
 * Every leaf is the command string for the running game version.
 */
export type ConsoleCommands = Resolved<typeof COMMAND_TABLE>;
export interface IOmeggaOptions {
	noauth?: boolean;
	noplugin?: boolean;
	noweb?: boolean;
	debug?: boolean;
}
export interface IServerStatus {
	serverName: string;
	description: string;
	bricks: number;
	components: number;
	time: number;
	/** player slots, from the status' `Players (online/max):` line */
	maxPlayers?: number;
	/**
	 * every integer-valued line in the status header, keyed by a snake_cased
	 * version of its label (`bricks`, `components`, ...). Reported generically so
	 * stats the game adds later are available without a parser change.
	 */
	stats?: Record<string, number>;
	players: {
		name: string;
		ping: number;
		time: number;
		roles: string[];
		address: string;
		id: string;
	}[];
}
export type IMinigameList = {
	index: number;
	name: string;
	numMembers: number;
	owner: {
		name: string;
		id: string;
	};
}[];
export type IPlayerPositions = {
	player: OmeggaPlayer;
	/** null when the player has no pawn (e.g. spectating) */
	pawn: string | null;
	/** null when the player has no pawn position */
	pos: number[] | null;
	isDead: boolean;
}[];
export type ILogMinigame = {
	name: string;
	ruleset: string;
	index: number;
	members: OmeggaPlayer[];
	teams: {
		name: string;
		team: string;
		color: number[];
		members: OmeggaPlayer[];
	}[];
};
/**
 * The single gamemode that replaced minigames (~CL14000). Owns the teams and
 * the players within them.
 */
export type IGamemode = {
	/** the gamemode name (e.g. "Sandbox") */
	name: string;
	/** the BP_GameStateBase_C object id */
	gamestate: string;
	/** every player across all teams */
	members: OmeggaPlayer[];
	teams: {
		name: string;
		/** the BRGameModeTeam object id */
		team: string;
		/** [r, g, b, a] */
		color: number[];
		members: OmeggaPlayer[];
	}[];
};
export interface BRSBytes extends Uint8Array {
	brsOffset: number;
}
export type Modify<T, R> = Omit<T, keyof R> & R;
export type Bytes = Uint8Array | BRSBytes;
export type Uuid = string;
export type UnrealClass = string;
export type UnrealObject = string;
export type UnrealBoolean = boolean;
export type UnrealFloat = number;
export type UnrealInteger = number;
export type UnrealInteger64 = number;
export type UnrealColor = [
	number,
	number,
	number,
	number
];
export type UnrealByte = number;
export type UnrealRotator = [
	number,
	number,
	number
];
export type Vector3d = Vector;
export type IntVector = Vector;
export type UnrealString = string;
export type WireGraphVariant = {
	number: number;
} | {
	integer: number;
} | {
	bool: boolean;
} | {
	exec: true;
} | {
	object: true;
};
export type BRInventoryEntryPlan = string;
export type UnrealType = UnrealClass | UnrealObject | UnrealBoolean | UnrealFloat | UnrealColor | UnrealByte | UnrealRotator | UnrealString | WireGraphVariant | UnrealInteger64 | Vector3d | IntVector | BRInventoryEntryPlan;
export type UnrealTypeFromString<T> = T extends "Class" ? UnrealClass : T extends "Object" ? UnrealObject : T extends "Boolean" ? UnrealBoolean : T extends "Float" ? UnrealFloat : T extends "Color" ? UnrealColor : T extends "Byte" ? UnrealByte : T extends "Rotator" ? UnrealRotator : T extends "Rotator3d" ? UnrealRotator : T extends "Vector3d" ? Vector3d : T extends "IntVector" ? IntVector : T extends "String" ? UnrealString : T extends "BRInventoryEntryPlan" ? BRInventoryEntryPlan : T extends "WireGraphVariant" ? WireGraphVariant : T extends "WireGraphPrimMathVariant" ? WireGraphVariant : T extends "Integer" ? UnrealInteger : T extends "Integer64" ? UnrealInteger64 : UnrealType;
export interface User {
	id: Uuid;
	name: string;
}
export interface LegacyOwner extends User {
	bricks: number;
}
export interface Owner extends LegacyOwner {
	display_name: string;
}
declare enum Direction {
	XPositive = 0,
	XNegative = 1,
	YPositive = 2,
	YNegative = 3,
	ZPositive = 4,
	ZNegative = 5
}
declare enum Rotation {
	Deg0 = 0,
	Deg90 = 1,
	Deg180 = 2,
	Deg270 = 3
}
export type ColorRgb = [
	number,
	number,
	number
];
export interface Collision {
	player: boolean;
	weapon: boolean;
	interaction: boolean;
	tool: boolean;
	physics: boolean;
}
export interface AppliedComponent {
	[property: string]: UnrealType;
}
export interface UnknownComponents {
	[component_name: string]: {
		version: number;
		brick_indices?: number[];
		properties: {
			[property: string]: string;
		};
	};
}
export type KnownComponents = {
	BCD_SpotLight: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Rotation: "Rotator";
			InnerConeAngle: "Float";
			OuterConeAngle: "Float";
			Brightness: "Float";
			Radius: "Float";
			Color: "Color";
			bUseBrickColor: "Boolean";
			bCastShadows: "Boolean";
		};
	};
	BCD_PointLight: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bMatchBrickShape: "Boolean";
			Brightness: "Float";
			Radius: "Float";
			Color: "Color";
			bUseBrickColor: "Boolean";
			bCastShadows: "Boolean";
		};
	};
	BCD_ItemSpawn: {
		version: 1;
		brick_indices?: number[];
		properties: {
			PickupClass: "Class";
			bPickupEnabled: "Boolean";
			bPickupRespawnOnMinigameReset: "Boolean";
			PickupMinigameResetRespawnDelay: "Float";
			bPickupAutoDisableOnPickup: "Boolean";
			PickupRespawnTime: "Float";
			PickupOffsetDirection: "Byte";
			PickupOffsetDistance: "Float";
			PickupRotation: "Rotator";
			PickupScale: "Float";
			bPickupAnimationEnabled: "Boolean";
			PickupAnimationAxis: "Byte";
			bPickupAnimationAxisLocal: "Boolean";
			PickupSpinSpeed: "Float";
			PickupBobSpeed: "Float";
			PickupBobHeight: "Float";
			PickupAnimationPhase: "Float";
		};
	};
	BCD_Interact: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bPlayInteractSound: "Boolean";
			Message: "String";
			ConsoleTag: "String";
		};
	};
	BCD_AudioEmitter: {
		version: 1;
		brick_indices?: number[];
		properties: {
			AudioDescriptor: "Object";
			VolumeMultiplier: "Float";
			PitchMultiplier: "Float";
			InnerRadius: "Float";
			MaxDistance: "Float";
			bSpatialization: "Boolean";
		};
	};
	Component_AudioEmitter: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			AudioDescriptor: "Object";
			VolumeMultiplier: "Float";
			PitchMultiplier: "Float";
			InnerRadius: "Float";
			MaxDistance: "Float";
			bSpatialization: "Boolean";
			FocusAzimuth: "Float";
			NonFocusAzimuth: "Float";
			NonFocusVolumeAttenuation: "Float";
		};
	};
	Component_BotSpawn: {
		version: 1;
		brick_indices?: number[];
		properties: {
			RespawnTime: "Float";
			CorpseTimeout: "Float";
			GunSkill: "Float";
			Agression: "Float";
			ReactionTime: "Float";
			MovementRandomness: "Float";
			Jumpyness: "Float";
			MovementAmount: "Float";
			AttackMovementAmount: "Float";
			AggroRange: "Float";
			bCanJump: "Boolean";
			bBackVision: "Boolean";
			bVisionRaycasting: "Boolean";
			bCanTargetPlayers: "Boolean";
			bCanTargetBots: "Boolean";
			MoveTarget: "Vector3d";
			BotWeapon: "Class";
		};
	};
	Component_CheckPoint: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bRotatePlayerGravityOnSpawn: "Boolean";
		};
	};
	Component_Damage: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Message: "String";
			ConsoleTag: "String";
		};
	};
	Component_GoalPoint: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	Component_InputSplitter: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	Component_OneShotAudioEmitter: {
		version: 1;
		brick_indices?: number[];
		properties: {
			AudioDescriptor: "Object";
			VolumeMultiplier: "Float";
			PitchMultiplier: "Float";
			InnerRadius: "Float";
			MaxDistance: "Float";
			bSpatialization: "Boolean";
			bEnableRepeat: "Boolean";
			RepeatTime: "Float";
			RepeatVariance: "Float";
		};
	};
	Component_SpawnPoint: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bRotatePlayerGravityOnSpawn: "Boolean";
			bEnable: "Boolean";
		};
	};
	Component_Target: {
		version: 1;
		brick_indices?: number[];
		properties: {
			OnTime: "Float";
		};
	};
	Component_Internal_AnimatedButton: {
		version: 1;
		brick_indices?: number[];
		properties: {
			PressSound: "Object";
			ReleaseSound: "Object";
			bAllowNearbyInteraction: "Boolean";
			bHiddenInteraction: "Boolean";
			PromptCustomLabel: "String";
		};
	};
	Component_Internal_AnimatedSwitch: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			InteractSound: "Object";
			bAllowNearbyInteraction: "Boolean";
			bHiddenInteraction: "Boolean";
			PromptCustomLabel: "String";
		};
	};
	Component_Internal_AttachedZone: {
		version: 1;
		brick_indices?: number[];
		properties: {
			ZoneStartDistance: "Integer";
			ZoneEndDistance: "Integer";
			bIsBuildingZone: "Boolean";
			bIsLooseZone: "Boolean";
			bIsShareZone: "Boolean";
		};
	};
	Component_Internal_Bearing: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bLimitAngle: "Boolean";
			LimitAngle: "Float";
			Damping: "Float";
		};
	};
	Component_Internal_Joint_Wheel: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			DriveSpeed: "Float";
			DrivePower: "Float";
			bSteerEnabled: "Boolean";
			Steer: "Float";
			SteerLimitDegree: "Float";
			SteerPower: "Float";
			bSuspensionEnabled: "Boolean";
			SuspensionStiffness: "Float";
			SuspensionDamping: "Float";
			JointDistance: "Integer";
			bDriveWhenNotAttachedToEngine: "Boolean";
			bCanBrake: "Boolean";
			bAllowEngineSteerCorrect: "Boolean";
			Damping: "Float";
		};
	};
	Component_Internal_Motor: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			Speed: "Float";
			Power: "Float";
			bLimitAngle: "Boolean";
			LimitAngle: "Float";
			Damping: "Float";
		};
	};
	Component_Internal_MotorSlider: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			Speed: "Float";
			Power: "Float";
			bPositionsArePercentages: "Boolean";
			Damping: "Float";
		};
	};
	Component_Internal_Rerouter: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	Component_Internal_Seat: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bIsOccupied: "Boolean";
			ExitOffset: "IntVector";
			bAllowNearbyInteraction: "Boolean";
			bHiddenInteraction: "Boolean";
			PromptCustomLabel: "String";
		};
	};
	Component_Internal_Servo: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			TargetAngle: "Float";
			Power: "Float";
			ActiveDamping: "Float";
			ForceLimit: "Float";
			bLimitAngle: "Boolean";
			LimitAngle: "Float";
			Damping: "Float";
		};
	};
	Component_Internal_ServoSlider: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			TargetPosition: "Float";
			Power: "Float";
			TopSpeed: "Float";
			Exponent: "Float";
			bPositionsArePercentages: "Boolean";
			Damping: "Float";
		};
	};
	Component_Internal_Slider: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bPositionsArePercentages: "Boolean";
			Damping: "Float";
		};
	};
	Component_Internal_Socket: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	Component_Internal_WeightBrick: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Mass: "Float";
			MassSize: "IntVector";
			MassOffset: "IntVector";
		};
	};
	Component_Internal_WheelEngine: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bEnabled: "Boolean";
			bEnableManualControl: "Boolean";
			ManualInput_Drive: "Float";
			ManualInput_Steer: "Float";
			bManualInput_Brake: "Boolean";
			CustomMass: "Float";
			CustomMassVerticalOffset: "Float";
			DriveInterpSpeed: "Float";
			DriveSpeed: "Float";
			DriveAcceleratingPowerMultiplier: "Float";
			DriveBrakingPowerMultiplier: "Float";
			DriveDampingMultiplier: "Float";
			SteerPowerMultiplier: "Float";
			SteerInterpSpeed: "Float";
			SteerLimitDegree: "Float";
			CenterOfSteering: "Float";
			bTankSteering: "Boolean";
			TankSteerSpeedMultiplier: "Float";
			WaterDriveForce: "Float";
			WaterSteeringForce: "Float";
			AudioDescriptor: "Object";
		};
	};
	Component_WireGraph_PlayAudioAt: {
		version: 1;
		brick_indices?: number[];
		properties: {
			AudioDescriptor: "Object";
			VolumeMultiplier: "Float";
			PitchMultiplier: "Float";
			InnerRadius: "Float";
			MaxDistance: "Float";
			bSpatialization: "Boolean";
		};
	};
	Component_WireGraph_SetInventoryEntry: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Slot: "Integer";
			EntryPlan: "BRInventoryEntryPlan";
		};
	};
	BrickComponentType_Internal_CharacterZoneEvent_Entered: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_Internal_CharacterZoneEvent_Left: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_Internal_ReadBrickGrid: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_Internal_TeleportDestination: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_Internal_ZoneEvent_BrickChanged: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_Internal_ZoneEvent_BrickRemoved: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_WireGraphPseudo_BufferSeconds: {
		version: 1;
		brick_indices?: number[];
		properties: {
			SecondsToWait: "Float";
			ZeroSecondsToWait: "Float";
			CurrentTime: "Float";
			Input: "WireGraphVariant";
			Output: "WireGraphVariant";
			Buffered: "WireGraphVariant";
			Queued: "WireGraphVariant";
			bHasQueued: "Boolean";
		};
	};
	BrickComponentType_WireGraphPseudo_BufferTicks: {
		version: 1;
		brick_indices?: number[];
		properties: {
			TicksToWait: "Integer";
			ZeroTicksToWait: "Integer";
			CurrentTicks: "Integer";
			Input: "WireGraphVariant";
			Output: "WireGraphVariant";
			Buffered: "WireGraphVariant";
			Queued: "WireGraphVariant";
			bHasQueued: "Boolean";
		};
	};
	BrickComponentType_WireGraphPseudo_Var: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Value: "WireGraphVariant";
		};
	};
	BrickComponentType_WireGraph_Exec_Branch: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_WireGraph_Exec_Character_SetTempPermission: {
		version: 1;
		brick_indices?: number[];
		properties: {
			PermissionTagStr: "String";
			bPermissionEnable: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Exec_Character_ShowHint: {
		version: 1;
		brick_indices?: number[];
		properties: {
			HintTitle: "String";
			HintText: "String";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_AddLocationRotation: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Vector: "Vector3d";
			Rotation: "Rotator3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_AddVelocity: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Vector: "Vector3d";
			Rotation: "Vector3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_RelativeTeleport: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_WireGraph_Exec_Entity_SetGravityDirection: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Rotation: "Rotator3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_SetLocation: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Vector: "Vector3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_SetLocationRotation: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Vector: "Vector3d";
			Rotation: "Rotator3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_SetRotation: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Rotation: "Rotator3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_SetVelocity: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Vector: "Vector3d";
			Rotation: "Vector3d";
		};
	};
	BrickComponentType_WireGraph_Exec_Entity_Teleport: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_WireGraph_Exec_Union: {
		version: 1;
		brick_indices?: number[];
		properties: {};
	};
	BrickComponentType_WireGraph_Exec_Var_Get: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Value: "WireGraphVariant";
		};
	};
	BrickComponentType_WireGraph_Exec_Var_Increment: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Value: "WireGraphVariant";
		};
	};
	BrickComponentType_WireGraph_Exec_Var_Set: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Value: "WireGraphVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseAND: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseNAND: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseNOR: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseNOT: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Input: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseOR: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseShiftLeft: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseShiftRight: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_BitwiseXOR: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "Integer64";
			InputB: "Integer64";
		};
	};
	BrickComponentType_WireGraph_Expr_Ceil: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Input: "Double";
		};
	};
	BrickComponentType_WireGraph_Expr_CompareEqual: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphVariant";
			InputB: "WireGraphVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_CompareGreater: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_CompareLess: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_CompareLessOrEqual: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_CompareNotEqual: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphVariant";
			InputB: "WireGraphVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_Floor: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Input: "Double";
		};
	};
	BrickComponentType_WireGraph_Expr_LogicalAND: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bInputA: "Boolean";
			bInputB: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Expr_LogicalNAND: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bInputA: "Boolean";
			bInputB: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Expr_LogicalNOR: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bInputA: "Boolean";
			bInputB: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Expr_LogicalNOT: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bInput: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Expr_LogicalOR: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bInputA: "Boolean";
			bInputB: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Expr_LogicalXOR: {
		version: 1;
		brick_indices?: number[];
		properties: {
			bInputA: "Boolean";
			bInputB: "Boolean";
		};
	};
	BrickComponentType_WireGraph_Expr_MathAdd: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_MathBlend: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Blend: "Double";
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_MathDivide: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_MathModulo: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_MathModuloFloored: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_MathMultiply: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Expr_MathSubtract: {
		version: 1;
		brick_indices?: number[];
		properties: {
			InputA: "WireGraphPrimMathVariant";
			InputB: "WireGraphPrimMathVariant";
		};
	};
	BrickComponentType_WireGraph_Fake_Gamemode_RoundEndEvent: {
		version: 1;
		brick_indices?: number[];
		properties: {
			RoundNumber: "Integer";
		};
	};
	BrickComponentType_WireGraph_Fake_Gamemode_RoundStartEvent: {
		version: 1;
		brick_indices?: number[];
		properties: {
			RoundNumber: "Integer";
		};
	};
	BrickComponent_WireGraph_Expr_EdgeDetector: {
		version: 1;
		brick_indices?: number[];
		properties: {
			Input: "Double";
			bPulseOnRisingEdge: "Boolean";
			bPulseOnFallingEdge: "Boolean";
		};
	};
};
export interface DefinedComponents extends UnknownComponents, Partial<KnownComponents> {
}
export type Components<C extends DefinedComponents> = {
	[T in keyof C]: {
		[V in keyof C[T]["properties"]]: UnrealTypeFromString<C[T]["properties"][V]>;
	};
} & {
	[component_name: string]: AppliedComponent;
};
export type Vector = [
	number,
	number,
	number
];
export type WirePort = {
	brick_index: number;
	component: string;
	port: string;
};
export type Wire = {
	source: WirePort;
	target: WirePort;
};
export interface BrickV1 {
	asset_name_index: number;
	size: Vector;
	position: Vector;
	direction: Direction;
	rotation: Rotation;
	collision: boolean;
	visibility: boolean;
	color: UnrealColor | number;
}
export interface BrickV2 extends BrickV1 {
	material_index: number;
}
export interface BrickV3 extends BrickV2 {
	owner_index: number;
}
export interface BrickV8 extends BrickV3 {
	components: Components<DefinedComponents>;
}
export type BrickV9 = Modify<BrickV8, {
	physical_index: number;
	material_intensity: number;
	color: ColorRgb | number;
}>;
export type BrickV10 = Modify<BrickV9, {
	collision: Collision;
}>;
export interface BrsV1 {
	version: 1;
	map: string;
	author: User;
	description: string;
	brick_count: number;
	mods: string[];
	brick_assets: string[];
	colors: UnrealColor[];
	bricks: BrickV1[];
}
export type BrsV2 = Modify<BrsV1, {
	version: 2;
	materials: string[];
	bricks: BrickV2[];
}>;
export type BrsV3 = Modify<BrsV2, {
	version: 3;
	brick_owners: User[];
	bricks: BrickV3[];
}>;
export type BrsV4 = Modify<BrsV3, {
	version: 4;
	save_time: Uint8Array;
}>;
export type BrsV8 = Modify<BrsV4, {
	version: 8;
	host: User;
	brick_owners: LegacyOwner[];
	preview?: Bytes;
	game_version: number;
	bricks: BrickV8[];
	components: DefinedComponents;
}>;
export type BrsV9 = Modify<BrsV8, {
	version: 9;
	physical_materials: string[];
	bricks: BrickV9[];
}>;
export type BrsV10 = Modify<BrsV9, {
	version: 10;
	bricks: BrickV10[];
}>;
export type BrsV14 = Modify<BrsV10, {
	version: 14;
	wires: Wire[];
}>;
export type ReadSaveObject = BrsV1 | BrsV2 | BrsV3 | BrsV4 | BrsV8 | BrsV9 | BrsV10 | BrsV14;
export interface Brick {
	asset_name_index?: number;
	size: Vector;
	position: Vector;
	direction?: Direction;
	rotation?: Rotation;
	collision?: boolean | Partial<Collision>;
	visibility?: boolean;
	material_index?: number;
	physical_index?: number;
	material_intensity?: number;
	color?: ColorRgb | number | UnrealColor | number[];
	owner_index?: number;
	components?: Components<DefinedComponents>;
}
export interface WriteSaveObject {
	game_version?: number;
	map?: string;
	description?: string;
	author?: Partial<User>;
	host?: Partial<User>;
	mods?: string[];
	brick_assets?: string[];
	colors?: UnrealColor[];
	materials?: string[];
	brick_owners?: Partial<Owner>[];
	physical_materials?: string[];
	preview?: Bytes;
	bricks: Brick[];
	save_time?: ArrayLike<number>;
	components?: DefinedComponents;
	wires?: Wire[];
}
export interface FoundFile {
	contentId: number;
	createdAt: number;
}
export interface WorldFs {
	findFileByPath(path: string): FoundFile | null;
	/** The file revision whose [created_at, deleted_at) interval contains
	 * date. For single-revision containers this is findFileByPath. */
	findFileByPathAtRevision(path: string, date: number): FoundFile | null;
	/** Decompressed blob content. */
	readBlob(contentId: number): Uint8Array;
	readFile(path: string): Uint8Array;
	/** Names of the subfolders of a folder path ('' = root). */
	childFolders(path: string): string[];
	/** Names of the files directly inside a folder path ('' = root). */
	childFiles(path: string): string[];
}
export type PendingEntry = [
	name: string,
	node: PendingNode
];
export type PendingNode = {
	type: "folder";
	children: PendingEntry[];
} | {
	type: "file";
	content: Uint8Array;
};
export type Compressor = (data: Uint8Array) => Uint8Array | null;
export interface BrzContainerOptions {
	/** zstd compressor (e.g. node:zlib zstdCompressSync); return null to skip.
	 * Omitted -> every blob stored raw (still a valid archive, and what the
	 * byte-parity gates compare against). */
	compress?: Compressor;
}
declare function writeBrzContainer(root: PendingEntry[], options?: BrzContainerOptions): Uint8Array;
declare class BrzReader implements WorldFs {
	readonly folderParentIds: number[];
	readonly folderNames: string[];
	readonly fileParentIds: number[];
	readonly fileContentIds: number[];
	readonly fileNames: string[];
	private blobs;
	private blobData;
	private folderLut;
	private fileLut;
	private pathCache;
	private constructor();
	static from(data: Uint8Array): BrzReader;
	/** parentId -1 = root */
	findFolder(parentId: number, name: string): number | null;
	findFile(parentId: number, name: string): {
		contentId: number;
	} | null;
	private folderIdOf;
	/** Names of the subfolders of a folder path ('' = root), in id order.
	 * A missing path yields []. */
	childFolders(path: string): string[];
	/** Names of the files directly inside a folder path ('' = root), in id
	 * order. A missing path yields []. */
	childFiles(path: string): string[];
	blobMethod(contentId: number): number;
	private blob;
	/** Decompress (if needed) and verify size + BLAKE3. */
	readBlob(contentId: number): Uint8Array;
	/** '/'-separated path from the root. An empty file (contentId -1) returns
	 * an empty buffer (the reference reader treats empty files as unfindable;
	 * a deliberate, documented deviation for usability). */
	readFile(path: string): Uint8Array;
	/** Path lookup returning the WorldFs FoundFile shape. createdAt is always
	 * 0: a .brz archive holds exactly one revision. */
	findFileByPath(path: string): FoundFile | null;
	findFileByPathAtRevision(path: string, _date: number): FoundFile | null;
	/** All file paths in file-id (BFS) order. */
	listPaths(): string[];
}
declare class ByteWriter {
	private buf;
	private view;
	private len;
	/** `capacity` pre-sizes the backing buffer. Growing copies, so callers that
	 * can cheaply compute (or bound) their output size should pass it. */
	constructor(capacity?: number);
	private ensure;
	get length(): number;
	u8(v: number): void;
	i8(v: number): void;
	bytes(v: Uint8Array | number[]): void;
	u16be(v: number): void;
	u32be(v: number): void;
	u64be(v: bigint): void;
	i16be(v: number): void;
	i32be(v: number): void;
	i64be(v: bigint): void;
	f32be(v: number): void;
	f64be(v: number): void;
	u16le(v: number): void;
	u32le(v: number): void;
	u64le(v: bigint): void;
	i16le(v: number): void;
	i32le(v: number): void;
	i64le(v: bigint): void;
	f32le(v: number): void;
	f64le(v: number): void;
	toBytes(): Uint8Array;
}
declare class ByteReader {
	data: Uint8Array;
	private view;
	offset: number;
	constructor(data: Uint8Array, offset?: number);
	get remaining(): number;
	private need;
	peek(): number;
	u8(): number;
	i8(): number;
	bytes(n: number): Uint8Array;
	u16be(): number;
	u32be(): number;
	u64be(): bigint;
	i16be(): number;
	i32be(): number;
	i64be(): bigint;
	f32be(): number;
	f64be(): number;
	u16le(): number;
	u32le(): number;
	u64le(): bigint;
	i16le(): number;
	i32le(): number;
	i64le(): bigint;
	f32le(): number;
	f64le(): number;
}
export interface SchemaData {
	enums: Map<string, Map<string, number>>;
	variants: Map<string, string[]>;
	structs: Map<string, Map<string, PropDesc>>;
}
export type EmbeddedSchemaName = "BRSavedGlobalDataSoA" | "BRSavedOwnerTableSoA" | "BRSavedBrickChunkIndexSoA" | "BRSavedBrickChunkSoA" | "BRSavedWireChunkSoA" | "BRSavedComponentChunkSoA" | "BRSavedComponentChunkSoA_max" | "BRSavedEntityChunkIndexSoA" | "BRSavedEntityChunkSoA";
export type PropDesc = {
	kind: "type" | "array" | "flatarray";
	type: string;
} | {
	kind: "map";
	key: string;
	value: string;
};
/** Compact data form emitted by scripts/syncBrdbData.mjs:
 * 'T' = plain type, ['T'] = array, ['T', null] = flat array,
 * { K: 'V' } = map (single entry). */
export type SchemaSourceProp = string | readonly [
	string
] | readonly [
	string,
	null
] | Readonly<Record<string, string>>;
export interface SchemaSource {
	enums: Readonly<Record<string, Readonly<Record<string, number>>>>;
	variants: Readonly<Record<string, readonly string[]>>;
	structs: Readonly<Record<string, Readonly<Record<string, SchemaSourceProp>>>>;
}
export type BrdbValue = number | bigint | boolean | string | null | BrdbValue[] | {
	[field: string]: BrdbValue;
};
/** A decoded variant value: which member the tag selected, plus its payload.
 * Kept tagged (rather than flattened like the reference reader) so that
 * decode -> encode round-trips byte-identically. */
export interface BrdbVariant {
	$variant: string;
	value: BrdbValue;
}
declare class BrdbSchema {
	readonly enums: Map<string, Map<string, number>>;
	readonly variants: Map<string, string[]>;
	readonly structs: Map<string, Map<string, PropDesc>>;
	constructor(enums: Map<string, Map<string, number>>, variants: Map<string, string[]>, structs: Map<string, Map<string, PropDesc>>);
	static fromText(text: string): BrdbSchema;
	/** Hydrate a schema from the generated data form (see SchemaSource). */
	static fromData(data: SchemaSource): BrdbSchema;
	static fromBinary(bytes: Uint8Array): BrdbSchema;
	/** Extract the named structs plus every type they transitively reference
	 * (sub-structs, enums, variants, and variant member types) into a
	 * self-contained subset. Primitive/unknown names are skipped. Uses a LIFO
	 * worklist; the result ORDER matches the reference implementation, and
	 * that order determines the serialized schema's bytes. */
	extractStructsTransitive(seeds: Iterable<string>): SchemaData;
	/** Merge definitions into this schema. Existing names keep their position
	 * (and are replaced); new names append, matching the reference merge. */
	merge(data: SchemaData): void;
	/** The zero value of a type: numbers 0, bool false, str '', asset refs
	 * null, arrays empty, structs recursive, enums ordinal 0, variants tag 0
	 * with the first member's zero value. */
	zeroValue(ty: string): BrdbValue;
	/** Complete a partial struct value: present fields pass through, missing
	 * fields fall back to `defaults`, then to their zero value. Unknown keys
	 * in `partial` are an error; unknown keys in `defaults` are ignored (the
	 * defaults table may carry fields a given schema revision lacks). */
	fillStruct(structName: string, partial: Readonly<Record<string, BrdbValue>>, defaults?: Readonly<Record<string, BrdbValue>>): Record<string, BrdbValue>;
	topoStructOrder(): string[];
	toBinary(): Uint8Array;
	flatTypeSize(ty: string): number;
	writeValue(w: ByteWriter, ty: string, value: BrdbValue): void;
	private writeVariantPayload;
	private writeLegacyWireVariant;
	private writeProperty;
	/** @internal the flat-array element writer; writePlan.ts falls back to it
	 * for element shapes it cannot plan, so mid-stream error behavior matches. */
	writeFlat(w: ByteWriter, ty: string, value: BrdbValue, ctx: string): void;
	private static readonly MAX_DECODE_DEPTH;
	readValue(r: ByteReader, ty: string, depth?: number): BrdbValue;
	private readLegacyWireVariant;
	private readProperty;
	private readFlat;
	encode(ty: string, value: BrdbValue): Uint8Array;
	decode(bytes: Uint8Array, ty: string): BrdbValue;
}
declare function embeddedSchema(name: EmbeddedSchemaName): BrdbSchema;
export type BrickComponentData_AudioEmitter = {
	bEnabled: boolean;
	AudioDescriptor: number | null;
	VolumeMultiplier: number;
	PitchMultiplier: number;
	InnerRadius: number;
	MaxDistance: number;
	bSpatialization: boolean;
	FocusAzimuth: number;
	NonFocusAzimuth: number;
	NonFocusVolumeAttenuation: number;
};
export type BrickComponentData_Bearing = {
	bLimitAngle: boolean;
	LimitAngle: number;
	CurrentAngle: number;
	bAnglesArePercentages: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_Button = {
	PressSound: number | null;
	ReleaseSound: number | null;
	bAllowNearbyInteraction: boolean;
	bHiddenInteraction: boolean;
	PromptCustomLabel: string;
};
export type BrickComponentData_CheckPoint = {
	bRotatePlayerGravityOnSpawn: boolean;
};
export type BrickComponentData_Clock = {
	bEnabled: boolean;
	bPulseOn: boolean;
	OnTimeSeconds: number;
	OffTimeSeconds: number;
	IntervalSeconds: number;
};
export type BrickComponentData_Damage = {
	Damage: number;
	RepeatDelay: number;
	Message: string;
	ConsoleTag: string;
};
export type BrickComponentData_Interact = {
	InteractSound: number | null;
	Message: string;
	ConsoleTag: string;
	bAllowNearbyInteraction: boolean;
	bHiddenInteraction: boolean;
	PromptCustomLabel: string;
};
export type BrickComponentData_Internal_CharacterZoneEvent = {
	TagFilter: string;
	bCollisionEnabled_Player: boolean;
	bCollisionEnabled_Player1: boolean;
	bCollisionEnabled_Player2: boolean;
	bCollisionEnabled_Player3: boolean;
};
export type BrickComponentData_Internal_EntityZoneEvent = {
	TagFilter: string;
};
export type BrickComponentData_Internal_InputSplitter_V2 = {};
export type BrickComponentData_Internal_Microchip = {};
export type BrickComponentData_Internal_MicrochipInput = {
	PortLabel: string;
};
export type BrickComponentData_Internal_MicrochipOutput = {
	PortLabel: string;
};
export type BrickComponentData_Internal_ProjectileZoneEvent = {};
export type BrickComponentData_Internal_ReadBrickGrid = {};
export type BrickComponentData_Internal_ZoneEvent = {};
export type BrickComponentData_Motor = {
	bEnabled: boolean;
	Speed: number;
	Power: number;
	bLimitAngle: boolean;
	LimitAngle: number;
	CurrentAngle: number;
	bAnglesArePercentages: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_MotorSlider = {
	bEnabled: boolean;
	Speed: number;
	Power: number;
	bPositionsArePercentages: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_OneShotAudioEmitter = {
	AudioDescriptor: number | null;
	VolumeMultiplier: number;
	PitchMultiplier: number;
	InnerRadius: number;
	MaxDistance: number;
	bSpatialization: boolean;
	bEnableRepeat: boolean;
	RepeatTime: number;
	RepeatVariance: number;
	RepeatCount: number;
};
export type BrickComponentData_ProjectileSpawner = {
	ProjectileClass: number | null;
	FireSound: number | null;
	Direction: number;
	SpawnLocation: number;
	SpawnMargin: number;
	SpawnOffsetBias: number;
	bEnabled: boolean;
	NumberOfShots: number;
	SpreadConeAngle: number;
	bSpreadBiasedTowardsCenter: boolean;
	FireRate: number;
	bEnforceFireRate: boolean;
	DamageMultiplier: number;
	SpeedMultiplier: number;
	ScaleMultiplier: number;
};
export type BrickComponentData_Rerouter = {};
export type BrickComponentData_RigidBearing = {
	TargetAngle: number;
	bAnglesArePercentages: boolean;
	bReversed: boolean;
	CurrentAngle: number;
	InterpMode: number;
	SmoothTime: number;
	TopSpeed: number;
};
export type BrickComponentData_RigidSlider = {
	TargetPosition: number;
	bPositionsArePercentages: boolean;
	bReversed: boolean;
	CurrentPosition: number;
	InterpMode: number;
	SmoothTime: number;
	TopSpeed: number;
};
export type BrickComponentData_Servo = {
	bEnabled: boolean;
	TargetAngle: number;
	Power: number;
	ActiveDamping: number;
	ForceLimit: number;
	bLimitAngle: boolean;
	LimitAngle: number;
	CurrentAngle: number;
	bAnglesArePercentages: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_ServoSlider = {
	bEnabled: boolean;
	TargetPosition: number;
	Power: number;
	TopSpeed: number;
	Exponent: number;
	bPositionsArePercentages: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_Slider = {
	bPositionsArePercentages: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_SpawnPoint = {
	bRotatePlayerGravityOnSpawn: boolean;
	bEnable: boolean;
};
export type BrickComponentData_Switch = {
	bEnabled: boolean;
	InteractSound: number | null;
	bAllowNearbyInteraction: boolean;
	bHiddenInteraction: boolean;
	PromptCustomLabel: string;
};
export type BrickComponentData_Target = {
	OnTime: number;
};
export type BrickComponentData_TeleportDestination = {};
export type BrickComponentData_Touch = {
	BeginTouchSound: number | null;
	EndTouchSound: number | null;
	bCollisionEnabled_Player: boolean;
	bCollisionEnabled_Player1: boolean;
	bCollisionEnabled_Player2: boolean;
	bCollisionEnabled_Player3: boolean;
};
export type BrickComponentData_WireGraph_AudioReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_BrickAssetReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_DeltaTime = {};
export type BrickComponentData_WireGraph_EntityTypeReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Average = {
	Value: BrdbVariant;
	bIsEmpty: boolean;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Base = {};
export type BrickComponentData_WireGraph_Exec_ArrayVar_DualRef = {};
export type BrickComponentData_WireGraph_Exec_ArrayVar_ElementOp = {
	Index: number;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Find = {
	Index: number;
	bFound: boolean;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Get = {
	bOutOfBounds: boolean;
	Index: number;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_GetLength = {
	Length: number;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Insert = {
	bOutOfBounds: boolean;
	Index: number;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_MinMax = {
	Value: BrdbVariant;
	bIsEmpty: boolean;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Pop = {
	bIsEmpty: boolean;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Push = {
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_RemoveAtIndex = {
	Index: number;
	bOutOfBounds: boolean;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Resize = {
	Size: number;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Slice = {
	Start: number;
	Count: number;
	bOutOfBounds: boolean;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Sort = {
	bDescending: boolean;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_SortMultiple = {
	bDescending: boolean;
	bSuccess: boolean;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Sum = {
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_ArrayVar_Swap = {
	IndexA: number;
	IndexB: number;
	bOutOfBounds: boolean;
};
export type BrickComponentData_WireGraph_Exec_Character_AddInventoryEntity = {
	EntityType: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_AddInventoryItem = {
	Item: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_GetAim = {
	bLocalAim: boolean;
};
export type BrickComponentData_WireGraph_Exec_Character_GetAmmo = {
	Resource: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_GetCurrentInventorySlot = {};
export type BrickComponentData_WireGraph_Exec_Character_GetDamage = {};
export type BrickComponentData_WireGraph_Exec_Character_GetFromController = {};
export type BrickComponentData_WireGraph_Exec_Character_GetInventoryEntry = {
	Slot: number;
};
export type BrickComponentData_WireGraph_Exec_Character_GetWeaponChamberAmmo = {
	Slot: number;
	Resource: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_GrantAmmo = {
	Resource: number | null;
	Amount: number;
};
export type BrickComponentData_WireGraph_Exec_Character_IncDamage = {
	Amount: number;
};
export type BrickComponentData_WireGraph_Exec_Character_IncWeaponChamberAmmo = {
	Slot: number;
	Resource: number | null;
	Amount: number;
};
export type BrickComponentData_WireGraph_Exec_Character_SetAmmo = {
	Resource: number | null;
	Amount: number;
};
export type BrickComponentData_WireGraph_Exec_Character_SetDamage = {
	Damage: number;
};
export type BrickComponentData_WireGraph_Exec_Character_SetInventoryEntity = {
	Slot: number;
	EntityType: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_SetInventoryItem = {
	Slot: number;
	Item: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_SetTempPermission = {
	PermissionTagStr: string;
	bPermissionEnable: boolean;
};
export type BrickComponentData_WireGraph_Exec_Character_SetWeaponChamberAmmo = {
	Slot: number;
	Resource: number | null;
	Amount: number;
};
export type BrickComponentData_WireGraph_Exec_Character_ShowHint = {
	HintTitle: string;
	HintText: string;
};
export type BrickComponentData_WireGraph_Exec_ChatCommand = {
	CommandName: string;
	HelpText: string;
};
export type BrickComponentData_WireGraph_Exec_Cycle = {
	Count: number;
	Value: number;
};
export type BrickComponentData_WireGraph_Exec_Entity_DestroySpawned = {};
export type BrickComponentData_WireGraph_Exec_Entity_DestroySpawnedPrefab = {};
export type BrickComponentData_WireGraph_Exec_Entity_GetSpeed = {};
export type BrickComponentData_WireGraph_Exec_Entity_GetTag = {
	Tag: string;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetTeam = {};
export type BrickComponentData_WireGraph_Exec_Entity_IsFrozen = {};
export type BrickComponentData_WireGraph_Exec_Entity_PlayAudioAt = {
	AudioDescriptor: number | null;
	VolumeMultiplier: number;
	PitchMultiplier: number;
	InnerRadius: number;
	MaxDistance: number;
	bSpatialization: boolean;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetFrozen = {
	bFrozen: boolean;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetTag = {
	Tag: string;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetTeam = {};
export type BrickComponentData_WireGraph_Exec_Gamemode_BroadcastChatMessage = {
	Message: string;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_BroadcastStatusMessage = {
	Message: string;
	bFlashIfUnchanged: boolean;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_FillArrayFromPlayers = {
	bIncludeBuilderMode: boolean;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_FillArrayFromTeamMembers = {};
export type BrickComponentData_WireGraph_Exec_Gamemode_GetCurrentRound = {};
export type BrickComponentData_WireGraph_Exec_Gamemode_GetLeaderboardValue = {
	Key: string;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_GetTeam = {};
export type BrickComponentData_WireGraph_Exec_Gamemode_GetTeamByName = {
	TeamName: string;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_GetTeamLeaderboardValue = {
	Key: string;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_GetTeamName = {};
export type BrickComponentData_WireGraph_Exec_Gamemode_LeaderboardValue = {
	Key: string;
	Value: number;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_PlayerWins = {
	bTeamWinsInstead: boolean;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_SetTeam = {
	bPinPlayerToTeam: boolean;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_SetTeamPinned = {
	bPinned: boolean;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_TeamLeaderboardValue = {
	Key: string;
	Value: number;
};
export type BrickComponentData_WireGraph_Exec_Gamemode_TeamWins = {};
export type BrickComponentData_WireGraph_Exec_GetInputs = {};
export type BrickComponentData_WireGraph_Exec_GetOwnTransform = {};
export type BrickComponentData_WireGraph_Exec_MapVar_ArrayDest = {};
export type BrickComponentData_WireGraph_Exec_MapVar_Base = {};
export type BrickComponentData_WireGraph_Exec_MapVar_CopyFrom = {};
export type BrickComponentData_WireGraph_Exec_MapVar_Get = {
	bFound: boolean;
	Key: BrdbVariant;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_MapVar_GetLength = {
	Length: number;
};
export type BrickComponentData_WireGraph_Exec_MapVar_KeyOp = {
	Key: BrdbVariant;
	bFound: boolean;
};
export type BrickComponentData_WireGraph_Exec_MapVar_Set = {
	Key: BrdbVariant;
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_PlayClientAudio = {
	AudioDescriptor: number | null;
	VolumeMultiplier: number;
	PitchMultiplier: number;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_ForceRespawn = {};
export type BrickComponentData_WireGraph_Exec_PlayerState_GetDisplayName = {};
export type BrickComponentData_WireGraph_Exec_PlayerState_GetFromEntity = {};
export type BrickComponentData_WireGraph_Exec_PlayerState_GetUserId = {};
export type BrickComponentData_WireGraph_Exec_PlayerState_GetUserName = {};
export type BrickComponentData_WireGraph_Exec_PlayerState_HasPermission = {
	PermissionName: string;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_HasRole = {
	RoleName: string;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_IsTrustedByBrickOwner = {};
export type BrickComponentData_WireGraph_Exec_PlayerState_SetCanRespawn = {
	bCanRespawn: boolean;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_ShowChatMessage = {
	Message: string;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_ShowMessageBox = {
	Title: string;
	Message: string;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_ShowStatusMessage = {
	Message: string;
};
export type BrickComponentData_WireGraph_Exec_PlayGlobalAudio = {
	AudioDescriptor: number | null;
	VolumeMultiplier: number;
	PitchMultiplier: number;
};
export type BrickComponentData_WireGraph_Exec_PrintToConsole = {
	Text: string;
};
export type BrickComponentData_WireGraph_Exec_Random = {
	Min: BrdbVariant;
	Max: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_Toggle = {
	Value: boolean;
};
export type BrickComponentData_WireGraph_Exec_Var_EditOrGet = {
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_Var_Get = {
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraph_Exec_WholeGridInteracted = {
	bAllowNearbyInteraction: boolean;
	bHiddenInteraction: boolean;
	PromptCustomLabel: string;
};
export type BrickComponentData_WireGraph_Exec_WholeGridTargeted = {};
export type BrickComponentData_WireGraph_Exec_Zone_GetEntities = {
	TagFilter: string;
};
export type BrickComponentData_WireGraph_Exec_Zone_GetPlayers = {
	TagFilter: string;
};
export type BrickComponentData_WireGraph_ExecBranch = {
	bCond: boolean;
};
export type BrickComponentData_WireGraph_ExecUnion = {};
export type BrickComponentData_WireGraph_Expr_Bool_Bool = {
	bInput: boolean;
};
export type BrickComponentData_WireGraph_Expr_BoolBool_Bool = {
	bInputA: boolean;
	bInputB: boolean;
};
export type BrickComponentData_WireGraph_Expr_ChangeDetector = {
	Input: BrdbVariant;
	bPulseOnChange: boolean;
};
export type BrickComponentData_WireGraph_Expr_ChangeDetectorExec = {
	Input: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_Compare = {
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_Convert = {
	Input: BrdbVariant;
	Output: BrdbVariant;
	TargetType: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_EdgeDetector = {
	Input: number;
	bPulseOnRisingEdge: boolean;
	bPulseOnFallingEdge: boolean;
};
export type BrickComponentData_WireGraph_Expr_EdgeDetectorExec = {
	Input: number;
};
export type BrickComponentData_WireGraph_Expr_EnumToInteger = {
	Input: BrdbVariant;
	Output: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_Float_Float = {
	Input: number;
};
export type BrickComponentData_WireGraph_Expr_Gamemode_TeamPredicate = {};
export type BrickComponentData_WireGraph_Expr_Int_Int = {
	Input: number;
};
export type BrickComponentData_WireGraph_Expr_IntegerToEnum = {
	Input: number;
	bWrap: boolean;
	TargetType: BrdbVariant;
	Output: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_IntInt_Int = {
	InputA: number;
	InputB: number;
};
export type BrickComponentData_WireGraph_Expr_ItemToPickup = {};
export type BrickComponentData_WireGraph_Expr_MakeColor = {
	R: number;
	G: number;
	B: number;
	A: number;
};
export type BrickComponentData_WireGraph_Expr_MakeColorHex = {
	Hex: string;
};
export type BrickComponentData_WireGraph_Expr_MakeColorSRGB = {
	R: number;
	G: number;
	B: number;
	A: number;
};
export type BrickComponentData_WireGraph_Expr_MakeQuaternion = {
	X: number;
	Y: number;
	Z: number;
	W: number;
};
export type BrickComponentData_WireGraph_Expr_MakeRotation = {
	Pitch: number;
	Yaw: number;
	Roll: number;
};
export type BrickComponentData_WireGraph_Expr_MakeVector = {
	X: number;
	Y: number;
	Z: number;
};
export type BrickComponentData_WireGraph_Expr_MathAtan2 = {
	Y: number;
	X: number;
};
export type BrickComponentData_WireGraph_Expr_MathBlend = {
	Blend: number;
	bClampAlpha: boolean;
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_MathClamp = {
	Min: BrdbVariant;
	Max: BrdbVariant;
	Input: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_MathCompare = {
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_MathEasing = {
	Blend: number;
	Function: number;
	Direction: number;
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_MathLogBase = {
	Input: number;
	Base: number;
};
export type BrickComponentData_WireGraph_Expr_MathPow = {
	Input: number;
	Exponent: number;
};
export type BrickComponentData_WireGraph_Expr_NearlyEqual = {
	InputA: BrdbVariant;
	InputB: BrdbVariant;
	Tolerance: number;
};
export type BrickComponentData_WireGraph_Expr_PrimMathVariant_PrimMathVariant = {
	Input: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant = {
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_Remap = {
	Value: number;
	InputMin: number;
	InputMax: number;
	OutputMin: number;
	OutputMax: number;
	Function: number;
	Direction: number;
};
export type BrickComponentData_WireGraph_Expr_Select = {
	bSelectB: boolean;
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_String_CharacterToCodepoint = {
	Character: string;
};
export type BrickComponentData_WireGraph_Expr_String_CodepointToCharacter = {
	Codepoint: number;
};
export type BrickComponentData_WireGraph_Expr_String_Concatenate = {
	InputA: string;
	InputB: string;
	Separator: string;
};
export type BrickComponentData_WireGraph_Expr_String_Contains = {
	Input: string;
	Search: string;
	bCaseSensitive: boolean;
};
export type BrickComponentData_WireGraph_Expr_String_EndsWith = {
	Input: string;
	Suffix: string;
	bCaseSensitive: boolean;
};
export type BrickComponentData_WireGraph_Expr_String_Find = {
	Input: string;
	Search: string;
	bCaseSensitive: boolean;
	Start: number;
};
export type BrickComponentData_WireGraph_Expr_String_FormatText = {
	FormatString: string;
	InputA: BrdbVariant;
	InputB: BrdbVariant;
	InputC: BrdbVariant;
	InputD: BrdbVariant;
	InputE: BrdbVariant;
	InputF: BrdbVariant;
	InputG: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_String_Length = {
	Input: string;
};
export type BrickComponentData_WireGraph_Expr_String_ParseInt = {
	Input: string;
};
export type BrickComponentData_WireGraph_Expr_String_ParseNumber = {
	Input: string;
};
export type BrickComponentData_WireGraph_Expr_String_Replace = {
	Input: string;
	Search: string;
	Replacement: string;
	bCaseSensitive: boolean;
	Start: number;
	MaxReplacements: number;
};
export type BrickComponentData_WireGraph_Expr_String_Split = {
	Input: string;
	Delimiter: string;
	bCaseSensitive: boolean;
	Occurrence: number;
};
export type BrickComponentData_WireGraph_Expr_String_StartsWith = {
	Input: string;
	Prefix: string;
	bCaseSensitive: boolean;
};
export type BrickComponentData_WireGraph_Expr_String_Substring = {
	Input: string;
	Start: number;
	Length: number;
};
export type BrickComponentData_WireGraph_Expr_String_ToLower = {
	Input: string;
};
export type BrickComponentData_WireGraph_Expr_String_ToUpper = {
	Input: string;
};
export type BrickComponentData_WireGraph_Expr_String_Trim = {
	Input: string;
};
export type BrickComponentData_WireGraph_Expr_Swap = {
	bSwap: boolean;
	InputA: BrdbVariant;
	InputB: BrdbVariant;
};
export type BrickComponentData_WireGraph_Expr_Variant_Variant = {
	Input: BrdbVariant;
};
export type BrickComponentData_WireGraph_Fake_CharacterDamageEvent = {};
export type BrickComponentData_WireGraph_Fake_CharacterDeathEvent = {};
export type BrickComponentData_WireGraph_Fake_CharacterEvent = {};
export type BrickComponentData_WireGraph_Fake_CharacterFiredWeaponEvent = {};
export type BrickComponentData_WireGraph_Fake_ControllerEvent = {};
export type BrickComponentData_WireGraph_Fake_ControllerTeamEvent = {};
export type BrickComponentData_WireGraph_Fake_RoundEvent = {
	RoundNumber: number;
};
export type BrickComponentData_WireGraph_FindPlayer = {
	Query: string;
};
export type BrickComponentData_WireGraph_FontReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_FormatDate = {
	UnixEpoch: number;
	Format: string;
	bUseUTC: boolean;
};
export type BrickComponentData_WireGraph_GetUnixEpoch = {};
export type BrickComponentData_WireGraph_ItemReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_OneShotAudioReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_ParticleReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_PickupReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_ProjectileReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_ServerUptime = {};
export type BrickComponentData_WireGraph_WeaponResourceReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraph_WheelEngineAudioReference = {
	Asset: number | null;
};
export type BrickComponentData_WireGraphPseudo_ArrayVar = {
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraphPseudo_BufferSeconds = {
	SecondsToWait: number;
	ZeroSecondsToWait: number;
	CurrentTime: number;
	Input: BrdbVariant;
	Output: BrdbVariant;
	Buffered: BrdbVariant;
	bHasQueued: boolean;
	bIsOffTimer: boolean;
};
export type BrickComponentData_WireGraphPseudo_BufferTicks = {
	TicksToWait: number;
	ZeroTicksToWait: number;
	CurrentTicks: number;
	Input: BrdbVariant;
	Output: BrdbVariant;
	Buffered: BrdbVariant;
	bHasQueued: boolean;
	bIsOffTimer: boolean;
};
export type BrickComponentData_WireGraphPseudo_CustomEvent = {
	EventName: string;
	bIsObjectEvent: boolean;
	DataOut1: BrdbVariant;
	DataOut2: BrdbVariant;
	DataOut3: BrdbVariant;
	DataOut4: BrdbVariant;
	DataOut5: BrdbVariant;
	DataOut6: BrdbVariant;
	DataOut7: BrdbVariant;
	DataOut8: BrdbVariant;
};
export type BrickComponentData_WireGraphPseudo_MapVar = {
	Value: BrdbVariant;
};
export type BrickComponentData_WireGraphPseudo_SendCustomEvent = {
	EventName: string;
	DataIn1: BrdbVariant;
	DataIn2: BrdbVariant;
	DataIn3: BrdbVariant;
	DataIn4: BrdbVariant;
	DataIn5: BrdbVariant;
	DataIn6: BrdbVariant;
	DataIn7: BrdbVariant;
	DataIn8: BrdbVariant;
};
export type BrickComponentData_WireGraphPseudo_Timer = {
	Limit: number;
	Time: number;
	bRunning: boolean;
};
export type BrickComponentData_WireGraphPseudo_Tween = {
	Target: BrdbVariant;
	Value: BrdbVariant;
	StartValue: BrdbVariant;
	Duration: number;
	Elapsed: number;
	bRunning: boolean;
	Function: number;
	Direction: number;
};
export type BrickComponentData_WireGraphPseudo_Var = {
	Value: BrdbVariant;
};
export type BrickComponentWireControl_DriveAndSteer = {};
export type BrickComponentWirePortControl_TeleportDestination = {};
export type BRInventoryEntryConfig = {
	Item: BrdbVariant;
};
export type BRInventoryEntryWeaponResourceAmounts = {
	Loaded: number;
	Reserve: number;
};
export type BRQueueSecondsEntry = {
	Data: BrdbVariant[];
	RemainingTime: number;
};
export type BRQueueTicksEntry = {
	Data: BrdbVariant[];
	RemainingTicks: number;
};
export type Color = {
	B: number;
	G: number;
	R: number;
	A: number;
};
type IntVector$1 = {
	X: number;
	Y: number;
	Z: number;
};
export type LinearColor = {
	R: number;
	G: number;
	B: number;
	A: number;
};
export type Quat = {
	X: number;
	Y: number;
	Z: number;
	W: number;
};
export type Rotator = {
	Pitch: number;
	Yaw: number;
	Roll: number;
};
export type Rotator3f = {
	Pitch: number;
	Yaw: number;
	Roll: number;
};
type Vector$1 = {
	X: number;
	Y: number;
	Z: number;
};
export type Vector2D = {
	X: number;
	Y: number;
};
export type Vector2f = {
	X: number;
	Y: number;
};
export type Vector3f = {
	X: number;
	Y: number;
	Z: number;
};
export type Vector4 = {
	X: number;
	Y: number;
	Z: number;
	W: number;
};
export type BrickComponentData_AerodynamicSurface = {
	bEnabled: boolean;
	bDiscoverable: boolean;
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
	Role: number;
	LiftCoefficient: number;
	LiftMultiplier: number;
	ForceApplication: number;
	DragCoefficient: number;
	StallAngle: number;
	MaxDeflection: number;
	Deflection: number;
};
export type BrickComponentData_AerodynamicSurface_Directional = {
	AerodynamicDirection: number;
	bEnabled: boolean;
	bDiscoverable: boolean;
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
	Role: number;
	LiftCoefficient: number;
	LiftMultiplier: number;
	ForceApplication: number;
	DragCoefficient: number;
	StallAngle: number;
	MaxDeflection: number;
	Deflection: number;
};
export type BrickComponentData_BrickPropertyChanger = {
	bVisibility: boolean;
	bCollisionEnabled: boolean;
	bCollisionEnabled_Player: boolean;
	bCollisionEnabled_Player1: boolean;
	bCollisionEnabled_Player2: boolean;
	bCollisionEnabled_Player3: boolean;
	bCollisionEnabled_Weapon: boolean;
	bCollisionEnabled_Interaction: boolean;
	bCollisionEnabled_Physics: boolean;
	Color: Color;
	MaterialAlpha: number;
	Material: number;
};
export type BrickComponentData_ExplosionSpawner = {
	ProjectileType: number | null;
	SpawnOffset: Vector$1;
	ScaleMultiplier: number;
	DamageMultiplier: number;
};
export type BrickComponentData_Gyroscope = {
	bEnabled: boolean;
	bDiscoverable: boolean;
	Strength: number;
	Damping: number;
	MaxForce: number;
	TargetAxis: Vector$1;
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
};
export type BrickComponentData_Internal_AttachedZone = {
	ZoneStartDistance: number;
	ZoneEndDistance: number;
	bIsBuildingZone: boolean;
	bIsLooseZone: boolean;
	bIsShareZone: boolean;
	bWater: boolean;
	WaterScattering: Vector$1;
	WaterAbsorption: Vector$1;
	WaterFogIntensity: number;
	WaterFogScatteringColor: LinearColor;
	WaterFogAmbientColor: LinearColor;
	WaterFogScatteringScale: number;
	WaterFogAmbientScale: number;
	bDetectPlayers: boolean;
	bDetectPlayers1: boolean;
	bDetectPlayers2: boolean;
	bDetectPlayers3: boolean;
	bDetectEntities: boolean;
	bDetectProjectiles: boolean;
	TagFilter: string;
	ZoneWindForce: number;
};
export type BrickComponentData_Joint_Wheel = {
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
	bDiscoverable: boolean;
	bEnabled: boolean;
	DriveSpeed: number;
	DrivePower: number;
	bSteerEnabled: boolean;
	Steer: number;
	SteerLimitDegree: number;
	SteerPower: number;
	bSuspensionEnabled: boolean;
	SuspensionStiffness: number;
	SuspensionDamping: number;
	JointDistance: number;
	bDriveWhenNotAttachedToEngine: boolean;
	bCanBrake: boolean;
	bAllowEngineSteerCorrect: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_Joint_Wheel_Suspension = {
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
	bDiscoverable: boolean;
	bWheelVisible: boolean;
	bEnabled: boolean;
	DriveSpeed: number;
	DrivePower: number;
	bSteerEnabled: boolean;
	Steer: number;
	SteerLimitDegree: number;
	SteerPower: number;
	bSuspensionEnabled: boolean;
	SuspensionStiffness: number;
	SuspensionDamping: number;
	SuspensionOffset: number;
	SuspensionLength: number;
	JointDistance: number;
	bDriveWhenNotAttachedToEngine: boolean;
	bCanBrake: boolean;
	bAllowEngineSteerCorrect: boolean;
	bReversed: boolean;
	Damping: number;
};
export type BrickComponentData_PointLight = {
	bMatchBrickShape: boolean;
	bEnabled: boolean;
	Brightness: number;
	Radius: number;
	Color: Color;
	bUseBrickColor: boolean;
	bCastShadows: boolean;
	RayTracingVisibility: number;
};
export type BrickComponentData_PrefabSpawn = {
	Prefab: string;
	SpawnOffset: Vector$1;
	SpawnOffsetRotation: Rotator;
	SpawnVelocity: Vector$1;
	bSpawnEnable: boolean;
	RespawnTime: number;
	SpawnedEntityIds: number[];
};
export type BrickComponentData_Seat_V2 = {
	bIsOccupied: boolean;
	ExitOffset: IntVector$1;
	bRollCameraInThirdPerson: boolean;
	CameraOrigin: number;
	CameraOriginOffset: Vector$1;
	bScaleCameraOriginOffsetWithZoom: boolean;
	ThirdPersonStartingZoom: number;
	ThirdPersonCameraRotation: Rotator;
	SeatMode: number;
	bStickyPlaneThrottle: boolean;
	bFlyingGroundControls: boolean;
	AirStrafeControl: number;
	FlightInvertXOverride: number;
	FlightInvertYOverride: number;
	bAllowHeldItems: boolean;
	bAllowNearbyInteraction: boolean;
	bHiddenInteraction: boolean;
	PromptCustomLabel: string;
};
export type BrickComponentData_SpotLight = {
	Rotation: Rotator3f;
	InnerConeAngle: number;
	OuterConeAngle: number;
	bEnabled: boolean;
	Brightness: number;
	Radius: number;
	Color: Color;
	bUseBrickColor: boolean;
	bCastShadows: boolean;
	RayTracingVisibility: number;
};
export type BrickComponentData_TextDisplay = {
	Text: string;
	Font: number | null;
	Rotation: number;
	Skew: number;
	Kerning: number;
	LineHeight: number;
	WidthScale: number;
	LineOffset: number;
	Anchor: Vector2f;
	Offset: Vector3f;
	Color: Color;
	MaterialSlider: number;
	ShadingWidth: number;
	OutlineColor: Color;
	OutlineWidth: number;
	ScuffWidth: number;
	GraffitiDepthLimit: number;
	GraffitiAngleLimit: number;
	GraffitiLayer: number;
	bEnabled: boolean;
	Face: number;
	bAlignToWedge: boolean;
	bOverrideColor: boolean;
	Typeface: number;
	Billboard: number;
	Material: number;
	Shading: number;
	bFlipShading: boolean;
	Outline: number;
	bSharpCorners: boolean;
	bSharpOutlines: boolean;
	bOverrideOutlineColor: boolean;
	bForeground: boolean;
};
export type BrickComponentData_Thruster = {
	bEnabled: boolean;
	bDiscoverable: boolean;
	Force: number;
	ForceApplication: number;
	Throttle: number;
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
	Pitch: number;
	Yaw: number;
	bSpawnLight: boolean;
};
export type BrickComponentData_WeightBrick = {
	Mass: number;
	MassSize: IntVector$1;
	MassOffset: IntVector$1;
};
export type BrickComponentData_WheelEngine_V2 = {
	bEnabled: boolean;
	bDisableInWorldControlDiagnostics: boolean;
	bEnableManualControl: boolean;
	ManualControlMode: number;
	ManualInput_Drive: number;
	ManualInput_Steer: number;
	ManualInput_Pitch: number;
	ManualInput_Roll: number;
	bManualInput_Brake: boolean;
	Control_DriveAndSteer: BrickComponentWireControl_DriveAndSteer;
	bAutodiscoverWheels: boolean;
	bAutodiscoverThrusters: boolean;
	bAutodiscoverGyroscopes: boolean;
	bAutodiscoverAerodynamicSurfaces: boolean;
	CustomMass: number;
	MassDistribution: number;
	CustomMassVerticalOffset: number;
	DriveInterpSpeed: number;
	DriveSpeed: number;
	FlightTopSpeed: number;
	FlightHandling: number;
	bEnableAirBraking: boolean;
	bEnableMassBalancing: boolean;
	LiftMultiplier: number;
	bEnableGlideTrim: boolean;
	GlideTrimStrength: number;
	GlideTrimTargetSpeedMultiplier: number;
	bEnableAerodynamicRateDamping: boolean;
	PhysicalRollDampingResponseTime: number;
	PhysicalPitchDampingResponseTime: number;
	PhysicalYawDampingResponseTime: number;
	ThrustMultiplier: number;
	KeyboardSteeringRollMix: number;
	KeyboardSteeringYawMix: number;
	HorizontalSteeringRollMix: number;
	HorizontalSteeringYawMix: number;
	ArcadeRollRate: number;
	ArcadePitchRate: number;
	ArcadeYawRate: number;
	ArcadeResponseTime: number;
	ArcadeAirGripResponseTime: number;
	ArcadeMaxLateralAccelerationGs: number;
	ArcadeAeroAuthorityFadeStartSpeed: number;
	ArcadeAeroAuthorityFadeEndSpeed: number;
	MigrationVersion: number;
	DriveAcceleratingPowerMultiplier: number;
	DriveBrakingPowerMultiplier: number;
	DriveDampingMultiplier: number;
	SteerPowerMultiplier: number;
	WheelFrictionMultiplier: number;
	SteerInterpSpeed: number;
	SteerLimitSpeedFalloff: number;
	SteerLimitDegree: number;
	CenterOfSteering: number;
	bTankSteering: boolean;
	TankSteerSpeedMultiplier: number;
	bAutoRight: boolean;
	WaterDriveForce: number;
	WaterSteeringForce: number;
	AudioDescriptor: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_AddInventoryBrick = {
	BrickAsset: number | null;
	ProceduralSize: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Character_AddInventoryEntry = {
	Entry: BRInventoryEntryConfig;
};
export type BrickComponentData_WireGraph_Exec_Character_SetInventoryBrick = {
	Slot: number;
	BrickAsset: number | null;
	ProceduralSize: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_AddLocationRotation = {
	Vector: Vector$1;
	Rotation: Rotator;
};
export type BrickComponentData_WireGraph_Exec_Entity_AddVelocity = {
	Vector: Vector$1;
	Rotation: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetAngularVelocity = {
	AngularVelocity: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetLinearVelocity = {
	LinearVelocity: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetLocation = {
	Vector: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetLocationRotation = {
	Vector: Vector$1;
	Rotation: Rotator;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetRotation = {
	Rotation: Rotator;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetVelocity = {
	Vector: Vector$1;
	Rotation: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_GetVelocityAtPoint = {
	Point: Vector$1;
	LinearVelocity: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_RelativeTeleport = {
	Source: BrickComponentWirePortControl_TeleportDestination;
	Destination: BrickComponentWirePortControl_TeleportDestination;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetAngularVelocity = {
	AngularVelocity: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetGravityDirection = {
	Rotation: Rotator;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetLinearVelocity = {
	LinearVelocity: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetLocation = {
	Vector: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetLocationRotation = {
	Vector: Vector$1;
	Rotation: Rotator;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetRotation = {
	Rotation: Rotator;
};
export type BrickComponentData_WireGraph_Exec_Entity_SetVelocity = {
	Vector: Vector$1;
	Rotation: Vector$1;
};
export type BrickComponentData_WireGraph_Exec_Entity_Teleport = {
	Destination: BrickComponentWirePortControl_TeleportDestination;
};
export type BrickComponentData_WireGraph_Exec_PlayerState_DisplayText = {
	Text: string;
	Font: number | null;
	Typeface: number;
	Anchor: Vector2D;
	Position: Vector2D;
	Angle: number;
	ZOrder: number;
	Scale: Vector2D;
	Pivot: Vector2D;
	FontSize: number;
	FontColor: LinearColor;
	LetterSpacing: number;
	Skew: number;
	LineHeight: number;
	OutlineSize: number;
	OutlineColor: LinearColor;
	bMiteredOutline: boolean;
	WrapWidth: number;
	ShadowOffset: Vector2D;
	ShadowColor: LinearColor;
	Justification: number;
	Transition: number;
	Easing: number;
	Lifetime: number;
	TextId: number;
};
export type BrickComponentData_WireGraph_Exec_PrefabSpawner = {
	Prefab: string;
	SpawnOffset: Vector$1;
	SpawnOffsetRotation: Rotator;
	SpawnVelocity: Vector$1;
	Lifetime: number;
	Limit: number;
	SpawnedEntityIds: number[];
	SpawnedInstanceIds: number[];
};
export type BrickComponentData_WireGraph_Exec_SpawnExplosion = {
	ProjectileType: number | null;
	SpawnOffset: Vector$1;
	ScaleMultiplier: number;
	DamageMultiplier: number;
};
export type BrickComponentData_WireGraph_Exec_SpawnExplosionAt = {
	ProjectileType: number | null;
	WorldPosition: Vector$1;
	ScaleMultiplier: number;
	DamageMultiplier: number;
};
export type BrickComponentData_WireGraph_Exec_Sweep = {
	Origin: Vector$1;
	Direction: Vector$1;
	Distance: number;
	Radius: number;
	CollisionChannel: number;
	bDetectBricks: boolean;
	bDetectPlayers1: boolean;
	bDetectPlayers2: boolean;
	bDetectPlayers3: boolean;
	bDetectPlayers4: boolean;
	bOnlyHitPlayerBodyParts: boolean;
	bDetectPhysics: boolean;
	bDetectMap: boolean;
	bRelative: boolean;
	bIgnoreOwningGrid: boolean;
	HitLocation: Vector$1;
	HitNormal: Vector$1;
	HitDistance: number;
};
export type BrickComponentData_WireGraph_Exec_SweepSimple = {
	Direction: number;
	Distance: number;
	Radius: number;
	CollisionChannel: number;
	SpreadConeAngle: number;
	bSpreadBiasedTowardsCenter: boolean;
	bDetectBricks: boolean;
	bDetectPlayers1: boolean;
	bDetectPlayers2: boolean;
	bDetectPlayers3: boolean;
	bDetectPlayers4: boolean;
	bOnlyHitPlayerBodyParts: boolean;
	bDetectPhysics: boolean;
	bDetectMap: boolean;
	HitLocation: Vector$1;
	HitNormal: Vector$1;
	HitDistance: number;
};
export type BrickComponentData_WireGraph_Expr_ColorBlend = {
	ColorA: LinearColor;
	ColorB: LinearColor;
	Alpha: number;
	BlendSpace: number;
	bClampAlpha: boolean;
};
export type BrickComponentData_WireGraph_Expr_ColorConvert = {
	Input: LinearColor;
	FromSpace: number;
	ToSpace: number;
};
export type BrickComponentData_WireGraph_Expr_ColorToHex = {
	Input: LinearColor;
};
export type BrickComponentData_WireGraph_Expr_DirectionToRotation = {
	Direction: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_InvertRotation = {
	Input: Quat;
};
export type BrickComponentData_WireGraph_Expr_QuatAngleBetween = {
	InputA: Quat;
	InputB: Quat;
};
export type BrickComponentData_WireGraph_Expr_QuatBetween = {
	From: Vector$1;
	To: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_QuatDotProduct = {
	InputA: Quat;
	InputB: Quat;
};
export type BrickComponentData_WireGraph_Expr_QuatFromAxisAngle = {
	Axis: Vector$1;
	Angle: number;
};
export type BrickComponentData_WireGraph_Expr_QuatSlerp = {
	InputA: Quat;
	InputB: Quat;
	Alpha: number;
	bShortestPath: boolean;
	bClampAlpha: boolean;
};
export type BrickComponentData_WireGraph_Expr_QuatToAxisAngle = {
	Input: Quat;
};
export type BrickComponentData_WireGraph_Expr_RotateVector = {
	Rotation: Quat;
	Vector: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_RotationToDirection = {
	Rotation: Quat;
};
export type BrickComponentData_WireGraph_Expr_SplitColor = {
	Input: LinearColor;
};
export type BrickComponentData_WireGraph_Expr_SplitColorSRGB = {
	Input: LinearColor;
};
export type BrickComponentData_WireGraph_Expr_SplitQuaternion = {
	Input: Quat;
};
export type BrickComponentData_WireGraph_Expr_SplitRotation = {
	Input: Rotator;
};
export type BrickComponentData_WireGraph_Expr_SplitVector = {
	Input: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_Vec_Float = {
	Input: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_Vec_Vec = {
	Input: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_VecFloat_Vec = {
	Input: Vector$1;
	Scalar: number;
};
export type BrickComponentData_WireGraph_Expr_VecVec_Float = {
	InputA: Vector$1;
	InputB: Vector$1;
};
export type BrickComponentData_WireGraph_Expr_VecVec_Vec = {
	InputA: Vector$1;
	InputB: Vector$1;
};
export type BrickComponentData_WireGraphPseudo_Dampen = {
	Target: BrdbVariant;
	Value: BrdbVariant;
	SmoothTime: number;
	Velocity: Vector4;
};
export type BrickComponentData_WireGraphPseudo_QueueSeconds = {
	SecondsToWait: number;
	Entries: BRQueueSecondsEntry[];
	DataIn1: BrdbVariant;
	DataIn2: BrdbVariant;
	DataIn3: BrdbVariant;
	DataIn4: BrdbVariant;
	DataIn5: BrdbVariant;
	DataIn6: BrdbVariant;
	DataIn7: BrdbVariant;
	DataIn8: BrdbVariant;
	DataOut1: BrdbVariant;
	DataOut2: BrdbVariant;
	DataOut3: BrdbVariant;
	DataOut4: BrdbVariant;
	DataOut5: BrdbVariant;
	DataOut6: BrdbVariant;
	DataOut7: BrdbVariant;
	DataOut8: BrdbVariant;
};
export type BrickComponentData_WireGraphPseudo_QueueTicks = {
	TicksToWait: number;
	Entries: BRQueueTicksEntry[];
	DataIn1: BrdbVariant;
	DataIn2: BrdbVariant;
	DataIn3: BrdbVariant;
	DataIn4: BrdbVariant;
	DataIn5: BrdbVariant;
	DataIn6: BrdbVariant;
	DataIn7: BrdbVariant;
	DataIn8: BrdbVariant;
	DataOut1: BrdbVariant;
	DataOut2: BrdbVariant;
	DataOut3: BrdbVariant;
	DataOut4: BrdbVariant;
	DataOut5: BrdbVariant;
	DataOut6: BrdbVariant;
	DataOut7: BrdbVariant;
	DataOut8: BrdbVariant;
};
export type BrickTypeNetWrapper = {
	BrickAsset: number | null;
	ProceduralSize: IntVector$1;
};
export type BRInventoryEntryWeaponAmmoOverride = {
	bOverrideStartingAmmo: boolean;
	Resources: BRInventoryEntryWeaponResourceAmounts[];
};
export type BRPlayerPartCustomizationV3 = {
	PartDescriptor: number | null;
	DecalDescriptor: number | null;
	SocketName: string;
	Colors: Color[];
};
export type BrickComponentData_ItemSpawn = {
	PickupClass: number | null;
	bPickupEnabled: boolean;
	bPickupRespawnOnMinigameReset: boolean;
	PickupMinigameResetRespawnDelay: number;
	bPickupAutoDisableOnPickup: boolean;
	PickupRespawnTime: number;
	bRenderTranslucentWhenDisabled: boolean;
	DamageMultiplier: number;
	WeaponSpeedMultiplier: number;
	ItemNameOverride: string;
	ProjectileOverride: number | null;
	WeaponAmmoOverride: BRInventoryEntryWeaponAmmoOverride;
	PickupOffsetDirection: number;
	PickupOffsetDistance: number;
	PickupRotation: Rotator3f;
	PickupScale: number;
	bOverridePickupColors: boolean;
	PickupMeshColors: Color[];
	bPickupAnimationEnabled: boolean;
	PickupAnimationAxis: number;
	bPickupAnimationAxisLocal: boolean;
	PickupSpinSpeed: number;
	PickupBobSpeed: number;
	PickupBobHeight: number;
	PickupAnimationPhase: number;
};
export type BrickComponentData_WireGraph_Exec_Character_AddInventoryItemAdv = {
	ItemType: number | null;
	DamageMultiplier: number;
	WeaponSpeedMultiplier: number;
	ItemScale: number;
	ItemNameOverride: string;
	ProjectileOverride: number | null;
	WeaponAmmoOverride: BRInventoryEntryWeaponAmmoOverride;
	bOverrideColors: boolean;
	MeshColors: Color[];
};
export type BrickComponentData_WireGraph_Exec_Character_SetInventoryItemAdv = {
	Slot: number;
	ItemType: number | null;
	DamageMultiplier: number;
	WeaponSpeedMultiplier: number;
	ItemScale: number;
	ItemNameOverride: string;
	ProjectileOverride: number | null;
	WeaponAmmoOverride: BRInventoryEntryWeaponAmmoOverride;
	bOverrideColors: boolean;
	MeshColors: Color[];
};
type BRInventoryEntryPlan$1 = {
	Type: number;
	BrickTypeIfBrick: BrickTypeNetWrapper;
	EntityTypeIfEntity: number | null;
	ItemTypeIfItem: number | null;
};
export type BRPlayerAvatarCustomizationV3 = {
	Parts: BRPlayerPartCustomizationV3[];
};
export type BrickComponentData_BotSpawn = {
	RespawnTime: number;
	CorpseTimeout: number;
	GunSkill: number;
	Agression: number;
	ReactionTime: number;
	MovementRandomness: number;
	RunSpeed: number;
	HealthMultiplier: number;
	Jumpyness: number;
	MovementAmount: number;
	AttackMovementAmount: number;
	AggroRange: number;
	AttackDamageMultiplier: number;
	bCanJump: boolean;
	bBackVision: boolean;
	bVisionRaycasting: boolean;
	bCanTargetPlayers: boolean;
	bCanTargetBots: boolean;
	bActiveBot: boolean;
	bSpawnEnable: boolean;
	bDeleteBot: boolean;
	MoveTarget: Vector$1;
	MovementGoalDummy: BrickComponentWirePortControl_TeleportDestination;
	BotName: string;
	Skin: BRPlayerAvatarCustomizationV3;
	bColorsAreLinear: boolean;
	TeamCollisionChannel: number;
	bTeamCollision: boolean;
	bTeamCollision1: boolean;
	bTeamCollision2: boolean;
	bTeamCollision3: boolean;
	BotWeapon: number | null;
};
export type BrickComponentData_WireGraph_Exec_Character_SetInventoryEntry = {
	Slot: number;
	Entry: BRInventoryEntryConfig;
	EntryPlan: BRInventoryEntryPlan$1;
};
/** Component type name -> data struct shape, for editor completion. */
export type ComponentTypeDataMap = {
	BrickComponentType_AerodynamicSurface: BrickComponentData_AerodynamicSurface_Directional;
	BrickComponentType_Clock: BrickComponentData_Clock;
	BrickComponentType_ExplosionSpawner: BrickComponentData_ExplosionSpawner;
	BrickComponentType_Internal_AerodynamicSurface: BrickComponentData_AerodynamicSurface;
	BrickComponentType_Internal_AerodynamicSurfaceVertical: BrickComponentData_AerodynamicSurface;
	BrickComponentType_Internal_CharacterZoneEvent_Entered: BrickComponentData_Internal_CharacterZoneEvent;
	BrickComponentType_Internal_CharacterZoneEvent_Left: BrickComponentData_Internal_CharacterZoneEvent;
	BrickComponentType_Internal_EntityZoneEvent_Entered: BrickComponentData_Internal_EntityZoneEvent;
	BrickComponentType_Internal_EntityZoneEvent_Left: BrickComponentData_Internal_EntityZoneEvent;
	BrickComponentType_Internal_MicrochipInput: BrickComponentData_Internal_MicrochipInput;
	BrickComponentType_Internal_MicrochipOutput: BrickComponentData_Internal_MicrochipOutput;
	BrickComponentType_Internal_ProjectileZoneEvent_Entered: BrickComponentData_Internal_ProjectileZoneEvent;
	BrickComponentType_Internal_ProjectileZoneEvent_Left: BrickComponentData_Internal_ProjectileZoneEvent;
	BrickComponentType_Internal_ReadBrickGrid: BrickComponentData_Internal_ReadBrickGrid;
	BrickComponentType_Internal_TeleportDestination: BrickComponentData_TeleportDestination;
	BrickComponentType_Internal_ZoneEvent_BrickChanged: BrickComponentData_Internal_ZoneEvent;
	BrickComponentType_Internal_ZoneEvent_BrickRemoved: BrickComponentData_Internal_ZoneEvent;
	BrickComponentType_PrefabSpawn: BrickComponentData_PrefabSpawn;
	BrickComponentType_WireGraphPseudo_ArrayVar: BrickComponentData_WireGraphPseudo_ArrayVar;
	BrickComponentType_WireGraphPseudo_BufferSeconds: BrickComponentData_WireGraphPseudo_BufferSeconds;
	BrickComponentType_WireGraphPseudo_BufferTicks: BrickComponentData_WireGraphPseudo_BufferTicks;
	BrickComponentType_WireGraphPseudo_CustomEvent: BrickComponentData_WireGraphPseudo_CustomEvent;
	BrickComponentType_WireGraphPseudo_CustomEvent_Global: BrickComponentData_WireGraphPseudo_CustomEvent;
	BrickComponentType_WireGraphPseudo_Dampen: BrickComponentData_WireGraphPseudo_Dampen;
	BrickComponentType_WireGraphPseudo_MapVar: BrickComponentData_WireGraphPseudo_MapVar;
	BrickComponentType_WireGraphPseudo_QueueSeconds: BrickComponentData_WireGraphPseudo_QueueSeconds;
	BrickComponentType_WireGraphPseudo_QueueTicks: BrickComponentData_WireGraphPseudo_QueueTicks;
	BrickComponentType_WireGraphPseudo_SendCustomEvent: BrickComponentData_WireGraphPseudo_SendCustomEvent;
	BrickComponentType_WireGraphPseudo_SendCustomEvent_Global: BrickComponentData_WireGraphPseudo_SendCustomEvent;
	BrickComponentType_WireGraphPseudo_Timer: BrickComponentData_WireGraphPseudo_Timer;
	BrickComponentType_WireGraphPseudo_Tween: BrickComponentData_WireGraphPseudo_Tween;
	BrickComponentType_WireGraphPseudo_Var: BrickComponentData_WireGraphPseudo_Var;
	BrickComponentType_WireGraph_AudioReference: BrickComponentData_WireGraph_AudioReference;
	BrickComponentType_WireGraph_BrickAssetReference: BrickComponentData_WireGraph_BrickAssetReference;
	BrickComponentType_WireGraph_DeltaTime: BrickComponentData_WireGraph_DeltaTime;
	BrickComponentType_WireGraph_EntityTypeReference: BrickComponentData_WireGraph_EntityTypeReference;
	BrickComponentType_WireGraph_Exec_ArrayVar_Append: BrickComponentData_WireGraph_Exec_ArrayVar_DualRef;
	BrickComponentType_WireGraph_Exec_ArrayVar_Average: BrickComponentData_WireGraph_Exec_ArrayVar_Average;
	BrickComponentType_WireGraph_Exec_ArrayVar_Clear: BrickComponentData_WireGraph_Exec_ArrayVar_Base;
	BrickComponentType_WireGraph_Exec_ArrayVar_CopyFrom: BrickComponentData_WireGraph_Exec_ArrayVar_DualRef;
	BrickComponentType_WireGraph_Exec_ArrayVar_Fill: BrickComponentData_WireGraph_Exec_ArrayVar_Push;
	BrickComponentType_WireGraph_Exec_ArrayVar_Find: BrickComponentData_WireGraph_Exec_ArrayVar_Find;
	BrickComponentType_WireGraph_Exec_ArrayVar_Get: BrickComponentData_WireGraph_Exec_ArrayVar_Get;
	BrickComponentType_WireGraph_Exec_ArrayVar_GetLength: BrickComponentData_WireGraph_Exec_ArrayVar_GetLength;
	BrickComponentType_WireGraph_Exec_ArrayVar_Insert: BrickComponentData_WireGraph_Exec_ArrayVar_Insert;
	BrickComponentType_WireGraph_Exec_ArrayVar_Max: BrickComponentData_WireGraph_Exec_ArrayVar_MinMax;
	BrickComponentType_WireGraph_Exec_ArrayVar_Min: BrickComponentData_WireGraph_Exec_ArrayVar_MinMax;
	BrickComponentType_WireGraph_Exec_ArrayVar_Pop: BrickComponentData_WireGraph_Exec_ArrayVar_Pop;
	BrickComponentType_WireGraph_Exec_ArrayVar_Push: BrickComponentData_WireGraph_Exec_ArrayVar_Push;
	BrickComponentType_WireGraph_Exec_ArrayVar_RemoveAtIndex: BrickComponentData_WireGraph_Exec_ArrayVar_RemoveAtIndex;
	BrickComponentType_WireGraph_Exec_ArrayVar_Resize: BrickComponentData_WireGraph_Exec_ArrayVar_Resize;
	BrickComponentType_WireGraph_Exec_ArrayVar_Reverse: BrickComponentData_WireGraph_Exec_ArrayVar_Base;
	BrickComponentType_WireGraph_Exec_ArrayVar_SetAtIndex: BrickComponentData_WireGraph_Exec_ArrayVar_ElementOp;
	BrickComponentType_WireGraph_Exec_ArrayVar_Shuffle: BrickComponentData_WireGraph_Exec_ArrayVar_Base;
	BrickComponentType_WireGraph_Exec_ArrayVar_Slice: BrickComponentData_WireGraph_Exec_ArrayVar_Slice;
	BrickComponentType_WireGraph_Exec_ArrayVar_Sort: BrickComponentData_WireGraph_Exec_ArrayVar_Sort;
	BrickComponentType_WireGraph_Exec_ArrayVar_SortMultiple: BrickComponentData_WireGraph_Exec_ArrayVar_SortMultiple;
	BrickComponentType_WireGraph_Exec_ArrayVar_Sum: BrickComponentData_WireGraph_Exec_ArrayVar_Sum;
	BrickComponentType_WireGraph_Exec_ArrayVar_Swap: BrickComponentData_WireGraph_Exec_ArrayVar_Swap;
	BrickComponentType_WireGraph_Exec_Branch: BrickComponentData_WireGraph_ExecBranch;
	BrickComponentType_WireGraph_Exec_Character_AddInventoryBrick: BrickComponentData_WireGraph_Exec_Character_AddInventoryBrick;
	BrickComponentType_WireGraph_Exec_Character_AddInventoryEntity: BrickComponentData_WireGraph_Exec_Character_AddInventoryEntity;
	BrickComponentType_WireGraph_Exec_Character_AddInventoryEntry: BrickComponentData_WireGraph_Exec_Character_AddInventoryEntry;
	BrickComponentType_WireGraph_Exec_Character_AddInventoryItem: BrickComponentData_WireGraph_Exec_Character_AddInventoryItem;
	BrickComponentType_WireGraph_Exec_Character_AddInventoryItemAdv: BrickComponentData_WireGraph_Exec_Character_AddInventoryItemAdv;
	BrickComponentType_WireGraph_Exec_Character_GetAim: BrickComponentData_WireGraph_Exec_Character_GetAim;
	BrickComponentType_WireGraph_Exec_Character_GetAmmo: BrickComponentData_WireGraph_Exec_Character_GetAmmo;
	BrickComponentType_WireGraph_Exec_Character_GetCurrentInventorySlot: BrickComponentData_WireGraph_Exec_Character_GetCurrentInventorySlot;
	BrickComponentType_WireGraph_Exec_Character_GetDamage: BrickComponentData_WireGraph_Exec_Character_GetDamage;
	BrickComponentType_WireGraph_Exec_Character_GetFromController: BrickComponentData_WireGraph_Exec_Character_GetFromController;
	BrickComponentType_WireGraph_Exec_Character_GetInventoryEntry: BrickComponentData_WireGraph_Exec_Character_GetInventoryEntry;
	BrickComponentType_WireGraph_Exec_Character_GetWeaponChamberAmmo: BrickComponentData_WireGraph_Exec_Character_GetWeaponChamberAmmo;
	BrickComponentType_WireGraph_Exec_Character_GrantAmmo: BrickComponentData_WireGraph_Exec_Character_GrantAmmo;
	BrickComponentType_WireGraph_Exec_Character_IncDamage: BrickComponentData_WireGraph_Exec_Character_IncDamage;
	BrickComponentType_WireGraph_Exec_Character_IncWeaponChamberAmmo: BrickComponentData_WireGraph_Exec_Character_IncWeaponChamberAmmo;
	BrickComponentType_WireGraph_Exec_Character_SetAmmo: BrickComponentData_WireGraph_Exec_Character_SetAmmo;
	BrickComponentType_WireGraph_Exec_Character_SetDamage: BrickComponentData_WireGraph_Exec_Character_SetDamage;
	BrickComponentType_WireGraph_Exec_Character_SetInventoryBrick: BrickComponentData_WireGraph_Exec_Character_SetInventoryBrick;
	BrickComponentType_WireGraph_Exec_Character_SetInventoryEntity: BrickComponentData_WireGraph_Exec_Character_SetInventoryEntity;
	BrickComponentType_WireGraph_Exec_Character_SetInventoryEntry: BrickComponentData_WireGraph_Exec_Character_SetInventoryEntry;
	BrickComponentType_WireGraph_Exec_Character_SetInventoryItem: BrickComponentData_WireGraph_Exec_Character_SetInventoryItem;
	BrickComponentType_WireGraph_Exec_Character_SetInventoryItemAdv: BrickComponentData_WireGraph_Exec_Character_SetInventoryItemAdv;
	BrickComponentType_WireGraph_Exec_Character_SetTempPermission: BrickComponentData_WireGraph_Exec_Character_SetTempPermission;
	BrickComponentType_WireGraph_Exec_Character_SetWeaponChamberAmmo: BrickComponentData_WireGraph_Exec_Character_SetWeaponChamberAmmo;
	BrickComponentType_WireGraph_Exec_Character_ShowHint: BrickComponentData_WireGraph_Exec_Character_ShowHint;
	BrickComponentType_WireGraph_Exec_ChatCommand: BrickComponentData_WireGraph_Exec_ChatCommand;
	BrickComponentType_WireGraph_Exec_Cycle: BrickComponentData_WireGraph_Exec_Cycle;
	BrickComponentType_WireGraph_Exec_Entity_AddLocationRotation: BrickComponentData_WireGraph_Exec_Entity_AddLocationRotation;
	BrickComponentType_WireGraph_Exec_Entity_AddVelocity: BrickComponentData_WireGraph_Exec_Entity_AddVelocity;
	BrickComponentType_WireGraph_Exec_Entity_DestroySpawned: BrickComponentData_WireGraph_Exec_Entity_DestroySpawned;
	BrickComponentType_WireGraph_Exec_Entity_DestroySpawnedPrefab: BrickComponentData_WireGraph_Exec_Entity_DestroySpawnedPrefab;
	BrickComponentType_WireGraph_Exec_Entity_GetAngularVelocity: BrickComponentData_WireGraph_Exec_Entity_GetAngularVelocity;
	BrickComponentType_WireGraph_Exec_Entity_GetLinearVelocity: BrickComponentData_WireGraph_Exec_Entity_GetLinearVelocity;
	BrickComponentType_WireGraph_Exec_Entity_GetLocation: BrickComponentData_WireGraph_Exec_Entity_GetLocation;
	BrickComponentType_WireGraph_Exec_Entity_GetLocationRotation: BrickComponentData_WireGraph_Exec_Entity_GetLocationRotation;
	BrickComponentType_WireGraph_Exec_Entity_GetRotation: BrickComponentData_WireGraph_Exec_Entity_GetRotation;
	BrickComponentType_WireGraph_Exec_Entity_GetSpeed: BrickComponentData_WireGraph_Exec_Entity_GetSpeed;
	BrickComponentType_WireGraph_Exec_Entity_GetTag: BrickComponentData_WireGraph_Exec_Entity_GetTag;
	BrickComponentType_WireGraph_Exec_Entity_GetTeam: BrickComponentData_WireGraph_Exec_Entity_GetTeam;
	BrickComponentType_WireGraph_Exec_Entity_GetVelocity: BrickComponentData_WireGraph_Exec_Entity_GetVelocity;
	BrickComponentType_WireGraph_Exec_Entity_GetVelocityAtPoint: BrickComponentData_WireGraph_Exec_Entity_GetVelocityAtPoint;
	BrickComponentType_WireGraph_Exec_Entity_IsFrozen: BrickComponentData_WireGraph_Exec_Entity_IsFrozen;
	BrickComponentType_WireGraph_Exec_Entity_RelativeTeleport: BrickComponentData_WireGraph_Exec_Entity_RelativeTeleport;
	BrickComponentType_WireGraph_Exec_Entity_SetAngularVelocity: BrickComponentData_WireGraph_Exec_Entity_SetAngularVelocity;
	BrickComponentType_WireGraph_Exec_Entity_SetFrozen: BrickComponentData_WireGraph_Exec_Entity_SetFrozen;
	BrickComponentType_WireGraph_Exec_Entity_SetGravityDirection: BrickComponentData_WireGraph_Exec_Entity_SetGravityDirection;
	BrickComponentType_WireGraph_Exec_Entity_SetLinearVelocity: BrickComponentData_WireGraph_Exec_Entity_SetLinearVelocity;
	BrickComponentType_WireGraph_Exec_Entity_SetLocation: BrickComponentData_WireGraph_Exec_Entity_SetLocation;
	BrickComponentType_WireGraph_Exec_Entity_SetLocationRotation: BrickComponentData_WireGraph_Exec_Entity_SetLocationRotation;
	BrickComponentType_WireGraph_Exec_Entity_SetRotation: BrickComponentData_WireGraph_Exec_Entity_SetRotation;
	BrickComponentType_WireGraph_Exec_Entity_SetTag: BrickComponentData_WireGraph_Exec_Entity_SetTag;
	BrickComponentType_WireGraph_Exec_Entity_SetTeam: BrickComponentData_WireGraph_Exec_Entity_SetTeam;
	BrickComponentType_WireGraph_Exec_Entity_SetVelocity: BrickComponentData_WireGraph_Exec_Entity_SetVelocity;
	BrickComponentType_WireGraph_Exec_Entity_Teleport: BrickComponentData_WireGraph_Exec_Entity_Teleport;
	BrickComponentType_WireGraph_Exec_Gamemode_BroadcastChatMessage: BrickComponentData_WireGraph_Exec_Gamemode_BroadcastChatMessage;
	BrickComponentType_WireGraph_Exec_Gamemode_BroadcastStatusMessage: BrickComponentData_WireGraph_Exec_Gamemode_BroadcastStatusMessage;
	BrickComponentType_WireGraph_Exec_Gamemode_FillArrayFromPlayers: BrickComponentData_WireGraph_Exec_Gamemode_FillArrayFromPlayers;
	BrickComponentType_WireGraph_Exec_Gamemode_FillArrayFromTeamMembers: BrickComponentData_WireGraph_Exec_Gamemode_FillArrayFromTeamMembers;
	BrickComponentType_WireGraph_Exec_Gamemode_GetCurrentRound: BrickComponentData_WireGraph_Exec_Gamemode_GetCurrentRound;
	BrickComponentType_WireGraph_Exec_Gamemode_GetLeaderboardValue: BrickComponentData_WireGraph_Exec_Gamemode_GetLeaderboardValue;
	BrickComponentType_WireGraph_Exec_Gamemode_GetTeam: BrickComponentData_WireGraph_Exec_Gamemode_GetTeam;
	BrickComponentType_WireGraph_Exec_Gamemode_GetTeamByName: BrickComponentData_WireGraph_Exec_Gamemode_GetTeamByName;
	BrickComponentType_WireGraph_Exec_Gamemode_GetTeamLeaderboardValue: BrickComponentData_WireGraph_Exec_Gamemode_GetTeamLeaderboardValue;
	BrickComponentType_WireGraph_Exec_Gamemode_GetTeamName: BrickComponentData_WireGraph_Exec_Gamemode_GetTeamName;
	BrickComponentType_WireGraph_Exec_Gamemode_IncrementLeaderboardValue: BrickComponentData_WireGraph_Exec_Gamemode_LeaderboardValue;
	BrickComponentType_WireGraph_Exec_Gamemode_IncrementTeamLeaderboardValue: BrickComponentData_WireGraph_Exec_Gamemode_TeamLeaderboardValue;
	BrickComponentType_WireGraph_Exec_Gamemode_PlayerWins: BrickComponentData_WireGraph_Exec_Gamemode_PlayerWins;
	BrickComponentType_WireGraph_Exec_Gamemode_SetLeaderboardValue: BrickComponentData_WireGraph_Exec_Gamemode_LeaderboardValue;
	BrickComponentType_WireGraph_Exec_Gamemode_SetTeam: BrickComponentData_WireGraph_Exec_Gamemode_SetTeam;
	BrickComponentType_WireGraph_Exec_Gamemode_SetTeamLeaderboardValue: BrickComponentData_WireGraph_Exec_Gamemode_TeamLeaderboardValue;
	BrickComponentType_WireGraph_Exec_Gamemode_SetTeamPinned: BrickComponentData_WireGraph_Exec_Gamemode_SetTeamPinned;
	BrickComponentType_WireGraph_Exec_Gamemode_TeamWins: BrickComponentData_WireGraph_Exec_Gamemode_TeamWins;
	BrickComponentType_WireGraph_Exec_GetInputs: BrickComponentData_WireGraph_Exec_GetInputs;
	BrickComponentType_WireGraph_Exec_GetOwnTransform: BrickComponentData_WireGraph_Exec_GetOwnTransform;
	BrickComponentType_WireGraph_Exec_MapVar_Clear: BrickComponentData_WireGraph_Exec_MapVar_Base;
	BrickComponentType_WireGraph_Exec_MapVar_CopyFrom: BrickComponentData_WireGraph_Exec_MapVar_CopyFrom;
	BrickComponentType_WireGraph_Exec_MapVar_Get: BrickComponentData_WireGraph_Exec_MapVar_Get;
	BrickComponentType_WireGraph_Exec_MapVar_GetKeys: BrickComponentData_WireGraph_Exec_MapVar_ArrayDest;
	BrickComponentType_WireGraph_Exec_MapVar_GetLength: BrickComponentData_WireGraph_Exec_MapVar_GetLength;
	BrickComponentType_WireGraph_Exec_MapVar_GetValues: BrickComponentData_WireGraph_Exec_MapVar_ArrayDest;
	BrickComponentType_WireGraph_Exec_MapVar_Has: BrickComponentData_WireGraph_Exec_MapVar_KeyOp;
	BrickComponentType_WireGraph_Exec_MapVar_Remove: BrickComponentData_WireGraph_Exec_MapVar_KeyOp;
	BrickComponentType_WireGraph_Exec_MapVar_Set: BrickComponentData_WireGraph_Exec_MapVar_Set;
	BrickComponentType_WireGraph_Exec_PlayClientAudio: BrickComponentData_WireGraph_Exec_PlayClientAudio;
	BrickComponentType_WireGraph_Exec_PlayGlobalAudio: BrickComponentData_WireGraph_Exec_PlayGlobalAudio;
	BrickComponentType_WireGraph_Exec_PlayerState_DisplayText: BrickComponentData_WireGraph_Exec_PlayerState_DisplayText;
	BrickComponentType_WireGraph_Exec_PlayerState_ForceRespawn: BrickComponentData_WireGraph_Exec_PlayerState_ForceRespawn;
	BrickComponentType_WireGraph_Exec_PlayerState_GetDisplayName: BrickComponentData_WireGraph_Exec_PlayerState_GetDisplayName;
	BrickComponentType_WireGraph_Exec_PlayerState_GetFromEntity: BrickComponentData_WireGraph_Exec_PlayerState_GetFromEntity;
	BrickComponentType_WireGraph_Exec_PlayerState_GetUserId: BrickComponentData_WireGraph_Exec_PlayerState_GetUserId;
	BrickComponentType_WireGraph_Exec_PlayerState_GetUserName: BrickComponentData_WireGraph_Exec_PlayerState_GetUserName;
	BrickComponentType_WireGraph_Exec_PlayerState_HasPermission: BrickComponentData_WireGraph_Exec_PlayerState_HasPermission;
	BrickComponentType_WireGraph_Exec_PlayerState_HasRole: BrickComponentData_WireGraph_Exec_PlayerState_HasRole;
	BrickComponentType_WireGraph_Exec_PlayerState_IsTrustedByBrickOwner: BrickComponentData_WireGraph_Exec_PlayerState_IsTrustedByBrickOwner;
	BrickComponentType_WireGraph_Exec_PlayerState_SetCanRespawn: BrickComponentData_WireGraph_Exec_PlayerState_SetCanRespawn;
	BrickComponentType_WireGraph_Exec_PlayerState_ShowChatMessage: BrickComponentData_WireGraph_Exec_PlayerState_ShowChatMessage;
	BrickComponentType_WireGraph_Exec_PlayerState_ShowMessageBox: BrickComponentData_WireGraph_Exec_PlayerState_ShowMessageBox;
	BrickComponentType_WireGraph_Exec_PlayerState_ShowStatusMessage: BrickComponentData_WireGraph_Exec_PlayerState_ShowStatusMessage;
	BrickComponentType_WireGraph_Exec_PrefabSpawner: BrickComponentData_WireGraph_Exec_PrefabSpawner;
	BrickComponentType_WireGraph_Exec_PrintToConsole: BrickComponentData_WireGraph_Exec_PrintToConsole;
	BrickComponentType_WireGraph_Exec_Random: BrickComponentData_WireGraph_Exec_Random;
	BrickComponentType_WireGraph_Exec_SpawnExplosion: BrickComponentData_WireGraph_Exec_SpawnExplosion;
	BrickComponentType_WireGraph_Exec_SpawnExplosionAt: BrickComponentData_WireGraph_Exec_SpawnExplosionAt;
	BrickComponentType_WireGraph_Exec_Sweep: BrickComponentData_WireGraph_Exec_Sweep;
	BrickComponentType_WireGraph_Exec_SweepSimple: BrickComponentData_WireGraph_Exec_SweepSimple;
	BrickComponentType_WireGraph_Exec_Toggle: BrickComponentData_WireGraph_Exec_Toggle;
	BrickComponentType_WireGraph_Exec_Union: BrickComponentData_WireGraph_ExecUnion;
	BrickComponentType_WireGraph_Exec_Var_Get: BrickComponentData_WireGraph_Exec_Var_Get;
	BrickComponentType_WireGraph_Exec_Var_Increment: BrickComponentData_WireGraph_Exec_Var_EditOrGet;
	BrickComponentType_WireGraph_Exec_Var_Set: BrickComponentData_WireGraph_Exec_Var_EditOrGet;
	BrickComponentType_WireGraph_Exec_WholeGridInteracted: BrickComponentData_WireGraph_Exec_WholeGridInteracted;
	BrickComponentType_WireGraph_Exec_WholeGridTargeted: BrickComponentData_WireGraph_Exec_WholeGridTargeted;
	BrickComponentType_WireGraph_Exec_Zone_GetEntities: BrickComponentData_WireGraph_Exec_Zone_GetEntities;
	BrickComponentType_WireGraph_Exec_Zone_GetPlayers: BrickComponentData_WireGraph_Exec_Zone_GetPlayers;
	BrickComponentType_WireGraph_Expr_BitwiseAND: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseBitCount: BrickComponentData_WireGraph_Expr_Int_Int;
	BrickComponentType_WireGraph_Expr_BitwiseNAND: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseNOR: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseNOT: BrickComponentData_WireGraph_Expr_Int_Int;
	BrickComponentType_WireGraph_Expr_BitwiseOR: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseShiftLeft: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseShiftRight: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseShiftRightLogical: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_BitwiseXOR: BrickComponentData_WireGraph_Expr_IntInt_Int;
	BrickComponentType_WireGraph_Expr_Ceil: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_ChangeDetector: BrickComponentData_WireGraph_Expr_ChangeDetector;
	BrickComponentType_WireGraph_Expr_ChangeDetectorExec: BrickComponentData_WireGraph_Expr_ChangeDetectorExec;
	BrickComponentType_WireGraph_Expr_ColorBlend: BrickComponentData_WireGraph_Expr_ColorBlend;
	BrickComponentType_WireGraph_Expr_ColorConvert: BrickComponentData_WireGraph_Expr_ColorConvert;
	BrickComponentType_WireGraph_Expr_ColorToHex: BrickComponentData_WireGraph_Expr_ColorToHex;
	BrickComponentType_WireGraph_Expr_CompareEqual: BrickComponentData_WireGraph_Expr_Compare;
	BrickComponentType_WireGraph_Expr_CompareGreater: BrickComponentData_WireGraph_Expr_MathCompare;
	BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual: BrickComponentData_WireGraph_Expr_MathCompare;
	BrickComponentType_WireGraph_Expr_CompareLess: BrickComponentData_WireGraph_Expr_MathCompare;
	BrickComponentType_WireGraph_Expr_CompareLessOrEqual: BrickComponentData_WireGraph_Expr_MathCompare;
	BrickComponentType_WireGraph_Expr_CompareNotEqual: BrickComponentData_WireGraph_Expr_Compare;
	BrickComponentType_WireGraph_Expr_Convert: BrickComponentData_WireGraph_Expr_Convert;
	BrickComponentType_WireGraph_Expr_DirectionToRotation: BrickComponentData_WireGraph_Expr_DirectionToRotation;
	BrickComponentType_WireGraph_Expr_EdgeDetector: BrickComponentData_WireGraph_Expr_EdgeDetector;
	BrickComponentType_WireGraph_Expr_EdgeDetectorExec: BrickComponentData_WireGraph_Expr_EdgeDetectorExec;
	BrickComponentType_WireGraph_Expr_EnumToInteger: BrickComponentData_WireGraph_Expr_EnumToInteger;
	BrickComponentType_WireGraph_Expr_Floor: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_Gamemode_IsBuilderTeam: BrickComponentData_WireGraph_Expr_Gamemode_TeamPredicate;
	BrickComponentType_WireGraph_Expr_Gamemode_IsUnaffiliatedTeam: BrickComponentData_WireGraph_Expr_Gamemode_TeamPredicate;
	BrickComponentType_WireGraph_Expr_IntegerToEnum: BrickComponentData_WireGraph_Expr_IntegerToEnum;
	BrickComponentType_WireGraph_Expr_InvertRotation: BrickComponentData_WireGraph_Expr_InvertRotation;
	BrickComponentType_WireGraph_Expr_ItemToPickup: BrickComponentData_WireGraph_Expr_ItemToPickup;
	BrickComponentType_WireGraph_Expr_LogicalAND: BrickComponentData_WireGraph_Expr_BoolBool_Bool;
	BrickComponentType_WireGraph_Expr_LogicalNAND: BrickComponentData_WireGraph_Expr_BoolBool_Bool;
	BrickComponentType_WireGraph_Expr_LogicalNOR: BrickComponentData_WireGraph_Expr_BoolBool_Bool;
	BrickComponentType_WireGraph_Expr_LogicalNOT: BrickComponentData_WireGraph_Expr_Bool_Bool;
	BrickComponentType_WireGraph_Expr_LogicalOR: BrickComponentData_WireGraph_Expr_BoolBool_Bool;
	BrickComponentType_WireGraph_Expr_LogicalXOR: BrickComponentData_WireGraph_Expr_BoolBool_Bool;
	BrickComponentType_WireGraph_Expr_MakeColor: BrickComponentData_WireGraph_Expr_MakeColor;
	BrickComponentType_WireGraph_Expr_MakeColorHex: BrickComponentData_WireGraph_Expr_MakeColorHex;
	BrickComponentType_WireGraph_Expr_MakeColorSRGB: BrickComponentData_WireGraph_Expr_MakeColorSRGB;
	BrickComponentType_WireGraph_Expr_MakeQuaternion: BrickComponentData_WireGraph_Expr_MakeQuaternion;
	BrickComponentType_WireGraph_Expr_MakeRotation: BrickComponentData_WireGraph_Expr_MakeRotation;
	BrickComponentType_WireGraph_Expr_MakeVector: BrickComponentData_WireGraph_Expr_MakeVector;
	BrickComponentType_WireGraph_Expr_MathAbs: BrickComponentData_WireGraph_Expr_PrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathAcos: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathAcosh: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathAdd: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathAsin: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathAsinh: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathAtan: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathAtan2: BrickComponentData_WireGraph_Expr_MathAtan2;
	BrickComponentType_WireGraph_Expr_MathAtanh: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathBlend: BrickComponentData_WireGraph_Expr_MathBlend;
	BrickComponentType_WireGraph_Expr_MathClamp: BrickComponentData_WireGraph_Expr_MathClamp;
	BrickComponentType_WireGraph_Expr_MathCos: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathCosh: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathDegreesToRadians: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathDivide: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathEasing: BrickComponentData_WireGraph_Expr_MathEasing;
	BrickComponentType_WireGraph_Expr_MathExp: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathLn: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathLogBase: BrickComponentData_WireGraph_Expr_MathLogBase;
	BrickComponentType_WireGraph_Expr_MathMax: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathMin: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathModulo: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathModuloFloored: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathMultiply: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathNegate: BrickComponentData_WireGraph_Expr_Variant_Variant;
	BrickComponentType_WireGraph_Expr_MathPow: BrickComponentData_WireGraph_Expr_MathPow;
	BrickComponentType_WireGraph_Expr_MathRadiansToDegrees: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathSign: BrickComponentData_WireGraph_Expr_PrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathSin: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathSinh: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathSqrt: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathSubtract: BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant;
	BrickComponentType_WireGraph_Expr_MathTan: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_MathTanh: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_NearlyEqual: BrickComponentData_WireGraph_Expr_NearlyEqual;
	BrickComponentType_WireGraph_Expr_QuatAngleBetween: BrickComponentData_WireGraph_Expr_QuatAngleBetween;
	BrickComponentType_WireGraph_Expr_QuatBetween: BrickComponentData_WireGraph_Expr_QuatBetween;
	BrickComponentType_WireGraph_Expr_QuatDotProduct: BrickComponentData_WireGraph_Expr_QuatDotProduct;
	BrickComponentType_WireGraph_Expr_QuatFromAxisAngle: BrickComponentData_WireGraph_Expr_QuatFromAxisAngle;
	BrickComponentType_WireGraph_Expr_QuatSlerp: BrickComponentData_WireGraph_Expr_QuatSlerp;
	BrickComponentType_WireGraph_Expr_QuatToAxisAngle: BrickComponentData_WireGraph_Expr_QuatToAxisAngle;
	BrickComponentType_WireGraph_Expr_Remap: BrickComponentData_WireGraph_Expr_Remap;
	BrickComponentType_WireGraph_Expr_RotateVector: BrickComponentData_WireGraph_Expr_RotateVector;
	BrickComponentType_WireGraph_Expr_RotationToDirection: BrickComponentData_WireGraph_Expr_RotationToDirection;
	BrickComponentType_WireGraph_Expr_Round: BrickComponentData_WireGraph_Expr_Float_Float;
	BrickComponentType_WireGraph_Expr_Select: BrickComponentData_WireGraph_Expr_Select;
	BrickComponentType_WireGraph_Expr_SplitColor: BrickComponentData_WireGraph_Expr_SplitColor;
	BrickComponentType_WireGraph_Expr_SplitColorSRGB: BrickComponentData_WireGraph_Expr_SplitColorSRGB;
	BrickComponentType_WireGraph_Expr_SplitQuaternion: BrickComponentData_WireGraph_Expr_SplitQuaternion;
	BrickComponentType_WireGraph_Expr_SplitRotation: BrickComponentData_WireGraph_Expr_SplitRotation;
	BrickComponentType_WireGraph_Expr_SplitVector: BrickComponentData_WireGraph_Expr_SplitVector;
	BrickComponentType_WireGraph_Expr_String_CharacterToCodepoint: BrickComponentData_WireGraph_Expr_String_CharacterToCodepoint;
	BrickComponentType_WireGraph_Expr_String_CodepointToCharacter: BrickComponentData_WireGraph_Expr_String_CodepointToCharacter;
	BrickComponentType_WireGraph_Expr_String_Concatenate: BrickComponentData_WireGraph_Expr_String_Concatenate;
	BrickComponentType_WireGraph_Expr_String_Contains: BrickComponentData_WireGraph_Expr_String_Contains;
	BrickComponentType_WireGraph_Expr_String_EndsWith: BrickComponentData_WireGraph_Expr_String_EndsWith;
	BrickComponentType_WireGraph_Expr_String_Find: BrickComponentData_WireGraph_Expr_String_Find;
	BrickComponentType_WireGraph_Expr_String_FormatText: BrickComponentData_WireGraph_Expr_String_FormatText;
	BrickComponentType_WireGraph_Expr_String_Length: BrickComponentData_WireGraph_Expr_String_Length;
	BrickComponentType_WireGraph_Expr_String_ParseInt: BrickComponentData_WireGraph_Expr_String_ParseInt;
	BrickComponentType_WireGraph_Expr_String_ParseNumber: BrickComponentData_WireGraph_Expr_String_ParseNumber;
	BrickComponentType_WireGraph_Expr_String_Replace: BrickComponentData_WireGraph_Expr_String_Replace;
	BrickComponentType_WireGraph_Expr_String_Split: BrickComponentData_WireGraph_Expr_String_Split;
	BrickComponentType_WireGraph_Expr_String_StartsWith: BrickComponentData_WireGraph_Expr_String_StartsWith;
	BrickComponentType_WireGraph_Expr_String_Substring: BrickComponentData_WireGraph_Expr_String_Substring;
	BrickComponentType_WireGraph_Expr_String_ToLower: BrickComponentData_WireGraph_Expr_String_ToLower;
	BrickComponentType_WireGraph_Expr_String_ToUpper: BrickComponentData_WireGraph_Expr_String_ToUpper;
	BrickComponentType_WireGraph_Expr_String_Trim: BrickComponentData_WireGraph_Expr_String_Trim;
	BrickComponentType_WireGraph_Expr_Swap: BrickComponentData_WireGraph_Expr_Swap;
	BrickComponentType_WireGraph_Expr_VecCrossProduct: BrickComponentData_WireGraph_Expr_VecVec_Vec;
	BrickComponentType_WireGraph_Expr_VecDistance: BrickComponentData_WireGraph_Expr_VecVec_Float;
	BrickComponentType_WireGraph_Expr_VecDistanceSquared: BrickComponentData_WireGraph_Expr_VecVec_Float;
	BrickComponentType_WireGraph_Expr_VecDotProduct: BrickComponentData_WireGraph_Expr_VecVec_Float;
	BrickComponentType_WireGraph_Expr_VecMagnitude: BrickComponentData_WireGraph_Expr_Vec_Float;
	BrickComponentType_WireGraph_Expr_VecMagnitudeSquared: BrickComponentData_WireGraph_Expr_Vec_Float;
	BrickComponentType_WireGraph_Expr_VecNormalize: BrickComponentData_WireGraph_Expr_Vec_Vec;
	BrickComponentType_WireGraph_Expr_VecScale: BrickComponentData_WireGraph_Expr_VecFloat_Vec;
	BrickComponentType_WireGraph_Fake_Gamemode_CharacterDamagedEvent: BrickComponentData_WireGraph_Fake_CharacterDamageEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_CharacterDiedEvent: BrickComponentData_WireGraph_Fake_CharacterDeathEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_CharacterFiredWeaponEvent: BrickComponentData_WireGraph_Fake_CharacterFiredWeaponEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_CharacterSpawnedEvent: BrickComponentData_WireGraph_Fake_CharacterEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_ControllerJoinedEvent: BrickComponentData_WireGraph_Fake_ControllerEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_ControllerJoinedTeamEvent: BrickComponentData_WireGraph_Fake_ControllerTeamEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_ControllerLeftEvent: BrickComponentData_WireGraph_Fake_ControllerEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_ControllerLeftTeamEvent: BrickComponentData_WireGraph_Fake_ControllerTeamEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_RoundEndEvent: BrickComponentData_WireGraph_Fake_RoundEvent;
	BrickComponentType_WireGraph_Fake_Gamemode_RoundStartEvent: BrickComponentData_WireGraph_Fake_RoundEvent;
	BrickComponentType_WireGraph_FindPlayer: BrickComponentData_WireGraph_FindPlayer;
	BrickComponentType_WireGraph_FontReference: BrickComponentData_WireGraph_FontReference;
	BrickComponentType_WireGraph_FormatDate: BrickComponentData_WireGraph_FormatDate;
	BrickComponentType_WireGraph_GetUnixEpoch: BrickComponentData_WireGraph_GetUnixEpoch;
	BrickComponentType_WireGraph_ItemReference: BrickComponentData_WireGraph_ItemReference;
	BrickComponentType_WireGraph_OneShotAudioReference: BrickComponentData_WireGraph_OneShotAudioReference;
	BrickComponentType_WireGraph_ParticleReference: BrickComponentData_WireGraph_ParticleReference;
	BrickComponentType_WireGraph_PickupReference: BrickComponentData_WireGraph_PickupReference;
	BrickComponentType_WireGraph_ProjectileReference: BrickComponentData_WireGraph_ProjectileReference;
	BrickComponentType_WireGraph_ServerUptime: BrickComponentData_WireGraph_ServerUptime;
	BrickComponentType_WireGraph_WeaponResourceReference: BrickComponentData_WireGraph_WeaponResourceReference;
	BrickComponentType_WireGraph_WheelEngineAudioReference: BrickComponentData_WireGraph_WheelEngineAudioReference;
	Component_AudioEmitter: BrickComponentData_AudioEmitter;
	Component_BotSpawn: BrickComponentData_BotSpawn;
	Component_BrickPropertyChanger: BrickComponentData_BrickPropertyChanger;
	Component_Button: BrickComponentData_Button;
	Component_CheckPoint: BrickComponentData_CheckPoint;
	Component_Damage: BrickComponentData_Damage;
	Component_Interact: BrickComponentData_Interact;
	Component_Internal_AnimatedButton: BrickComponentData_Button;
	Component_Internal_AnimatedPressurePlate: BrickComponentData_Touch;
	Component_Internal_AnimatedSwitch: BrickComponentData_Switch;
	Component_Internal_AttachedZone: BrickComponentData_Internal_AttachedZone;
	Component_Internal_Bearing: BrickComponentData_Bearing;
	Component_Internal_Gyroscope: BrickComponentData_Gyroscope;
	Component_Internal_InputSplitter: BrickComponentData_Internal_InputSplitter_V2;
	Component_Internal_Joint_Wheel: BrickComponentData_Joint_Wheel;
	Component_Internal_Joint_Wheel_Suspension: BrickComponentData_Joint_Wheel_Suspension;
	Component_Internal_Microchip: BrickComponentData_Internal_Microchip;
	Component_Internal_Motor: BrickComponentData_Motor;
	Component_Internal_MotorSlider: BrickComponentData_MotorSlider;
	Component_Internal_ProjectileSpawner_Cannon: BrickComponentData_ProjectileSpawner;
	Component_Internal_Rerouter: BrickComponentData_Rerouter;
	Component_Internal_RigidBearing: BrickComponentData_RigidBearing;
	Component_Internal_RigidSlider: BrickComponentData_RigidSlider;
	Component_Internal_Seat: BrickComponentData_Seat_V2;
	Component_Internal_Servo: BrickComponentData_Servo;
	Component_Internal_ServoSlider: BrickComponentData_ServoSlider;
	Component_Internal_Slider: BrickComponentData_Slider;
	Component_Internal_Thruster: BrickComponentData_Thruster;
	Component_Internal_WeightBrick: BrickComponentData_WeightBrick;
	Component_Internal_WheelEngine: BrickComponentData_WheelEngine_V2;
	Component_ItemSpawn: BrickComponentData_ItemSpawn;
	Component_OneShotAudioEmitter: BrickComponentData_OneShotAudioEmitter;
	Component_PointLight: BrickComponentData_PointLight;
	Component_ProjectileSpawner: BrickComponentData_ProjectileSpawner;
	Component_SpawnPoint: BrickComponentData_SpawnPoint;
	Component_SpotLight: BrickComponentData_SpotLight;
	Component_Switch: BrickComponentData_Switch;
	Component_Target: BrickComponentData_Target;
	Component_TextDisplay: BrickComponentData_TextDisplay;
	Component_Touch: BrickComponentData_Touch;
	Component_WireGraph_PlayAudioAt: BrickComponentData_WireGraph_Exec_Entity_PlayAudioAt;
};
/** One entry of Bundle.json's `authors` array as the game writes it. */
export interface BundleAuthor {
	iD: string;
	name: string;
}
/** Bundle.json `color` (RGBA, 0..=1 floats; the game writes whole numbers
 * for white). */
export interface BundleColor {
	r: number;
	g: number;
	b: number;
	a: number;
}
export interface BundleJson {
	type: string;
	iD: string;
	name: string;
	version: string;
	tags: string[];
	authors: BundleAuthor[];
	createdAt: string;
	updatedAt: string;
	description: string;
	/** Absent in older generated bundles; the game always writes it. */
	color?: BundleColor;
	dependencies: unknown[];
	gameVersion: string;
}
export interface WriteBrzOptions {
	/** zstd compressor for blobs; omitted -> all blobs stored raw (valid, and
	 * what the byte-parity gates compare against). */
	compress?: Compressor;
	/** Meta/World.json environment. save.map is NOT used. Default "Plate". */
	environment?: string;
	/** Meta/Bundle.json field overrides. */
	bundle?: Partial<BundleJson>;
	/** Meta/Thumbnail.png content; omitted -> file not written. */
	thumbnail?: Uint8Array;
	/** Meta/Screenshot.jpg content; omitted -> file not written. The game
	 * reads it for world previews, and for prefab previews when present. */
	screenshot?: Uint8Array;
	/** External asset table ({type, name} pairs, e.g. type
	 * 'BrickOneShotAudioDescriptor', name 'OBA_UI_Goal_Tune_Cue'). Component
	 * data fields of asset type (e.g. Component_Interact's InteractSound)
	 * store an index into this table; null stays null. Default empty;
	 * WorldReader.externalAssets() reads the same shape back. */
	externalAssets?: {
		type: string;
		name: string;
	}[];
	/** Meta/Prefab.json content, written verbatim; when set the bundle is a
	 * prefab (Bundle.json type "Prefab" + Prefab.json, no World.json, so the
	 * `environment` option is unused). Pair with WorldReader.prefabJson()
	 * to keep a clipboard prefab's paste pivots/offset through a round
	 * trip. The World builder's makePrefab() computes this from the
	 * main-grid bounds instead and takes precedence over the option. */
	prefab?: Record<string, unknown>;
}
/** A brdb-native component on a brick. Legacy brs components
 * (save.components / brick.components) are NOT converted. */
/** Typed component input: known component types complete their `data`
 * fields in the editor; unknown type strings stay accepted (they throw at
 * write time unless the component db knows them). Omitted data fields take
 * the game's default values (zero values where no default is known). */
export type BrdbComponentInput = {
	[T in keyof ComponentTypeDataMap]: {
		/** brdb component type name, e.g. 'Component_Internal_Seat' */
		type: T;
		/** fields of the component's data struct */
		data?: Partial<ComponentTypeDataMap[T]>;
	};
}[keyof ComponentTypeDataMap] | {
	type: string & {};
	data?: Record<string, BrdbValue>;
};
export interface BrdbWireEndpointInput {
	/** index into save.bricks */
	brick_index: number;
	/** brdb component type name (must be used by a brick in this save) */
	component_type: string;
	/** wire port name, e.g. 'Output' */
	port: string;
}
/** A wire between two component ports, using brdb-native names. Legacy
 * save.wires (brs component names) are NOT converted. */
export interface BrdbWireInput {
	source: BrdbWireEndpointInput;
	target: BrdbWireEndpointInput;
}
/** brdb-native extras alongside the legacy save shape: bricks carry a
 * modern `components` ARRAY of typed inputs (replacing the legacy .brs
 * component map on that field, which is not converted) and the save
 * carries `wires`. */
export interface BrdbBrickExtras {
	components?: BrdbComponentInput[];
	/** Required for procedural assets; optional for basic (non-procedural)
	 * assets, whose size is fixed by the asset and never stored. */
	size?: WriteSaveObject["bricks"][number]["size"];
}
export interface BrdbSaveExtras {
	wires?: BrdbWireInput[];
}
/** The legacy save shape plus the brdb-native extras. The brick-level
 * legacy `components` map and the save-level legacy `wires` list are
 * replaced by the modern forms. */
export type WriteBrzSave = Omit<WriteSaveObject, "bricks" | "wires"> & {
	bricks: (Omit<WriteSaveObject["bricks"][number], "components" | "size"> & BrdbBrickExtras)[];
} & BrdbSaveExtras;
/** What the world writers accept: the modern shape, or an unmodified
 * legacy save (whose map-shaped `components` and legacy-named `wires`
 * are ignored rather than converted). */
export type WriteBrzInput = WriteBrzSave | WriteSaveObject;
declare function toRelative(position: readonly number[]): {
	chunk: [
		number,
		number,
		number
	];
	rel: [
		number,
		number,
		number
	];
};
declare function saveToPendingFs(save: WriteBrzInput, options?: WriteBrzOptions): PendingEntry[];
/** An entity to place in the world. Grid entities (dynamic/microchip brick
 * grids) come from `World.addBrickGrid`/`World.addMicrochip`. */
export interface BrdbEntityInput {
	/** entity type name; default 'Entity_DynamicBrickGrid' */
	type?: string;
	location?: {
		X: number;
		Y: number;
		Z: number;
	};
	rotation?: {
		X: number;
		Y: number;
		Z: number;
		W: number;
	};
	owner_index?: number;
	frozen?: boolean;
	sleeping?: boolean;
	linear_velocity?: {
		X: number;
		Y: number;
		Z: number;
	};
	angular_velocity?: {
		X: number;
		Y: number;
		Z: number;
	};
	/** up to 8 entity palette colors; missing slots default to white */
	colors?: {
		R: number;
		G: number;
		B: number;
		A: number;
	}[];
	/** fields of the entity's data class struct; omitted fields zero-fill */
	data?: Record<string, BrdbValue>;
}
/** A brick for the World builder: the legacy brick shape with the asset
 * and material referenced by NAME instead of by table index. */
export type WorldBrickInput = Omit<WriteBrzSave["bricks"][number], "asset_name_index" | "material_index" | "color" | "owner_index"> & {
	/** brick asset name; default 'PB_DefaultBrick' */
	asset?: string;
	/** material asset name; default 'BMC_Plastic' */
	material?: string;
	color?: [
		number,
		number,
		number
	];
	/** index returned by `World.addOwner` (0 = the built-in PUBLIC) */
	owner_index?: number;
};
export interface WorldBrickHandle {
	/** grid slot (0 = main grid) */
	readonly grid: number;
	/** index within that grid's brick list */
	readonly index: number;
}
export interface WorldGridHandle {
	readonly grid: number;
	readonly entityOrder: number;
}
export interface WorldEntityHandle {
	readonly entityOrder: number;
}
export interface WorldWireEndpoint {
	brick: WorldBrickHandle;
	component_type: string;
	port: string;
}
export interface WorldPrefabOptions {
	isMicrochipPrefab?: boolean;
	isPhysicsGrid?: boolean;
	freezePhysicsGrid?: boolean;
	freezeGlobalGrid?: boolean;
	addedGlobalGridOffset?: {
		x: number;
		y: number;
		z: number;
	};
}
export interface WorldMicrochipOptions {
	/** world position of the outer microchip shell brick */
	position: [
		number,
		number,
		number
	];
	color?: [
		number,
		number,
		number
	];
	owner_index?: number;
	/** inner grid entity location; default {X:0, Y:0, Z:40} */
	entityLocation?: {
		X: number;
		Y: number;
		Z: number;
	};
	/** inner grid plane half-extent in grid units; default {X:14, Y:14, Z:2}
	 * (matches in-game placement) */
	planeExtent?: {
		X: number;
		Y: number;
		Z: number;
	};
	/** whether the chip starts collapsed; default true */
	collapsed?: boolean;
}
declare class World {
	private gridBrickInputs;
	/** per sub-grid slot (1..): the grid entity's insertion order */
	private gridEntityOrders;
	private entityInputs;
	private wireList;
	private chipLinks;
	private ownerList;
	private prefabOptions;
	private prefabList;
	/** Register an owner; returns its owner_index (0 is the built-in PUBLIC
	 * owner, so the first added owner is index 1). */
	addOwner(owner: {
		id?: string;
		name?: string;
		display_name?: string;
	}): number;
	/** Add a brick to the main grid, or to a sub-grid via its handle. */
	addBrick(brick: WorldBrickInput, grid?: WorldGridHandle): WorldBrickHandle;
	addBricks(bricks: Iterable<WorldBrickInput>, grid?: WorldGridHandle): WorldBrickHandle[];
	/** Add a standalone (non-grid) entity. */
	addEntity(entity?: BrdbEntityInput): WorldEntityHandle;
	/** Create a sub-grid backed by a grid entity (a dynamic brick grid by
	 * default). Brick positions in sub-grids are grid-local; the writer
	 * shifts them by -CHUNK_HALF per axis to the chunk-center convention,
	 * matching the reference writer. */
	addBrickGrid(entity?: BrdbEntityInput): WorldGridHandle;
	/** Wire two component ports together; endpoints may be in different
	 * grids (the writer emits remote wire rows for cross-grid sources). */
	addWire(source: WorldWireEndpoint, target: WorldWireEndpoint): void;
	/** Pair an outer microchip shell brick with its inner grid. Most callers
	 * get this for free via `addMicrochip`. */
	registerMicrochipLink(brick: WorldBrickHandle, grid: WorldGridHandle): void;
	/** Build a microchip: places the outer B_1x1_Microchip shell brick on
	 * the main grid (with its Component_Internal_Microchip), creates the
	 * linked inner grid entity, and returns both handles. Add the chip's
	 * contents with `addBrick(..., grid)`. */
	addMicrochip(opts: WorldMicrochipOptions): {
		brick: WorldBrickHandle;
		grid: WorldGridHandle;
	};
	/** Mark this world as a prefab bundle: Bundle.json type "Prefab" plus
	 * Meta/Prefab.json with pivots/bounds computed from the main-grid brick
	 * bounding box (World.json is omitted). */
	makePrefab(options?: WorldPrefabOptions): void;
	/** Embed a prefab archive, content-addressed the way the game does:
	 * `Prefabs/Uploads/<BLAKE3-uppercase-hex>.brz`. Returns that path, the
	 * exact string a `Prefab` component property (`bundle_path_ref`) should
	 * carry, e.g. on BrickComponentType_WireGraph_Exec_PrefabSpawner or
	 * BrickComponentType_PrefabSpawn. Identical bytes dedupe to one entry. */
	addPrefab(bytes: Uint8Array): string;
	toPendingFs(options?: WriteBrzOptions): PendingEntry[];
	/** Serialize to an in-memory .brz archive. */
	toBrz(options?: WriteBrzOptions): Uint8Array;
}
declare function writeBrzLegacy(save: WriteBrzInput, options?: WriteBrzOptions): Uint8Array;
export interface ChunkCoord {
	x: number;
	y: number;
	z: number;
}
export interface BrickChunkRef {
	index: ChunkCoord;
	offset: ChunkCoord;
	size: number;
	numBricks: number;
	numComponents: number;
	numWires: number;
}
export interface EntityChunkRef {
	index: ChunkCoord;
	numEntities: number;
}
export interface EntityChunkIndex {
	nextPersistentIndex: number;
	chunks: EntityChunkRef[];
}
export interface ComponentInstance {
	typeName: string;
	structName: string | null;
	/** the owning brick's local index within its chunk */
	brickIndex: number;
	data: Record<string, BrdbValue> | null;
}
export interface WireEndpoint {
	/** the endpoint brick's local index within its chunk */
	brickIndex: number;
	componentType: string;
	port: string;
}
export interface RemoteWireEndpoint extends WireEndpoint {
	gridId: number;
	chunk: ChunkCoord;
}
export interface WireChunk {
	/** wires whose source is in the same grid+chunk as the target */
	local: Array<{
		source: WireEndpoint;
		target: WireEndpoint;
	}>;
	/** wires whose source lives in another grid or chunk */
	remote: Array<{
		source: RemoteWireEndpoint;
		target: WireEndpoint;
	}>;
}
export interface EntityRecord {
	typeName: string;
	className: string | null;
	persistentIndex: number;
	ownerIndex: number;
	originalOwnerIndex: number;
	location: {
		X: number;
		Y: number;
		Z: number;
	};
	rotation: {
		X: number;
		Y: number;
		Z: number;
		W: number;
	};
	frozen: boolean;
	sleeping: boolean;
	linearVelocity: {
		X: number;
		Y: number;
		Z: number;
	};
	angularVelocity: {
		X: number;
		Y: number;
		Z: number;
	};
	colors: Record<string, BrdbValue>;
	remainingLifeSpan: number;
	data: Record<string, BrdbValue> | null;
}
export interface BrzWorldBrick {
	asset_name_index: number;
	size: Vector;
	position: Vector;
	direction: number;
	rotation: number;
	collision: Collision;
	visibility: boolean;
	material_index: number;
	material_intensity: number;
	color: [
		number,
		number,
		number
	];
	owner_index: number;
}
declare class WorldReader {
	readonly fs: WorldFs;
	readonly worldId: number;
	private schemas;
	private values;
	constructor(fs: WorldFs, worldId?: number);
	static from(data: Uint8Array): WorldReader;
	private path;
	/** Parse a .schema blob once per revision; later calls return the cached
	 * schema. The public form resolves the schema file's own (latest)
	 * revision. */
	schema(path: string): BrdbSchema;
	/** Schema as it existed at `revision` (a created_at timestamp). Schemas
	 * evolve over a world's history; data files must decode with the schema
	 * revision that was live when they were written. */
	private schemaAt;
	private decode;
	private cached;
	bundle(): BundleJson;
	environment(): {
		environment: string;
	};
	/** Meta/Prefab.json parsed, or null for world bundles. */
	prefabJson(): Record<string, unknown> | null;
	/** Meta/Thumbnail.png bytes, or null when absent. */
	thumbnail(): Uint8Array | null;
	/** Meta/Screenshot.jpg bytes, or null when absent. */
	screenshot(): Uint8Array | null;
	/** Root-relative paths of embedded prefabs (files under Prefabs/), e.g.
	 * Prefabs/Uploads/<HASH>.brz, the exact strings Prefab component
	 * properties (bundle_path_ref) reference. Empty when none are embedded. */
	prefabPaths(): string[];
	/** Raw bytes of an embedded prefab archive. */
	readPrefab(path: string): Uint8Array;
	/** Open an embedded prefab as its own WorldReader. */
	prefabReader(path: string): WorldReader;
	globalData(): any;
	owners(): any;
	/** Basic asset names followed by procedural; decoded brick
	 * asset_name_index values point into this combined list. */
	brickAssets(): string[];
	materials(): string[];
	/** External asset table as {type, name} pairs, the shape the write
	 * options accept. Component data fields of asset type store indices
	 * into this table. */
	externalAssets(): {
		type: string;
		name: string;
	}[];
	/** Owner rows 1.. (the PUBLIC row 0 is excluded). */
	brickOwners(): Owner[];
	/** Grid ids under Bricks/Grids: 1 = the main grid, ≥2 = entity sub-grids. */
	gridIds(): number[];
	brickChunkIndex(gridId?: number): BrickChunkRef[];
	/** Decode one brick chunk's SoA. Not cached: chunk payloads are the bulk
	 * of an archive and are meant to be streamed, not retained. */
	brickChunkSoa(gridId: number, chunk: ChunkCoord): any;
	/** Lazily decode a grid's bricks, one chunk at a time. Positions are
	 * relative to the grid's origin: world origin for the main grid (1),
	 * entity-relative for sub-grids (≥2). */
	bricks(gridId?: number): Generator<BrzWorldBrick, void, void>;
	/** Entity chunk registry. */
	entityChunkIndex(): EntityChunkIndex;
	/** Decode a component chunk: the SoA plus each instance's trailing data
	 * struct. Instances stream in counter order; a type whose data-struct
	 * slot is missing or "None" contributes no trailing bytes. */
	componentChunk(gridId: number, chunk: ChunkCoord): {
		soa: any;
		components: ComponentInstance[];
	};
	/** Decode a wire chunk. Wires live in the TARGET's grid+chunk; local
	 * rows are same-grid-same-chunk sources, remote rows carry the source
	 * grid + chunk. Component/port names resolve through GlobalData. */
	wireChunk(gridId: number, chunk: ChunkCoord): WireChunk;
	/** Decode one entity chunk: the SoA plus each entity's trailing data
	 * struct (gated on EntityDataClassNames: absent or "None" = no struct). */
	entityChunk(chunk: ChunkCoord): EntityRecord[];
	/** Lazily decode every entity, one chunk at a time. */
	entities(): Generator<EntityRecord, void, void>;
}
export interface BrGuid {
	A: number;
	B: number;
	C: number;
	D: number;
}
declare function uuidToGuid(uuid: string): BrGuid;
declare function guidToUuid(guid: BrGuid): string;
declare function isProceduralAsset(name: string): boolean;
export interface BrdbStatement {
	run(...params: unknown[]): {
		lastInsertRowid: number | bigint;
	};
	get(...params: unknown[]): unknown;
	all(...params: unknown[]): unknown[];
}
export interface BrdbSqlite {
	exec(sql: string): unknown;
	prepare(sql: string): BrdbStatement;
	close(): void;
}
export interface BrdbBlob {
	blobId: number;
	compression: number;
	sizeUncompressed: number;
	sizeCompressed: number;
	deltaBaseId: number | null;
	hash: Uint8Array;
	content: Uint8Array;
}
export interface BrdbRevision {
	revisionId: number;
	description: string;
	createdAt: number;
}
export interface WritePendingOptions {
	/** Revision timestamp in unix seconds. Defaults to the wall clock. */
	createdAt?: number;
	/** Blob compressor. undefined uses the instance default (zstd level 14
	 * when opened through the lazy openers); null stores raw. */
	compress?: Compressor | null;
}
declare class Brdb implements WorldFs {
	readonly db: BrdbSqlite;
	/** Override how the better-sqlite3 module is resolved. Useful when a
	 * bundler or test runner cannot execute a native dynamic import. */
	static engineLoader: (() => Promise<unknown>) | null;
	/** zstd compressor applied to new blobs when no per-write compressor is
	 * given. The lazy openers set this; a directly-wrapped handle has none. */
	defaultCompress: Compressor | null;
	constructor(db: BrdbSqlite);
	/** Create-container semantics on any handle: run the DDL and stamp the
	 * initial revision. */
	static init(db: BrdbSqlite, createdAt?: number): Brdb;
	/** Construct create/open semantics on a handle, closing it if construction
	 * (the DDL or the required-table guard) throws so a failed opener never
	 * leaks the underlying handle (and, on Windows, never leaves it locked). */
	private static wrap;
	/** Open an existing database file. Rejects (without creating a file) when
	 * the path does not already exist. */
	static open(path: string): Promise<Brdb>;
	/** Open an existing database file read-only. Rejects (without creating a
	 * file) when the path does not already exist. */
	static openReadonly(path: string): Promise<Brdb>;
	/** Create a new database file (container schema + initial revision). */
	static create(path: string): Promise<Brdb>;
	/** Open the file if it exists, otherwise create it. */
	static openOrCreate(path: string): Promise<Brdb>;
	/** New in-memory database. */
	static memory(): Promise<Brdb>;
	/** Open a database from serialized bytes. */
	static fromBytes(bytes: Uint8Array): Promise<Brdb>;
	/** Serialize the database to bytes (requires a better-sqlite3 handle). */
	toBytes(): Uint8Array;
	/** Write a world save as one revision: a World builder instance or a
	 * legacy .brs-shaped save object. */
	save(description: string, save: WriteBrzInput | World, options?: Omit<WriteBrzOptions, "compress"> & WritePendingOptions): void;
	/** Lazy world reader over this database (same surface as .brz reading).
	 * The reader caches decoded metadata (GlobalData, Owners, Bundle/World
	 * JSON) for its lifetime; if this Brdb is written to (save/writePending)
	 * after the reader is created, construct a fresh worldReader() rather
	 * than reusing the old one, or later reads may mix stale cached metadata
	 * with newly written chunk data. */
	worldReader(): WorldReader;
	sqliteSchema(): string;
	createRevision(description: string, createdAt?: number): number;
	revisions(): BrdbRevision[];
	insertFolder(name: string, parentId: number | null, createdAt: number): number;
	insertFile(name: string, parentId: number | null, contentId: number, createdAt: number): number;
	/** Insert a blob (dedup by hash + uncompressed size), compressing when the
	 * compressor yields something strictly smaller. */
	insertBlob(content: Uint8Array, hash: Uint8Array, compress: Compressor | null): number;
	findBlobByHash(size: number, hash: Uint8Array): BrdbBlob | null;
	findBlob(contentId: number): BrdbBlob;
	deleteFile(fileId: number, deletedAt: number): void;
	deleteFolder(folderId: number, deletedAt: number): void;
	findFolder(parentId: number | null, name: string): number | null;
	/** Like findFolder, but resolves against the tree as of a revision date
	 * instead of the current tree. Used by findFileByPathAtRevision so an
	 * ancestor folder that was soft-deleted after `date` does not hide a file
	 * that was still live at `date`. */
	findFolderAtRevision(parentId: number | null, name: string, date: number): number | null;
	findFile(parentId: number | null, name: string): FoundFile | null;
	findFileAtRevision(parentId: number | null, name: string, date: number): FoundFile | null;
	close(): void;
	/** Merge a COMPLETE pending tree against the current tree in one
	 * transaction: identical files are noops, changed files are soft-deleted
	 * and reinserted, and existing entries absent from the pending tree are
	 * soft-deleted recursively. */
	writePending(description: string, pending: PendingEntry[], options?: WritePendingOptions): void;
	private currentFolders;
	private currentFiles;
	private mergeFolder;
	private insertPending;
	private deleteFolderRecursive;
	/** Resolve a folder path. '' is the root. With no date, resolves against
	 * the current tree; with a date, resolves each segment against the tree
	 * as of that revision (see findFolderAtRevision). */
	private folderIdOf;
	findFileByPath(path: string): FoundFile | null;
	/** Both folders and the leaf file resolve against the tree as of `date`,
	 * so a file is still reachable at a date before an ancestor folder was
	 * later soft-deleted. */
	findFileByPathAtRevision(path: string, date: number): FoundFile | null;
	childFolders(path: string): string[];
	childFiles(path: string): string[];
	/** Decompressed blob content. Empty files (contentId -1) yield empty
	 * bytes, matching the .brz reader's documented deviation. */
	readBlob(contentId: number): Uint8Array;
	readFile(path: string): Uint8Array;
	/** The full current tree as a pending tree (folders first, then files,
	 * each in name order). */
	toPending(): PendingEntry[];
}
declare class BitFlags {
	bytes: number[];
	private bits;
	push(v: boolean): void;
	toValue(): BrdbValue;
}
declare function hsv(h: number | {
	h: number;
	s: number;
	v: number;
}, s?: number, v?: number): number[];
export interface DebouncedFunc<T extends (...args: never[]) => unknown> {
	/**
	 * Call the original function, but applying the debounce rules.
	 *
	 * If the debounced function can be run immediately, this calls it and returns its return
	 * value.
	 *
	 * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
	 * function was not invoked yet.
	 */
	(...args: Parameters<T>): ReturnType<T> | undefined;
	/**
	 * Throw away any pending invocation of the debounced function.
	 */
	cancel(): void;
	/**
	 * If there is a pending invocation of the debounced function, invoke it immediately and return
	 * its return value.
	 *
	 * Otherwise, return the value from the last invocation, or undefined if the debounced function
	 * was never invoked.
	 */
	flush(): ReturnType<T> | undefined;
}
export interface DebouncedFuncLeading<T extends (...args: never[]) => unknown> extends DebouncedFunc<T> {
	(...args: Parameters<T>): ReturnType<T>;
	flush(): ReturnType<T>;
}
export interface DebounceSettings {
	leading?: boolean | undefined;
	maxWait?: number | undefined;
	trailing?: boolean | undefined;
}
export interface DebounceSettingsLeading extends DebounceSettings {
	leading: true;
}
declare function parseDuration(str: string): number;
declare function parseBrickadiaTime(str: string): number;
declare function brn2n(brName: string): string;
declare function n2brn(name: string): string;
export interface IBrickBounds {
	minBound: Vector;
	maxBound: Vector;
	center: Vector;
}
declare function checkBounds(brick: Brick, brick_assets: string[], bounds: IBrickBounds): boolean;
declare function getBounds({ bricks, brick_assets }: WriteSaveObject): IBrickBounds;
declare function getBrickSize(brick: Brick, brick_assets: string[]): [
	number,
	number,
	number
];
declare function getScaleAxis(brick: Brick, axis: number): number;
declare function setOwnership(player: {
	id: string;
	name: string;
}, saveData: ReadSaveObject): ReadSaveObject;
declare function rotate(brick: Brick, rotation: [
	number,
	number
]): Brick;
declare function rotate_x(times: number): (obj: Brick) => Brick;
declare function rotate_y(times: number): (obj: Brick) => Brick;
declare function rotate_z(times: number): (obj: Brick) => Brick;
// FIXME: Is this `any` really necessary?
export type VariableArgFunction = (...params: any[]) => unknown;
export type ArgumentTypes<F extends VariableArgFunction> = F extends (...args: infer A) => unknown ? A : never;
export type ElementOf<T> = T extends Array<infer E> ? E : T;
declare namespace BetterSqlite3 {
	interface Statement<BindParameters extends unknown[], Result = unknown> {
		database: Database;
		source: string;
		reader: boolean;
		readonly: boolean;
		busy: boolean;
		run(...params: BindParameters): Database.RunResult;
		get(...params: BindParameters): Result | undefined;
		all(...params: BindParameters): Result[];
		iterate(...params: BindParameters): IterableIterator<Result>;
		pluck(toggleState?: boolean): this;
		expand(toggleState?: boolean): this;
		raw(toggleState?: boolean): this;
		bind(...params: BindParameters): this;
		columns(): ColumnDefinition[];
		safeIntegers(toggleState?: boolean): this;
	}
	interface ColumnDefinition {
		name: string;
		column: string | null;
		table: string | null;
		database: string | null;
		type: string | null;
	}
	interface Transaction<F extends VariableArgFunction> {
		(...params: ArgumentTypes<F>): ReturnType<F>;
		default(...params: ArgumentTypes<F>): ReturnType<F>;
		deferred(...params: ArgumentTypes<F>): ReturnType<F>;
		immediate(...params: ArgumentTypes<F>): ReturnType<F>;
		exclusive(...params: ArgumentTypes<F>): ReturnType<F>;
	}
	interface VirtualTableOptions {
		rows: (...params: unknown[]) => Generator;
		columns: string[];
		parameters?: string[] | undefined;
		safeIntegers?: boolean | undefined;
		directOnly?: boolean | undefined;
	}
	interface Database {
		memory: boolean;
		readonly: boolean;
		name: string;
		open: boolean;
		inTransaction: boolean;
		prepare<BindParameters extends unknown[] | {} = unknown[], Result = unknown>(source: string): BindParameters extends unknown[] ? Statement<BindParameters, Result> : Statement<[
			BindParameters
		], Result>;
		transaction<F extends VariableArgFunction>(fn: F): Transaction<F>;
		exec(source: string): this;
		pragma(source: string, options?: Database.PragmaOptions): unknown;
		function(name: string, cb: (...params: any[]) => any): this;
		function(name: string, options: Database.RegistrationOptions, cb: (...params: any[]) => any): this;
		aggregate<T>(name: string, options: Database.RegistrationOptions & {
			start?: T | (() => T);
			// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
			step: (total: T, next: ElementOf<T>) => T | void;
			inverse?: ((total: T, dropped: T) => T) | undefined;
			result?: ((total: T) => unknown) | undefined;
		}): this;
		loadExtension(path: string): this;
		close(): this;
		defaultSafeIntegers(toggleState?: boolean): this;
		backup(destinationFile: string, options?: Database.BackupOptions): Promise<Database.BackupMetadata>;
		table(name: string, options: VirtualTableOptions): this;
		unsafeMode(unsafe?: boolean): this;
		serialize(options?: Database.SerializeOptions): Buffer;
	}
	interface DatabaseConstructor {
		new (filename?: string | Buffer, options?: Database.Options): Database;
		(filename?: string, options?: Database.Options): Database;
		prototype: Database;
		SqliteError: SqliteErrorType;
	}
}
declare class SqliteErrorClass extends Error {
	name: string;
	message: string;
	code: string;
	constructor(message: string, code: string);
}
export type SqliteErrorType = typeof SqliteErrorClass;
declare namespace Database {
	interface RunResult {
		changes: number;
		lastInsertRowid: number | bigint;
	}
	interface Options {
		readonly?: boolean | undefined;
		fileMustExist?: boolean | undefined;
		timeout?: number | undefined;
		verbose?: ((message?: unknown, ...additionalArgs: unknown[]) => void) | undefined;
		nativeBinding?: string | undefined;
	}
	interface SerializeOptions {
		attached?: string;
	}
	interface PragmaOptions {
		simple?: boolean | undefined;
	}
	interface RegistrationOptions {
		varargs?: boolean | undefined;
		deterministic?: boolean | undefined;
		safeIntegers?: boolean | undefined;
		directOnly?: boolean | undefined;
	}
	type AggregateOptions = Parameters<BetterSqlite3.Database["aggregate"]>[1];
	interface BackupMetadata {
		totalPages: number;
		remainingPages: number;
	}
	interface BackupOptions {
		progress: (info: BackupMetadata) => number;
	}
	type SqliteError = SqliteErrorType;
	type Statement<BindParameters extends unknown[] | {} = unknown[], Result = unknown> = BindParameters extends unknown[] ? BetterSqlite3.Statement<BindParameters, Result> : BetterSqlite3.Statement<[
		BindParameters
	], Result>;
	type ColumnDefinition = BetterSqlite3.ColumnDefinition;
	type Transaction<T extends VariableArgFunction = VariableArgFunction> = BetterSqlite3.Transaction<T>;
	type Database = BetterSqlite3.Database;
}
declare const Database: BetterSqlite3.DatabaseConstructor;
export declare const _OMEGGA_UTILS_IMPORT: {
	chat: {
		EMOTES: string[];
		sanitize: (str: string) => string;
		parseLinks: (message: string) => string;
		attr: (attr: string, param?: string) => ((message: string) => string);
		attrParam: <T = string>(attr: string) => (message: string, param: T) => string;
		color: (message: string, param: string) => string;
		bold: (message: string) => string;
		italic: (message: string) => string;
		underline: (message: string) => string;
		emoji: (message: string) => string;
		code: (message: string) => string;
		font: (message: string, param: string) => string;
		size: (message: string, param: number) => string;
		link: (message: string, param: string) => string;
		red: (message: string) => string;
		green: (message: string) => string;
		blue: (message: string) => string;
		yellow: (message: string) => string;
		cyan: (message: string) => string;
		magenta: (message: string) => string;
		black: (message: string) => string;
		white: (message: string) => string;
		gray: (message: string) => string;
	};
	color: {
		hsv: typeof hsv;
		linearRGB: (rgba: number[]) => number[];
		sRGB: (linear: number[]) => number[];
		rgbToHex: (r: number | [
			number,
			number,
			number
		] | {
			r: number;
			g: number;
			b: number;
		}, g?: number, b?: number) => string;
		DEFAULT_COLORSET: number[][];
	};
	uuid: {
		UUID_PATTERN: RegExp;
		match: (str: string) => boolean;
		random: () => string;
	};
	pattern: {
		explode: (str: string) => RegExp;
	};
	time: {
		parseDuration: typeof parseDuration;
		parseBrickadiaTime: typeof parseBrickadiaTime;
		debounce: (<T extends (...args: never[]) => unknown>(func: T, wait: number | undefined, options?: DebounceSettingsLeading) => DebouncedFuncLeading<T>) | (<T extends (...args: never[]) => unknown>(func: T, wait?: number, options?: DebounceSettings) => DebouncedFunc<T>);
	};
	map: {
		DEFAULT_MAPS: {
			name: string;
			brName: string;
		}[];
		brn2n: typeof brn2n;
		n2brn: typeof n2brn;
	};
	brick: {
		BRICK_CONSTANTS: {
			rotationTable: number[];
			translationTable: (([x, y, z]: [
				number,
				number,
				number
			]) => [
				number,
				number,
				number
			])[];
			orientationMap: Record<string, [
				number,
				number
			]>;
			DEFAULT_MATERIALS: string[];
			brickSizeMap: Record<string, [
				number,
				number,
				number
			]>;
		};
		checkBounds: typeof checkBounds;
		getBounds: typeof getBounds;
		getBrickSize: typeof getBrickSize;
		getScaleAxis: typeof getScaleAxis;
		setOwnership: typeof setOwnership;
		rotate: typeof rotate;
		rotate_x: typeof rotate_x;
		rotate_y: typeof rotate_y;
		rotate_z: typeof rotate_z;
		d2o: (direction: number, rotation: number) => number;
		o2d: (orientation: number) => number[];
	};
	wsl: () => number;
	brs: {
		read(rawBytes: Uint8Array, options?: {
			bricks?: boolean;
			preview
			/**
			 * Returns omegga
			 */
			? /**
			 * Returns omegga
			 */: boolean;
		}): ReadSaveObject;
		write(save: WriteSaveObject, options?: {
			compress?: boolean;
		}): Uint8Array;
		utils: any;
		constants: {
			MAGIC: Uint8Array;
			LATEST_VERSION: number;
			MAX_INT: number;
			DEFAULT_UUID: Uuid;
		};
	};
	brdb: {
		Brdb: typeof Brdb;
		WorldReader: typeof WorldReader;
		BrzReader: typeof BrzReader;
		writeBrzContainer: typeof writeBrzContainer;
		writeBrzLegacy: typeof writeBrzLegacy;
		saveToPendingFs: typeof saveToPendingFs;
		toRelative: typeof toRelative;
		MAIN_GRID: number;
		CHUNK_SIZE: number;
		CHUNK_HALF: number;
		BrdbSchema: typeof BrdbSchema;
		embeddedSchema: typeof embeddedSchema;
		guidToUuid: typeof guidToUuid;
		uuidToGuid: typeof uuidToGuid;
		PUBLIC_GUID: BrGuid;
		file: (content: Uint8Array) => PendingNode;
		folder: (children: PendingEntry[]) => PendingNode;
		isProceduralAsset: typeof isProceduralAsset;
		bit: (flags: {
			Flags: number[];
		}, i: number) => boolean;
		BitFlags: typeof BitFlags;
		ByteReader: typeof ByteReader;
		ByteWriter: typeof ByteWriter;
		msgpack: any;
	};
	Sqlite: new (filename?: string | Buffer, options?: Database.Options) => Database.Database;
};
declare global {
	export var Omegga: OmeggaLike;
	export var Player: StaticPlayer;
	export var OMEGGA_UTIL: typeof _OMEGGA_UTILS_IMPORT;
}
export type OL = OmeggaLike;
export type OP = OmeggaPlugin;
export type PC<T extends Record<string, unknown> = Record<string, unknown>> = PluginConfig<T>;
export type PS<T extends Record<string, unknown> = Record<string, unknown>> = PluginStore<T>;
export type PM = PluginMetrics;
export interface BrickBounds {
	minBound: [
		number,
		number,
		number
	];
	maxBound: [
		number,
		number,
		number
	];
	center: [
		number,
		number,
		number
	];
}
/** Created when a player clicks on a brick with an interact component */
export interface BrickInteraction {
	/** Brick name from catalog (Turkey Body, 4x Cube) */
	brick_name: string;
	/** Brick asset name; null when the display name is not recognized */
	brick_asset: string | null;
	/** Brick size; null when the display name is not recognized */
	brick_size: [
		number,
		number,
		number
	] | null;
	/** Player information, id, name, controller, and pawn */
	player: {
		id: string;
		name: string;
		controller: string;
		pawn: string;
	};
	/** Brick center position */
	position: [
		number,
		number,
		number
	];
	/** message sent from a brick click interaction */
	message: string;
	/** data parsed from the line (if it starts with json:) */
	data: null | number | string | boolean | Record<string, unknown>;
	/** True when there was a json payload */
	json: boolean;
	/** True when there was a parse error */
	error: boolean;
}
/** AutoRestart options */
export type AutoRestartConfig = {
	players: boolean;
	announcement: boolean;
	saveWorld: boolean;
};
export interface OmeggaPlayer {
	/** player name */
	name: string;
	/** player display name */
	displayName: string;
	/** player uuid */
	id: string;
	/** player controller id */
	controller: string;
	/** player state id */
	state: string;
	/**
	 * Returns omegga
	 */
	getOmegga(): OmeggaLike;
	/**
	 * Clone a player
	 */
	clone(): OmeggaPlayer;
	/**
	 * Get raw player info (to feed into a constructor)
	 */
	raw(): [
		string,
		string,
		string,
		string,
		string
	];
	/**
	 * True if the player is the host
	 */
	isHost(): boolean;
	/**
	 * Clear player's bricks
	 * @param quiet clear bricks quietly
	 */
	clearBricks(quiet?: boolean): void;
	/**
	 * Get player's roles, if any
	 */
	getRoles(): readonly string[];
	/**
	 * Get player's permissions in a map like `{"Bricks.ClearOwn": true, ...}`
	 * @return permissions map
	 */
	getPermissions(): Record<string, boolean>;
	/**
	 * Get player's name color
	 * @return 6 character hex string
	 */
	getNameColor(): string;
	/**
	 * Get the player's pawn; null when the player has no pawn
	 * @return pawn
	 */
	getPawn(): Promise<string | null>;
	/**
	 * Get player's position; null when the player has no pawn
	 * @return [x, y, z] coordinates
	 */
	getPosition(): Promise<[
		number,
		number,
		number
	] | null>;
	/**
	 * Gets a user's ghost brick info (by uuid, name, controller, or player object)
	 * @return ghost brick data
	 */
	getGhostBrick(): Promise<{
		targetGrid: string;
		location: number[];
		orientation: string;
	} | undefined>;
	/**
	 * gets a user's paint tool properties
	 */
	getPaint(): Promise<{
		materialIndex: string;
		materialAlpha: string;
		material: string;
		color: number[];
	} | undefined>;
	/**
	 * gets whether or not the player is crouching
	 */
	isCrouched(pawn?: string): Promise<boolean>;
	/**
	 * gets whether or not the player is dead
	 */
	isDead(pawn?: string): Promise<boolean>;
	/**
	 * Gets the bounds of the template in the user's clipboard (bounds of original selection box)
	 * @return template bounds
	 */
	getTemplateBounds(): Promise<BrickBounds | undefined>;
	/**
	 * Get bricks inside template bounds
	 * @return BRS JS Save Data
	 */
	getTemplateBoundsData(): Promise<ReadSaveObject | undefined>;
	/**
	 * Load bricks at ghost brick location
	 * @param saveData save data to load
	 */
	loadDataAtGhostBrick(saveData: WriteSaveObject, options?: {
		rotate?: boolean;
		offX?: number;
		offY?: number;
		offZ?: number;
		quiet?: boolean;
	}): Promise<void>;
	/**
	 * Load bricks on this player's clipboard
	 * @param saveName Save to load
	 */
	loadBricks(saveName: string): void;
	/**
	 * Load bricks on this player's clipboard passing save data
	 * @param saveData save data to load
	 */
	loadSaveData(saveData: WriteSaveObject, options?: {
		rotate?: boolean;
		offX?: number;
		offY?: number;
		offZ?: number;
		quiet?: boolean;
	}): Promise<void>;
	/**
	 * Kills this player
	 */
	kill(): void;
	/**
	 * Damages a player
	 * @param amount Amount to damage
	 */
	damage(amount: number): void;
	/**
	 * Heal this player
	 * @param amount to heal
	 */
	heal(amount: number): void;
	/**
	 * Gives a player an item
	 * @param item Item name (Weapon_Bow)
	 */
	giveItem(item: WeaponClass): void;
	/**
	 * Removes an item from a player's inventory
	 * @param item Item name (Weapon_Bow)
	 */
	takeItem(item: WeaponClass): void;
	/**
	 * Changes a player's team
	 * @param teamIndex Team index
	 */
	setTeam(teamIndex: number): void;
	/**
	 * Changes a player's minigame
	 * @param index Minigame index
	 */
	setMinigame(index: number): void;
	/**
	 * Changes a player's score
	 * @param minigameIndex minigame index
	 * @param score Score
	 */
	setScore(minigameIndex: number, score: number): void;
	/**
	 * Fetch a player's score
	 * @param minigameIndex minigame index
	 */
	getScore(minigameIndex: number): Promise<number>;
	/**
	 * Set leaderboard value
	 * @param key leaderboard key (Score, Kills, Deaths, CorrectGuesses)
	 * @param value leaderboard value
	 */
	setLeaderboard(key: string, value: number): void;
	/**
	 * Get leaderboard value
	 * @param key leaderboard key (Score, Kills, Deaths, CorrectGuesses)
	 * @return leaderboard value
	 */
	getLeaderboard(key: string): Promise<number | null>;
}
export interface StaticPlayer {
	/**
	 * get a player's roles, if any
	 * @param omegga omegga instance
	 * @param id player uuid
	 * @return list of roles
	 */
	getRoles(omegga: OmeggaLike, id: string): readonly string[];
	/**
	 * get a player's permissions in a map like `{"Bricks.ClearOwn": true, ...}`
	 * @param omegga Omegga instance
	 * @param id player uuid
	 * @return permissions map
	 */
	getPermissions(omegga: OmeggaLike, id: string): Record<string, boolean>;
	/**
	 * Kills a player
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 */
	kill(omegga: OmeggaLike, target: string | OmeggaPlayer): void;
	/**
	 * Damages a player
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param amount Damage amount
	 */
	damage(omegga: OmeggaLike, target: string | OmeggaPlayer, amount: number): void;
	/**
	 * Heal a player
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param amount Heal amount
	 */
	heal(omegga: OmeggaLike, target: string | OmeggaPlayer, amount: number): void;
	/**
	 * Gives a player an item
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param item Item name (Weapon_Bow)
	 */
	giveItem(omegga: OmeggaLike, target: string | OmeggaPlayer, item: WeaponClass): void;
	/**
	 * Removes an item from a player's inventory
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param item Item name (Weapon_Bow)
	 */
	takeItem(omegga: OmeggaLike, target: string | OmeggaPlayer, item: WeaponClass): void;
	/**
	 * Changes a player's team
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param teamIndex Team name? index?
	 */
	setTeam(omegga: OmeggaLike, target: string | OmeggaPlayer, teamIndex: number): void;
	/**
	 * Changes a player's minigame
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param index Minigame index
	 */
	setMinigame(omegga: OmeggaLike, target: string | OmeggaPlayer, index: number): void;
	/**
	 * Changes a player's score
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param minigameIndex minigame index
	 * @param score Score
	 */
	setScore(omegga: OmeggaLike, target: string | OmeggaPlayer, minigameIndex: number, score: number): void;
	/**
	 * Fetches a player's score
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param minigameIndex minigame index
	 */
	getScore(omegga: OmeggaLike, target: string | OmeggaPlayer, minigameIndex: number): Promise<number>;
	/**
	 * Set leaderboard value
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param key leaderboard key (Score, Kills, Deaths, CorrectGuesses)
	 * @param value leaderboard value
	 */
	setLeaderboard(omegga: OmeggaLike, target: string | OmeggaPlayer, key: string, value: number): void;
	/**
	 * Get leaderboard value
	 * @param omegga Omegga instance
	 * @param target Player or player name/id
	 * @param key leaderboard key (Score, Kills, Deaths, CorrectGuesses)
	 * @return leaderboard value
	 */
	getLeaderboard(omegga: OmeggaLike, target: string | OmeggaPlayer, key: string): Promise<number | null>;
}
export interface InjectedCommands {
	/** Get server status */
	getServerStatus(this: OmeggaLike): Promise<IServerStatus | null>;
	/**
	 * Get a list of minigames and their indices
	 * @deprecated minigames were replaced by a single gamemode (~CL14000); on
	 * modern servers this returns at most one entry with an empty `owner`.
	 * Prefer {@link InjectedCommands.getGamemode}.
	 */
	listMinigames(this: OmeggaLike): Promise<IMinigameList>;
	/** Get all player positions and pawns */
	getAllPlayerPositions(this: OmeggaLike): Promise<IPlayerPositions>;
	/** Get minigames and members (one entry per gamemode on modern servers) */
	getMinigames(this: OmeggaLike): Promise<ILogMinigame[]>;
	/**
	 * Get the single gamemode and its teams/players (modern servers, >=CL14000).
	 * Returns null on older servers (use {@link InjectedCommands.getMinigames}).
	 */
	getGamemode(this: OmeggaLike): Promise<IGamemode | null>;
}
/**
 * Event listener shape, mirroring node's EventEmitter. The rest parameter is
 * `any[]` for the same reason node's own is: it is both the type every listener
 * must be assignable to and the type an inline listener's parameters are
 * inferred from, so `unknown[]` would type a custom event's arguments as
 * `unknown` at every call site that does not hit a named overload.
 */
export type MockEventListener = (...args: any[]) => void;
export interface MockEventEmitter {
	addListener(event: string, listener: MockEventListener): this;
	emit(event: string, ...args: unknown[]): boolean;
	eventNames(): (string | symbol)[];
	getMaxListeners(): number;
	listenerCount(event: string): number;
	listeners(event: string): Function[];
	off(event: string, listener: MockEventListener): this;
	on(event: string, listener: MockEventListener): this;
	once(event: string, listener: MockEventListener): this;
	prependListener(event: string, listener: MockEventListener): this;
	prependOnceListener(event: string, listener: MockEventListener): this;
	rawListeners(event: string): Function[];
	removeAllListeners(event?: string): this;
	removeListener(event: string, listener: MockEventListener): this;
	setMaxListeners(maxListeners: number): this;
	on(event: "close", listener: () => void): this;
	on(event: "line", listener: (line: string) => void): this;
	on(event: "start", listener: (info: {
		map: string;
	}) => void): this;
	on(event: "version", listener: (version: number) => void): this;
	on(event: "unauthorized", listener: () => void): this;
	on(event: "join", listener: (player: OmeggaPlayer) => void): this;
	on(event: "leave", listener: (player: OmeggaPlayer) => void): this;
	on(event: "chat", listener: (name: string, message: string) => void): this;
	on(event: "mapchange", listener: (info: {
		map: string;
	}) => void): this;
	on(event: "autorestart", listener: (config: AutoRestartConfig) => void): this;
	on(event: "interact", listener: (interaction: BrickInteraction) => void): this;
	on(event: "minigamejoin", listener: (info: {
		player: {
			name: string;
			id: string;
		};
		minigameName: string;
	}) => void): this;
	on(event: "wirelog", listener: (raw: string) => void): this;
	on(event: `wirecmd:${string}`, listener: (...args: string[]) => void): this;
	on(event: "wirecmd", listener: (cmd: string, ...args: string[]) => void): this;
}
export interface OmeggaLike extends OmeggaCore, LogWrangling, InjectedCommands, MockEventEmitter {
	writeln(line: string): void;
	/** game CL version*/
	version: number;
	/**
	 * version-resolved Brickadia console command names, nested by namespace.
	 * e.g. `Omegga.Console.Bricks.Clear` resolves to the command string for the
	 * running game version ("Bricks.Clear" or "br.Bricks.Clear")
	 */
	Console: ConsoleCommands;
	/** verbose logging is enabled*/
	verbose: boolean;
	/** list of players */
	players: OmeggaPlayer[];
	/** server host */
	host?: {
		id: string;
		name: string;
	};
	/** server is started */
	started: boolean;
	/** server is starting */
	starting: boolean;
	/** server is stopping */
	stopping: boolean;
	/** current map */
	currentMap: string;
	/** path to config files */
	configPath: string;
	/** path to saves */
	savePath: string;
	/** path to worlds */
	worldPath: string;
	/** path to prefabs */
	prefabPath: string;
	/** path to presets */
	presetPath: string;
	/** path to containing dir */
	path: string;
	/**
	 * path to the directory containing the game server binary - null when the
	 * install is launcher-managed and the binary location isn't known
	 */
	binaryPath: string | null;
	/** get a plugin's name, documentation, and loaded status
	 * If run in an unsafe plugin, the emitPlugin method sends events from
	 * an "unsafe" plugin
	 */
	getPlugin(name: string): Promise<PluginInterop | null>;
}
export interface OmeggaCore {
	/**
	 * get a list of players
	 * @return list of players {id: uuid, name: name} objects
	 */
	getPlayers(): {
		id: string;
		name: string;
		displayName: string;
		controller: string;
		state: string;
	}[];
	/**
	 * find a player by name, id, controller, or state
	 * @param target - name, id, controller, or state
	 */
	getPlayer(target: string): OmeggaPlayer | null;
	/**
	 * find a player by rough name, prioritize exact matches and get fuzzier
	 * @param name player name, fuzzy
	 */
	findPlayerByName(name: string): OmeggaPlayer | null;
	/**
	 * get the host's ID
	 * @return Host Id
	 */
	getHostId(): string;
	/**
	 * broadcast messages to chat
	 * messages are broken by new line
	 * multiple arguments are additional lines
	 * all messages longer than 512 characters are deleted automatically, though omegga wouldn't have sent them anyway
	 * @param messages unescaped chat messages to send. may need to wrap messages with quotes
	 */
	broadcast(...messages: string[]): void;
	/**
	 * whisper messages to a player's chat
	 * messages are broken by new line
	 * multiple arguments are additional lines
	 * all messages longer than 512 characters are deleted automatically, though omegga wouldn't have sent them anyway
	 * @param target - player identifier or player object
	 * @param messages - unescaped chat messages to send. may need to wrap messages with quotes
	 */
	whisper(target: string | OmeggaPlayer, ...messages: string[]): void;
	/**
	 * prints text to the middle of a player's screen
	 * all messages longer than 512 characters are deleted automatically
	 * @param target - player identifier or player object
	 * @param message - unescaped chat messages to send. may need to wrap messages with quotes
	 */
	middlePrint(target: string | OmeggaPlayer, message: string): void;
	/**
	 * Save a minigame preset based on a minigame index
	 * @param index minigame index
	 * @param name preset name
	 */
	saveMinigame(index: number, name: string): void;
	/**
	 * Delete a minigame
	 * @param index minigame index
	 */
	deleteMinigame(index: number): void;
	/**
	 * Reset a minigame
	 * @param index minigame index
	 */
	resetMinigame(index: number): void;
	/**
	 * Force the next round in a minigame
	 * @param index minigame index
	 */
	nextRoundMinigame(index: number): void;
	/**
	 * Load an Minigame preset
	 * @param presetName preset name
	 * @param owner owner id/name
	 */
	loadMinigame(presetName: string, owner?: string): void;
	/**
	 * Get all presets in the minigame folder and child folders
	 */
	getMinigamePresets(): string[];
	/**
	 * Reset the environment settings
	 */
	resetEnvironment(): void;
	/**
	 * Save an environment preset
	 * @param presetName preset name
	 */
	saveEnvironment(presetName: string): Promise<void>;
	/** Save a temporary environment preset and return its contents */
	getEnvironmentData(): Promise<EnvironmentPreset | null>;
	/**
	 * Read environment data as json; null when the preset is missing or invalid
	 * @param presetName preset name
	 */
	readEnvironmentData(presetName: string): EnvironmentPreset | null;
	/**
	 * Load an environment preset
	 * @param presetName preset name
	 */
	loadEnvironment(presetName: string): void;
	/**
	 * Load some environment preset data
	 * @param preset preset data
	 */
	loadEnvironmentData(preset: EnvironmentPreset | NonNullable<EnvironmentPreset["data"]>["groups"]): void;
	/**
	 * Get all presets in the environment folder and child folders
	 */
	getEnvironmentPresets(): string[];
	/**
	 * Clear a user's bricks (by uuid, name, controller, or player object)
	 * @param target player or player identifier
	 * @param quiet quietly clear bricks
	 */
	clearBricks(target: string | {
		id: string;
	}, quiet?: boolean): void;
	/**
	 * Clear a region of bricks. On EA3 this routes to `br.World.ClearRegion`
	 * and can optionally clear entities too.
	 * @param region region to clear
	 * @param options optional settings
	 */
	clearRegion(region: {
		center: [
			number,
			number,
			number
		];
		extent: [
			number,
			number,
			number
		];
	}, options?: {
		target?: string | OmeggaPlayer;
		/** clear bricks in the region (default true) */
		bricks?: boolean;
		/** also clear entities in the region (default false, EA3 only) */
		entities?: boolean;
	}): void;
	/**
	 * Clear all bricks on the server. On EA3 this routes to
	 * `br.World.ClearAll` and can optionally clear entities too. A bare boolean
	 * is accepted as the legacy `quiet` argument.
	 * @param options quiet (or `{ quiet, bricks, entities }`)
	 */
	clearAllBricks(options?: boolean | {
		quiet?: boolean;
		bricks?: boolean;
		entities?: boolean;
	}): void;
	/**
	 * Save bricks under a filename
	 * @param saveName save file name
	 * @param region region of bricks to save
	 * @deprecated removed in Brickadia EA3 (no-op on newer servers) - save a
	 * prefab with {@link savePrefabRegion} instead
	 */
	saveBricks(saveName: string, region?: {
		center: [
			number,
			number,
			number
		];
		extent: [
			number,
			number,
			number
		];
	}): void;
	/**
	 * Save bricks under a filename, with a promise
	 * @param saveName save file name
	 * @param region region of bricks to save
	 * @deprecated removed in Brickadia EA3 (no-op on newer servers) - save a
	 * prefab with {@link savePrefabRegion} instead
	 */
	saveBricksAsync(saveName: string, region?: {
		center: [
			number,
			number,
			number
		];
		extent: [
			number,
			number,
			number
		];
	}): Promise<void>;
	/**
	 * Load bricks on the server
	 * @deprecated removed in Brickadia EA3 (no-op on newer servers) - load a
	 * prefab with {@link loadPrefab} instead
	 */
	loadBricks(saveName: string, options?: {
		offX?: number;
		offY?: number;
		offZ?: number;
		quiet?: boolean;
		correctPalette?: boolean;
		correctCustom?: boolean;
	}): void;
	/**
	 * Load bricks on the server into a player's clipbaord
	 * @deprecated removed in Brickadia ~EA2 (no-op on newer servers) - use
	 * {@link loadPrefabOnPlayer} instead
	 */
	loadBricksOnPlayer(saveName: string, player: string | OmeggaPlayer, options?: {
		offX?: number;
		offY?: number;
		offZ?: number;
		correctPalette?: boolean;
		correctCustom?: boolean;
	}): void;
	/**
	 * Get all saves in the save folder and child folders
	 */
	getSaves(): string[];
	/**
	 * Checks if a save exists and returns an absolute path
	 * @param saveName Save filename
	 * @return Path to string, undefined if the save does not exist
	 */
	getSavePath(saveName: string): string | undefined;
	/**
	 * Get all worlds in the worlds folder and child folders
	 */
	getWorlds(): string[];
	/**
	 * Checks if a world exists and returns an absolute path
	 * @param worldName World name
	 * @return Path to string, undefined if the world does not exist
	 */
	getWorldPath(worldName: string): string | undefined;
	/**
	 * Get a list of revisions for a world
	 * @param worldName World name
	 */
	getWorldRevisions(worldName: string): Promise<{
		index: number;
		date: Date;
		note: string;
	}[]>;
	/**
	 * Load a world by its name
	 * @param worldName World name
	 */
	loadWorld(worldName: string): Promise<boolean>;
	/**
	 * Load a world at a specific revision
	 * @param worldName World name
	 */
	loadWorldRevision(worldName: string, revision: number): Promise<boolean>;
	/**
	 * Save a world as a new name
	 * @param worldName World name
	 */
	saveWorldAs(worldName: string): Promise<boolean>;
	/**
	 * Save the current world
	 */
	saveWorld(): Promise<boolean>;
	/**
	 * Create an empty world with the given name
	 */
	createEmptyWorld(worldName: string): Promise<boolean>;
	/**
	 * unsafely load save data (wrap in try/catch)
	 * @param saveName save file name
	 * @param saveData BRS JS Save data
	 */
	writeSaveData(saveName: string, saveData: WriteSaveObject): void;
	/**
	 * unsafely read save data (wrap in try/catch)
	 * @param saveName save file name
	 * @param nobricks only read save header data
	 * @return BRS JS Save Data
	 */
	readSaveData(saveName: string, nobricks?: boolean): ReadSaveObject;
	/**
	 * load bricks from save data and resolve when game finishes loading
	 * @param saveData BRS JS Save data
	 * @deprecated removed in Brickadia EA3 (no-op on newer servers) - use the
	 * prefab API ({@link loadPrefab}) instead
	 */
	loadSaveData(saveData: WriteSaveObject, options?: {
		offX?: number;
		offY?: number;
		offZ?: number;
		quiet?: boolean;
		correctPalette?: boolean;
		correctCustom?: boolean;
	}): Promise<void>;
	/**
	 * load bricks from save data and resolve when game finishes loading
	 * @param saveData BRS JS Save data
	 * @param player Player name/id or player object
	 * @deprecated removed in Brickadia ~EA2 (no-op on newer servers) - use the
	 * prefab API ({@link loadPrefabOnPlayer}) instead
	 */
	loadSaveDataOnPlayer(saveData: WriteSaveObject, player: string | OmeggaPlayer, options?: {
		offX?: number;
		offY?: number;
		offZ?: number;
		correctPalette?: boolean;
		correctCustom?: boolean;
	}): Promise<void>;
	/**
	 * get current bricks as save data
	 * @deprecated removed in Brickadia EA3 (returns undefined on newer
	 * servers) - use the prefab API instead
	 */
	getSaveData(region?: {
		center: [
			number,
			number,
			number
		];
		extent: [
			number,
			number,
			number
		];
	}): Promise<ReadSaveObject | undefined>;
	/**
	 * Get all prefabs in the prefabs folder and child folders (EA3)
	 */
	getPrefabs(): string[];
	/**
	 * Checks if a prefab exists and returns an absolute path (EA3)
	 * @param prefabName Prefab filename
	 * @return Path to string
	 */
	getPrefabPath(prefabName: string): string | undefined;
	/**
	 * Load a prefab into the world (EA3). `path` is a bundle path ref such
	 * as `Prefabs/Uploads/<hash>.brz`.
	 * @param path prefab bundle path ref
	 * @param options placement options (offset, orientation, mirror axes, etc)
	 */
	loadPrefab(path: string, options?: {
		offX?: number;
		offY?: number;
		offZ?: number;
		atOriginalPosition?: boolean;
		orientation?: number;
		rootEntityPersistentIndex?: number;
		/** bitmask: X=1 Y=2 Z=4 (e.g. 3 mirrors X and Y) */
		mirrorAxes?: number;
		overrideUserId?: string;
	}): void;
	/**
	 * Save the world (or a region of it) as a prefab (EA3).
	 * @param path destination prefab bundle path ref (e.g. `Prefabs/MyPrefab.brz`)
	 * @param options save options; omit `region` to capture the whole world
	 */
	savePrefab(path: string, options?: {
		region?: {
			center: [
				number,
				number,
				number
			];
			extent: [
				number,
				number,
				number
			];
		};
		entities?: boolean;
		rootEntityPersistentIndex?: number;
		userId?: string;
	}): void;
	/**
	 * Save a prefab and resolve once the prefab file has been written to disk
	 * (EA3).
	 * @param path destination prefab bundle path ref
	 * @param options same options as {@link savePrefab}
	 * @returns absolute path to the written prefab, or null on timeout
	 */
	savePrefabAsync(path: string, options?: {
		region?: {
			center: [
				number,
				number,
				number
			];
			extent: [
				number,
				number,
				number
			];
		};
		entities?: boolean;
		rootEntityPersistentIndex?: number;
		userId?: string;
	}): Promise<string | null>;
	/**
	 * Give a prefab to a player's inventory (EA3).
	 * @param path prefab bundle path ref
	 * @param player player name/id or player object
	 * @param options give options (preserve ownership)
	 */
	givePrefabToPlayer(path: string, player: string | OmeggaPlayer, options?: {
		preserveOwnership?: boolean;
	}): void;
	/**
	 * Load a prefab onto a player (EA3, replaces {@link loadBricksOnPlayer}).
	 * @param path prefab bundle path ref
	 * @param player player name/id or player object
	 * @param options give options (preserve ownership)
	 */
	loadPrefabOnPlayer(path: string, player: string | OmeggaPlayer, options?: {
		preserveOwnership?: boolean;
	}): void;
	/**
	 * Change server map
	 * @param map Map name
	 */
	changeMap(map: string): Promise<boolean>;
	/**
	 * Get up-to-date role setup from RoleSetup.json
	 */
	getRoleSetup(): BRRoleSetup;
	/**
	 * Get up-to-date role assignments from RoleAssignment.json
	 */
	getRoleAssignments(): BRRoleAssignments;
	/**
	 * Get up-to-date ban list from BanList.json
	 */
	getBanList(): BRBanList;
	/**
	 * Get up-to-date name cache from PlayerNameCache.json
	 */
	getNameCache(): BRPlayerNameCache;
}
/** A simple document store for plugins */
export interface PluginStore<Storage extends Record<string, unknown> = Record<string, unknown>> {
	/** Get a value from plugin storage */
	get<T extends keyof Storage>(key: T): Promise<Storage[T]>;
	/** Set a value to plugin storage */
	set<T extends keyof Storage>(key: T, value: Storage[T]): Promise<void>;
	/** Delete a value from plugin storage */
	delete(key: string): Promise<void>;
	/** Wipe all values in plugin storage */
	wipe(): Promise<void>;
	/** Count entries in plugin storage */
	count(): Promise<number>;
	/** Get a list of keys in plugin storage */
	keys(): Promise<(keyof Storage)[]>;
}
/** A config representative of the config outlined in doc.json */
export type PluginConfig<T extends Record<string, unknown> = Record<string, unknown>> = T;
/** Label values attached to a plugin metric */
export type PluginMetricLabels = Record<string, string | number | boolean>;
/** Options common to every plugin metric */
export interface PluginMetricOptions {
	/**
	 * Metric name, exported as `omegga_plugin_<plugin>_<name>`. Must be
	 * lowercase letters, digits, and underscores.
	 */
	name: string;
	/** One-line description, shown in the scrape output */
	help?: string;
	/** Label names this metric may use (`plugin` is added automatically) */
	labels?: string[];
}
/** A value that only ever increases, such as a number of events */
export interface MetricCounter {
	/** Add to the count (default 1), optionally on a labelled series */
	inc(value?: number): void;
	inc(labels: PluginMetricLabels, value?: number): void;
	/** Discard every series */
	reset(): void;
}
/** A value that can go up and down, such as a queue length */
export interface MetricGauge {
	set(value: number): void;
	set(labels: PluginMetricLabels, value: number): void;
	inc(value?: number): void;
	inc(labels: PluginMetricLabels, value?: number): void;
	dec(value?: number): void;
	dec(labels: PluginMetricLabels, value?: number): void;
	/** Stop exporting one labelled series */
	remove(labels?: PluginMetricLabels): void;
	/**
	 * Produce the value on demand instead of setting it. The callback runs when
	 * the metric is collected, which is cheaper than setting it on a timer.
	 */
	collect(fn: () => number | void): void;
	reset(): void;
}
/** Bucketed observations, such as durations */
export interface MetricHistogram {
	observe(value: number): void;
	observe(labels: PluginMetricLabels, value: number): void;
	/** Start a timer; call the returned function to observe elapsed seconds */
	startTimer(labels?: PluginMetricLabels): () => number;
	reset(): void;
}
/**
 * Prometheus metrics for a plugin, exported under `omegga_plugin_<plugin>_`.
 *
 * Handles are always returned, so no guards are needed: when the metrics
 * endpoint is disabled every call is a no-op.
 */
export interface PluginMetrics {
	/** Whether the metrics endpoint is enabled; handles work either way */
	readonly enabled: boolean;
	counter(opts: PluginMetricOptions): MetricCounter;
	gauge(opts: PluginMetricOptions): MetricGauge;
	histogram(opts: PluginMetricOptions & {
		/** Upper bounds in ascending order; `+Inf` is added automatically */
		buckets?: number[];
	}): MetricHistogram;
}
/** An omegga plugin */
export declare abstract class OmeggaPlugin<Config extends Record<string, unknown> = Record<string, unknown>, Storage extends Record<string, unknown> = Record<string, unknown>> {
	omegga: OmeggaLike;
	config: PluginConfig<Config>;
	store: PluginStore<Storage>;
	/**
	 * Prometheus metrics for this plugin; no-ops when metrics are disabled.
	 *
	 * Always supplied by the plugin loader. It is declared optional purely so
	 * that plugins written before metrics existed still satisfy
	 * `implements OmeggaPlugin`. Declare `metrics: PM` on your own class, as
	 * the templates do for `omegga`, `config`, and `store`, to get the
	 * non-optional type.
	 */
	metrics?: PluginMetrics;
	constructor(omegga: OmeggaLike, config: PluginConfig<Config>, store: PluginStore<Storage>, metrics: PluginMetrics);
	/** Run when plugin starts, returns /commands it uses */
	abstract init(): Promise<void | {
		registeredCommands?: string[];
	}>;
	/** Run when plugin is stopped */
	abstract stop(): Promise<void>;
	/** Run when another plugin tries to interact with this plugin
	 * @param event Event name
	 * @param from Name of origin plugin
	 * @return value other plugin expects
	 */
	abstract pluginEvent?(event: string, from: string, ...args: unknown[]): Promise<unknown>;
}
export interface LogWrangling {
	/** Add a passive pattern on console output that invokes callback on match */
	addMatcher<T>(pattern: IMatcher<T>["pattern"], callback: IMatcher<T>["callback"]): void;
	/**
	 * Run an active pattern on console output that resolves a match.
	 * T is the element type of the resolved matches - RegExpMatchArray for
	 * RegExp patterns, the pattern's return type for function patterns.
	 */
	addWatcher<T = RegExpMatchArray>(pattern: IWatcher<T>["pattern"], options?: {
		timeoutDelay?: number;
		bundle?: boolean;
		debounce?: boolean;
		afterMatchDelay?: number;
		last?: IWatcher<T>["last"];
		exec?: () => void;
	}): Promise<T[]>;
	/**
	 * Run a command and capture bundled output.
	 * T is the element type of the resolved matches - RegExpMatchArray for
	 * RegExp patterns, the pattern's return type for function patterns.
	 */
	watchLogChunk<T = RegExpMatchArray>(cmd: string, pattern: IWatcher<T>["pattern"], options?: {
		first?: "index" | ((match: T) => boolean);
		last?: IWatcher<T>["last"];
		afterMatchDelay?: number;
		timeoutDelay?: number;
	}): Promise<T[]>;
	/** Run a command and capture bundled output for array functions */
	watchLogArray<Item extends Record<string, string> = Record<string, string>, Member extends Record<string, string> = Record<string, string>>(cmd: string, itemPattern: RegExp, memberPattern: RegExp): Promise<{
		item: Item;
		members: Member[];
	}[]>;
}
export type WatcherPattern<T> = (line: string, match: RegExpMatchArray | null) => T | RegExpMatchArray | null | undefined | "[OMEGGA_WATCHER_DONE]";
export type IMatcher<T> = {
	pattern: RegExp;
	callback: (match: RegExpMatchArray) => boolean;
} | {
	pattern: (line: string, match: RegExpMatchArray | null) => T;
	callback: (match: RegExpMatchArray) => T;
};
export type IWatcher<T> = {
	bundle: boolean;
	debounce: boolean;
	timeoutDelay: number;
	afterMatchDelay: number;
	last: (match: T) => boolean;
	callback: () => void;
	resolve: (...args: T[]) => void;
	remove: () => void;
	done: () => void;
	timeout: ReturnType<typeof setTimeout>;
} & ({
	pattern: WatcherPattern<T>;
	matches: T[];
} | {
	pattern: RegExp;
	matches: RegExpMatchArray[];
});
export declare type IPluginConfigDefinition = {
	description: string;
} & ({
	type: "string" | "password" | "role";
	default: string;
} | {
	type: "boolean";
	default: boolean;
} | {
	type: "number";
	default: number;
} | {
	type: "enum";
	options: (string | number)[];
	default: string | number;
} | {
	type: "players";
	default: {
		id: string;
		name: string;
	};
} | ({
	type: "list";
} & ({
	itemType: "string";
	default: string[];
} | {
	itemType: "number";
	default: number[];
} | {
	itemType: "enum";
	options: (string | number)[];
	default: string | number;
})));
export interface IPluginCommandArgument {
	name: string;
	description: string;
	required?: boolean;
}
export interface IPluginCommand {
	name: string;
	description: string;
	example?: string;
	args: IPluginCommandArgument[];
}
export interface IPluginDocumentation {
	name: string;
	description: string;
	author: string;
	config: Record<string, IPluginConfigDefinition>;
	commands: IPluginCommand[];
}
export interface PluginInterop {
	name: string;
	documentation: IPluginDocumentation | null;
	loaded: boolean;
	emitPlugin?(event: string, args: unknown[]): Promise<unknown>;
}
export type WeaponClass = "Weapon_APCarbine" | "Weapon_AntiMaterielRifle" | "Weapon_ArmingSword" | "Weapon_AssaultRifle" | "Weapon_AutoShotgun" | "Weapon_Battleaxe" | "Weapon_Bazooka" | "Weapon_BoltActionRifle" | "Weapon_Bow" | "Weapon_BoxPistol" | "Weapon_BullpupRifle" | "Weapon_BullpupSMG" | "Weapon_ChargedLongsword" | "Weapon_CrystalKalis" | "Weapon_Derringer" | "Weapon_Dynamite" | "Weapon_FlintlockPistol" | "Weapon_GrenadeLauncher" | "Weapon_GuardPistol" | "Weapon_Handaxe" | "Weapon_HealthPotion" | "Weapon_HeavyAssaultRifle" | "Weapon_HeavySMG" | "Weapon_HeroSword" | "Weapon_HighPowerPistol" | "Weapon_HoloBlade" | "Weapon_HuntingShotgun" | "Weapon_Ikakalaka" | "Weapon_ImpactGrenade" | "Weapon_ImpactGrenadeLauncher" | "Weapon_ImpulseGrenade" | "Weapon_Khopesh" | "Weapon_Knife" | "Weapon_LeverActionRifle" | "Weapon_LightMachineGun" | "Weapon_LongSword" | "Weapon_MagnumPistol" | "Weapon_MicroSMG" | "Weapon_Minigun" | "Weapon_Minigun" | "Weapon_MissileLauncher" | "Weapon_PDW" | "Weapon_Pickaxe" | "Weapon_PipeBomb" | "Weapon_Pistol" | "Weapon_PlasmaPistol" | "Weapon_PlasmaSMG" | "Weapon_PulseCarbine" | "Weapon_PulseRifle" | "Weapon_QuadLauncher" | "Weapon_Revolver" | "Weapon_RocketJumper" | "Weapon_RocketLauncher" | "Weapon_Sabre" | "Weapon_SemiAutoRifle" | "Weapon_ServiceRifle" | "Weapon_Shotgun" | "Weapon_SlugShotgun" | "Weapon_Sniper" | "Weapon_SodaCan" | "Weapon_Spatha" | "Weapon_SportingShotgun" | "Weapon_StampedSMG" | "Weapon_StandardSubmachineGun" | "Weapon_StickGrenade" | "Weapon_SubmachineGun" | "Weapon_SuperShotgun" | "Weapon_SuppressedAssaultRifle" | "Weapon_SuppressedBullpupSMG" | "Weapon_SuppressedGuardPistol" | "Weapon_SuppressedHeavySMG" | "Weapon_SuppressedMicroSMG" | "Weapon_SuppressedPistol" | "Weapon_SuppressedServiceRifle" | "Weapon_TacticalSMG" | "Weapon_TacticalShotgun" | "Weapon_Tomahawk" | "Weapon_TwinCannon" | "Weapon_TypewriterSMG" | "Weapon_Zweihander";

export {
	OmeggaPlugin as default,
};

export {};