@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/export/CocosExporter.d.ts

@@ -0,0 +1,40 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface CocosExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Cocos Creator version (e.g., '3.8', '3.7') */
+        engineVersion?: string;
+        /** Use 2D or 3D mode */
+        mode?: '2d' | '3d';
+        /** Bundle name for generated scripts */
+        bundleName?: string;
+        /** Generate TypeScript (vs JavaScript) */
+        useTypeScript?: boolean;
+        /** Physics engine (builtin, box2d, cannon) */
+        physicsEngine?: 'builtin' | 'box2d' | 'cannon';
+    };
+}
+export declare class CocosExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private uuidMap;
+    private engineVersion;
+    private useTypeScript;
+    private is2D;
+    protected doExport(project: NiceProject, options: CocosExportOptions): Promise<void>;
+    private generateProjectConfig;
+    private generateScripts;
+    private generateGameManager;
+    private generateEntityScript;
+    private exportScene;
+    private buildSceneData;
+    private buildNodeData;
+    private convertPropertyValue;
+    private exportPrefab;
+    private buildPrefabData;
+    private exportAsset;
+    private exportAnimationClip;
+    private generateMetaFile;
+    private getImporterType;
+    private getOrCreateUUID;
+}
+export declare function createCocosExporter(): CocosExporter;

package/dist/types/export/Construct3Exporter.d.ts

@@ -0,0 +1,38 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Construct3ExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Export as addon/behavior instead of full project */
+        exportAsAddon?: boolean;
+        /** Addon ID (if exportAsAddon) */
+        addonId?: string;
+        /** Use Construct's built-in physics */
+        useBuiltInPhysics?: boolean;
+        /** Target runtime version */
+        runtimeVersion?: string;
+        /** Generate JavaScript behaviors */
+        generateBehaviors?: boolean;
+        /** Generate JavaScript plugins */
+        generatePlugins?: boolean;
+    };
+}
+export declare class Construct3Exporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectId;
+    private uidCounter;
+    protected doExport(project: NiceProject, options: Construct3ExportOptions): Promise<void>;
+    private exportAsProject;
+    private generateProjectFile;
+    private collectObjectTypes;
+    private generateObjectTypes;
+    private generateObjectType;
+    private mapProperties;
+    private exportLayout;
+    private entityToInstance;
+    private generateEventSheet;
+    private generateEntityEvents;
+    private generateScripts;
+    private exportAsAddon;
+    private generateReadme;
+}
+export declare function createConstruct3Exporter(): Construct3Exporter;

package/dist/types/export/DefoldExporter.d.ts

@@ -0,0 +1,35 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface DefoldExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Target platforms */
+        platforms?: ('windows' | 'macos' | 'linux' | 'ios' | 'android' | 'html5')[];
+        /** Use physics 2D */
+        usePhysics2D?: boolean;
+        /** Use physics 3D */
+        usePhysics3D?: boolean;
+        /** Generate HTML5 manifest */
+        html5Manifest?: boolean;
+        /** Include native extension stubs */
+        nativeExtensions?: boolean;
+    };
+}
+export declare class DefoldExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: DefoldExportOptions): Promise<void>;
+    private generateProjectFile;
+    private generateMainCollection;
+    private exportScene;
+    private entityToEmbeddedInstance;
+    private generateGameObject;
+    private generateEntityScript;
+    private getComponentProperty;
+    private generateSpriteDefinition;
+    private generateCollisionObject;
+    private exportPrefab;
+    private generateSceneScript;
+    private generateSharedScripts;
+    private generateAppManifest;
+    private generateReadme;
+}
+export declare function createDefoldExporter(): DefoldExporter;

package/dist/types/export/GDevelopExporter.d.ts

@@ -0,0 +1,35 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface GDevelopExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** GDevelop version target */
+        version?: '5.0' | '5.1' | '5.2' | '5.3';
+        /** Include P2P multiplayer setup */
+        includeMultiplayer?: boolean;
+        /** Generate JavaScript events */
+        useJavaScriptEvents?: boolean;
+        /** Include leaderboard setup */
+        includeLeaderboards?: boolean;
+        /** Generate custom extensions */
+        generateExtensions?: boolean;
+    };
+}
+export declare class GDevelopExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectUUID;
+    private zOrderCounter;
+    protected doExport(project: NiceProject, options: GDevelopExportOptions): Promise<void>;
+    private generateProject;
+    private collectGlobalObjects;
+    private entityToGDObject;
+    private generateLayout;
+    private entityToGDInstance;
+    private generateSceneEvents;
+    private generateEntityEvents;
+    private generateGlobalVariables;
+    private collectResources;
+    private createNice2DevExtension;
+    private generateNice2DevExtension;
+    private generateReadme;
+}
+export declare function createGDevelopExporter(): GDevelopExporter;

package/dist/types/export/GameMakerExporter.d.ts

@@ -0,0 +1,43 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface GameMakerExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** GameMaker version (e.g., '2024.2', '2023.8') */
+        version?: string;
+        /** Use GML Visual (drag and drop) in addition to GML code */
+        useGmlVisual?: boolean;
+        /** Target runtime (VM or YYC) */
+        targetRuntime?: 'vm' | 'yyc';
+        /** Default sprite origin */
+        spriteOrigin?: 'top-left' | 'center' | 'bottom-center';
+        /** Physics world enabled */
+        enablePhysics?: boolean;
+    };
+}
+export declare class GameMakerExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectName;
+    private resourceTree;
+    private objectScripts;
+    protected doExport(project: NiceProject, options: GameMakerExportOptions): Promise<void>;
+    private generateProjectFile;
+    private generateFolderStructure;
+    private createFolder;
+    private generateScripts;
+    private generateObjects;
+    private findEntityByType;
+    private generateBaseObject;
+    private generateObjectFromEntity;
+    private generateEventList;
+    private extractEntityProperties;
+    private getGMLVarType;
+    private valueToGML;
+    private generateEventScripts;
+    private generateComponentInit;
+    private colorToGML;
+    private generateRoom;
+    private createTileLayer;
+    private generateSprite;
+    private generateSound;
+}
+export declare function createGameMakerExporter(): GameMakerExporter;

package/dist/types/export/MinecraftBedrockExporter.d.ts

@@ -0,0 +1,34 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface MinecraftBedrockExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Minimum Minecraft engine version */
+        minEngineVersion?: [number, number, number];
+        /** Pack version */
+        packVersion?: [number, number, number];
+        /** Enable experimental features */
+        experimentalGameplay?: boolean;
+        /** Generate scripting API files */
+        generateScripts?: boolean;
+        /** Script API version */
+        scriptApiVersion?: '@minecraft/server' | '@minecraft/server-gametest';
+        /** World template format */
+        worldTemplate?: boolean;
+        /** Include texture assets */
+        includeTextures?: boolean;
+    };
+}
+export declare class MinecraftBedrockExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectName;
+    private namespace;
+    private resourcePackUUID;
+    private behaviorPackUUID;
+    protected doExport(project: NiceProject, options: MinecraftBedrockExportOptions): Promise<void>;
+    private generateResourcePack;
+    private generateBehaviorPack;
+    private generateScripts;
+    private exportPrefab;
+    private exportScene;
+}
+export declare function createMinecraftBedrockExporter(): MinecraftBedrockExporter;

package/dist/types/export/MonoGameExporter.d.ts

@@ -0,0 +1,71 @@
+import type { ExportConfig, GameProject } from './PlatformExporter';
+export interface MonoGameExportConfig extends ExportConfig {
+    /** Target framework */
+    framework: 'monogame' | 'fna';
+    /** MonoGame version */
+    monogameVersion: '3.8.1' | '3.8.2';
+    /** Target platform template */
+    targetPlatform: 'DesktopGL' | 'WindowsDX' | 'UWP' | 'Android' | 'iOS';
+    /** Use extended content pipeline */
+    extendedPipeline: boolean;
+    /** Generate design-time content */
+    designTimeContent: boolean;
+    /** Use entity component system (MonoGame.Extended) */
+    useECS: boolean;
+    /** Use Nez framework */
+    useNez: boolean;
+    /** Use tilemaps */
+    useTilemaps: boolean;
+    /** Namespace for generated code */
+    namespace: string;
+    /** Solution name */
+    solutionName: string;
+}
+export declare const DEFAULT_MONOGAME_CONFIG: MonoGameExportConfig;
+export declare class MonoGameExporter {
+    private config;
+    private csharpFiles;
+    private contentFiles;
+    private assets;
+    constructor(config?: Partial<MonoGameExportConfig>);
+    /** Export game project to MonoGame */
+    export(project: GameProject): Promise<{
+        success: boolean;
+        outputPath: string | undefined;
+        files: {
+            path: string;
+            content: string;
+            type: "source";
+        }[];
+        assets: {
+            path: string;
+            type: "asset";
+            originalPath: string;
+        }[];
+        stats: {
+            duration: number;
+            fileCount: number;
+            assetCount: number;
+        };
+        errors?: undefined;
+    } | {
+        success: boolean;
+        errors: string[];
+        outputPath?: undefined;
+        files?: undefined;
+        assets?: undefined;
+        stats?: undefined;
+    }>;
+    private generateSolution;
+    private generateCsproj;
+    private generateGame1;
+    private generateECSInitialization;
+    private generateComponents;
+    private generateEntities;
+    private generateSystems;
+    private generateScreens;
+    private generateContentMgcb;
+    private collectAssets;
+    private generateGuid;
+    private toPascalCase;
+}

package/dist/types/export/Pico8Exporter.d.ts

@@ -0,0 +1,40 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Pico8ExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Optimize for token count */
+        optimizeTokens?: boolean;
+        /** Include debug tools */
+        includeDebug?: boolean;
+        /** Generate sprite sheet placeholder */
+        spriteSheet?: boolean;
+        /** Generate sfx placeholder */
+        sfxPlaceholders?: boolean;
+        /** Include music patterns */
+        musicPatterns?: boolean;
+    };
+}
+export declare class Pico8Exporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: Pico8ExportOptions): Promise<void>;
+    private generateCartridge;
+    private generateCode;
+    private generateCoreFunctions;
+    private generateEntitySystem;
+    private generateEntityDefinitions;
+    private entityTypeToLua;
+    private getEntitySpriteIndex;
+    private getComponentProperty;
+    private generateSceneSetup;
+    private generateUtilityFunctions;
+    private generateDebugOverlay;
+    private generateGfxSection;
+    private generateGffSection;
+    private generateMapSection;
+    private generateSfxSection;
+    private generateMusicSection;
+    private generateLuaSource;
+    private getClosestPico8Color;
+    private generateReadme;
+}
+export declare function createPico8Exporter(): Pico8Exporter;

package/dist/types/export/PlatformExporter.d.ts

@@ -1,5 +1,13 @@
 import type { ScriptGraph } from '../scripting/NodeGraph';
-export type PlatformId = 'unity' | 'godot' | 'unreal' | 'pixijs' | 'phaser' | 'threejs' | 'cocos' | 'gamemaker' | 'roblox' | 'minecraft' | 'rpgmaker' | 'construct3' | 'gdevelop' | 'defold' | 'solar2d' | 'pico8' | 'tic80' | 'web-generic';
+/** Generic base config for platform exporters. */
+export interface ExportConfig {
+    outputPath?: string;
+    assetPath?: string;
+    projectName?: string;
+    [key: string]: unknown;
+}
+/** Generic exporter result. */
+export type PlatformId = 'unity' | 'godot' | 'unreal' | 'pixijs' | 'phaser' | 'threejs' | 'cocos' | 'gamemaker' | 'roblox' | 'minecraft' | 'rpgmaker' | 'construct3' | 'gdevelop' | 'defold' | 'solar2d' | 'pico8' | 'tic80' | 'web-generic' | (string & {});
 export interface PlatformInfo {
     id: PlatformId;
     name: string;
@@ -10,8 +18,8 @@ export interface PlatformInfo {
     supportedAssets: AssetType[];
     exportFormats: string[];
 }
-export type PlatformFeature = '2d-rendering' | '3d-rendering' | 'physics-2d' | 'physics-3d' | 'audio' | 'networking' | 'ui-system' | 'visual-scripting' | 'tilemaps' | 'particles' | 'animation' | 'vr-ar';
-export type AssetType = 'sprite' | 'tileset' | 'audio' | 'font' | 'script' | 'scene' | 'prefab' | 'material' | 'shader' | 'animation' | 'tilemap' | 'particleSystem' | 'texture' | 'data';
+export type PlatformFeature = '2d-rendering' | '3d-rendering' | 'physics-2d' | 'physics-3d' | 'audio' | 'networking' | 'ui-system' | 'visual-scripting' | 'tilemaps' | 'particles' | 'animation' | 'vr-ar' | (string & {});
+export type AssetType = 'sprite' | 'tileset' | 'audio' | 'font' | 'script' | 'scene' | 'prefab' | 'material' | 'shader' | 'animation' | 'tilemap' | 'particleSystem' | 'texture' | 'data' | (string & {});
 export interface NiceProject {
     name: string;
     version: string;
@@ -22,6 +30,8 @@ export interface NiceProject {
     assets: NiceAsset[];
     scripts: ScriptGraph[];
     prefabs: NicePrefab[];
+    /** Top-level entity collection alias used by some exporters (flattened from all scenes). */
+    entities?: NiceEntity[];
 }
 export interface ProjectSettings {
     resolution: {
@@ -31,6 +41,7 @@ export interface ProjectSettings {
     width?: number;
     height?: number;
     backgroundColor: string;
+    targetFrameRate?: number;
     physics: {
         gravity: {
             x: number;
@@ -40,6 +51,7 @@ export interface ProjectSettings {
         velocityIterations?: number;
         positionIterations?: number;
         timeStep?: number;
+        scale?: number;
     };
     audio: {
         masterVolume: number;
@@ -64,6 +76,7 @@ export interface NiceScene {
     tilemaps?: NiceTilemap[];
     metadata?: Record<string, unknown>;
     settings?: Record<string, unknown>;
+    background?: string;
 }
 export interface NiceEntity {
     id: string;
@@ -199,3 +212,7 @@ export declare function registerPlatform(info: PlatformInfo): void;
 export declare function getPlatformInfo(id: PlatformId): PlatformInfo | undefined;
 export declare function getAllPlatforms(): PlatformInfo[];
 export default PlatformExporter;
+export type GameProject = NiceProject;
+export type Entity = NiceEntity;
+export type Component = NiceComponent;
+export type Asset = NiceAsset;

package/dist/types/export/RPGMakerExporter.d.ts

@@ -0,0 +1,41 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface RPGMakerExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Target version */
+        version?: 'MV' | 'MZ';
+        /** Plugin name prefix */
+        pluginPrefix?: string;
+        /** Generate common events */
+        generateCommonEvents?: boolean;
+        /** Generate battle system customizations */
+        customBattleSystem?: boolean;
+        /** Tile size */
+        tileSize?: 48 | 32;
+        /** Map width in tiles */
+        defaultMapWidth?: number;
+        /** Map height in tiles */
+        defaultMapHeight?: number;
+    };
+}
+export declare class RPGMakerExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private version;
+    private pluginPrefix;
+    private tileSize;
+    protected doExport(project: NiceProject, options: RPGMakerExportOptions): Promise<void>;
+    private generateMainPlugin;
+    private getMZPluginHeader;
+    private getMVPluginHeader;
+    private getMZPluginCommands;
+    private getMVPluginCommands;
+    private generateUtilityPlugin;
+    private exportScene;
+    private entityToEvent;
+    private generateEventCommands;
+    private exportPrefab;
+    private generateCommonEvents;
+    private generateDataFiles;
+    private hashCode;
+}
+export declare function createRPGMakerExporter(): RPGMakerExporter;

package/dist/types/export/RobloxExporter.d.ts

@@ -0,0 +1,38 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface RobloxExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Generate server scripts */
+        includeServerScripts?: boolean;
+        /** Generate client scripts */
+        includeClientScripts?: boolean;
+        /** Use Roblox's new Luau strict mode */
+        strictMode?: boolean;
+        /** Game genre (affects default services) */
+        genre?: 'adventure' | 'obby' | 'simulator' | 'roleplay' | 'fps' | 'tycoon';
+        /** Enable team create compatibility */
+        teamCreate?: boolean;
+        /** Target experience type */
+        experienceType?: 'game' | 'showcase' | 'social';
+    };
+}
+export declare class RobloxExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectName;
+    private useStrictMode;
+    protected doExport(project: NiceProject, options: RobloxExportOptions): Promise<void>;
+    private generateFolderStructure;
+    private generateCoreScripts;
+    private generateServicesSetup;
+    private generateClientScripts;
+    private generateServerScripts;
+    private exportScene;
+    private generateSceneModel;
+    private generateEntityXml;
+    private generateComponentChildren;
+    private hexToRobloxColor3;
+    private generateSceneScript;
+    private exportPrefab;
+    private luaTableFromObject;
+}
+export declare function createRobloxExporter(): RobloxExporter;

package/dist/types/export/Solar2DExporter.d.ts

@@ -0,0 +1,33 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Solar2DExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Target platforms */
+        platforms?: ('ios' | 'android' | 'win32' | 'macos' | 'tvos' | 'html5')[];
+        /** Use physics engine (Box2D) */
+        usePhysics?: boolean;
+        /** Use Composer scene manager */
+        useComposer?: boolean;
+        /** Generate plugin stubs */
+        pluginStubs?: boolean;
+        /** Generate push notification config */
+        pushNotifications?: boolean;
+        /** Content scaling mode */
+        scale?: 'letterbox' | 'zoomStretch' | 'zoomEven' | 'none';
+    };
+}
+export declare class Solar2DExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: Solar2DExportOptions): Promise<void>;
+    private generateConfigLua;
+    private generateBuildSettings;
+    private generateMainLua;
+    private generateUtilityModules;
+    private exportScene;
+    private createEntityLua;
+    private hexToRGB;
+    private exportPrefab;
+    private componentToLua;
+    private generateReadme;
+}
+export declare function createSolar2DExporter(): Solar2DExporter;

package/dist/types/export/Tic80Exporter.d.ts

@@ -0,0 +1,42 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Tic80ExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Programming language */
+        language?: 'lua' | 'javascript' | 'moonscript' | 'wren';
+        /** Include bank switching code */
+        bankSwitching?: boolean;
+        /** Generate sfx placeholders */
+        sfxPlaceholders?: boolean;
+        /** Generate music patterns */
+        musicPatterns?: boolean;
+        /** Include debug tools */
+        includeDebug?: boolean;
+    };
+}
+export declare class Tic80Exporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: Tic80ExportOptions): Promise<void>;
+    private generateTicFile;
+    private generateLuaCode;
+    private generateLuaCoreFunctions;
+    private generateLuaEntitySystem;
+    private generateLuaEntityDefinitions;
+    private entityTypeToLuaDef;
+    private getEntitySpriteIndex;
+    private getComponentProperty;
+    private generateLuaSceneManagement;
+    private generateLuaUtilities;
+    private generateJavaScriptCode;
+    private generateMoonscriptCode;
+    private generateWrenCode;
+    private generateSpritesSection;
+    private generateMapSection;
+    private generateWavesSection;
+    private generateSfxSection;
+    private generateMusicSection;
+    private generatePaletteSection;
+    private getClosestTic80Color;
+    private generateReadme;
+}
+export declare function createTic80Exporter(): Tic80Exporter;

package/dist/types/export/UnrealExporter.d.ts

@@ -0,0 +1,46 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface UnrealExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Unreal Engine version (e.g., '5.3', '5.4') */
+        engineVersion?: string;
+        /** Module name for generated C++ classes */
+        moduleName?: string;
+        /** Generate Blueprint-compatible nodes */
+        generateBlueprints?: boolean;
+        /** Generate pure C++ without BP macros */
+        pureCpp?: boolean;
+        /** Use Niagara instead of Cascade for particles */
+        useNiagara?: boolean;
+        /** Default skeletal mesh system */
+        skeletalSystem?: 'control-rig' | 'animation-bp';
+        /** Use Enhanced Input system */
+        useEnhancedInput?: boolean;
+        /** Generate Gameplay Ability System components */
+        useGAS?: boolean;
+        /** Project category */
+        projectCategory?: 'game' | 'plugin' | 'engine';
+    };
+}
+export declare class UnrealExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private moduleName;
+    private engineVersion;
+    private usedHeaders;
+    protected doExport(project: NiceProject, options: UnrealExportOptions): Promise<void>;
+    private generateProjectFiles;
+    private generateBuildFiles;
+    private generateSourceFiles;
+    private generateGameMode;
+    private generateActorClass;
+    private convertPropertyValue;
+    private generateConfigFiles;
+    private exportScene;
+    private generateLevelBlueprint;
+    private generateEntitySpawnCode;
+    private generateSpawnData;
+    private exportAsset;
+    private generateDataAsset;
+    private generateBlueprintLibrary;
+}
+export declare function createUnrealExporter(): UnrealExporter;

package/dist/types/export/index.d.ts

@@ -1,8 +1,22 @@
 export { PlatformExporter, type PlatformId, type PlatformInfo, type PlatformFeature, type AssetType, type NiceProject, type ProjectSettings, type NiceScene, type NiceEntity, type NiceComponent, type NiceAsset, type NicePrefab, type NiceTilemap, type TilemapLayer, type ExportOptions, type ExportResult, type ExportedFile, type ExportError, type ExportWarning, type ExportStats, type DetectionResult, detectBestPlatform, registerPlatform, getPlatformInfo, getAllPlatforms, } from './PlatformExporter';
 export { UnityExporter, type UnityExportOptions } from './UnityExporter';
 export { GodotExporter, type GodotExportOptions } from './GodotExporter';
+export { UnrealExporter, type UnrealExportOptions, createUnrealExporter } from './UnrealExporter';
+export { CocosExporter, type CocosExportOptions, createCocosExporter } from './CocosExporter';
+export { GameMakerExporter, type GameMakerExportOptions, createGameMakerExporter, } from './GameMakerExporter';
+export { RobloxExporter, type RobloxExportOptions, createRobloxExporter } from './RobloxExporter';
+export { MinecraftBedrockExporter, type MinecraftBedrockExportOptions, createMinecraftBedrockExporter, } from './MinecraftBedrockExporter';
+export { RPGMakerExporter, type RPGMakerExportOptions, createRPGMakerExporter, } from './RPGMakerExporter';
+export { Construct3Exporter, type Construct3ExportOptions, createConstruct3Exporter, } from './Construct3Exporter';
+export { GDevelopExporter, type GDevelopExportOptions, createGDevelopExporter, } from './GDevelopExporter';
+export { DefoldExporter, type DefoldExportOptions, createDefoldExporter } from './DefoldExporter';
+export { Solar2DExporter, type Solar2DExportOptions, createSolar2DExporter, } from './Solar2DExporter';
+export { Pico8Exporter, type Pico8ExportOptions, createPico8Exporter } from './Pico8Exporter';
+export { Tic80Exporter, type Tic80ExportOptions, createTic80Exporter } from './Tic80Exporter';
+export { ThreeJSExporter } from './ThreeJSExporter';
+export { BevyExporter, type BevyExportConfig, DEFAULT_BEVY_CONFIG } from './BevyExporter';
+export { MonoGameExporter, type MonoGameExportConfig, DEFAULT_MONOGAME_CONFIG, } from './MonoGameExporter';
 export { PixiJSExporter, PhaserExporter, type WebExportOptions } from './WebExporter';
-export { ThreeJSExporter, type ThreeJSExportOptions } from './ThreeJSExporter';
 import type { PlatformId } from './PlatformExporter';
 import { PlatformExporter } from './PlatformExporter';
 /**