@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/ecs/World.d.ts

@@ -1,5 +1,5 @@
-import type { EntityId, Component, ComponentType, Vec2, Color } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { EntityId, Component, ComponentType, Vec2, Color } from '../core/types';
 export interface Entity {
     readonly id: EntityId;
     name: string;

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

@@ -1 +1,2 @@
 export { World, System, createDefaultComponent, type Entity, type TransformComponent, type SpriteComponent, type ShapeComponent, type Collider2DComponent, type RigidBody2DComponent, type TextComponent, type AnimatorComponent, type ScriptComponent, type AudioSourceComponent, type ParticleEmitterComponent, type CameraTargetComponent, type BuiltInComponent, type ComponentMap, type SpriteAnimation, type AnimationFrame, } from './World';
+export { SoAStorage, ArchetypeRegistry, OptimizedWorld, QueryIterator, MovementSystem, TRANSFORM_SCHEMA, VELOCITY_SCHEMA, RENDERABLE_SCHEMA, type EntityId, type ComponentTypeId, type ArchetypeId, type ComponentSchema, type ComponentField, type Archetype, type QueryResult, type ECSSystem, } from './ECSOptimized';

package/dist/types/editor/AchievementEditor.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @file AchievementEditor.ts
+ * @description Achievement/Trophy Editor system with progress tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Achievement definitions with tiers
+ * - Progress tracking (counters, milestones)
+ * - Conditions and triggers
+ * - Rewards integration
+ * - Categories and rarity
+ * - Hidden achievements
+ * - Achievement chains
+ * - Statistics integration
+ * - Retroactive unlocks
+ * - Platform sync (Steam, Xbox, PlayStation, etc.)
+ */
+export type AchievementRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'secret';
+export type AchievementCategory = 'story' | 'exploration' | 'combat' | 'collection' | 'social' | 'challenge' | 'mastery' | 'secret' | 'seasonal' | 'dlc' | 'custom';
+export type TriggerType = 'stat' | 'event' | 'quest' | 'item' | 'level' | 'skill' | 'time' | 'location' | 'boss' | 'achievement' | 'custom';
+export type ComparisonOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
+export interface AchievementTrigger {
+    id: string;
+    type: TriggerType;
+    target: string;
+    operator: ComparisonOperator;
+    value: number | string | boolean;
+    description?: string;
+}
+export interface AchievementCondition {
+    triggers: AchievementTrigger[];
+    logic: 'and' | 'or';
+    description?: string;
+}
+export interface AchievementTier {
+    tier: number;
+    name: string;
+    description: string;
+    targetValue: number;
+    rewards?: AchievementReward[];
+    icon?: string;
+    pointValue: number;
+}
+export interface AchievementReward {
+    type: 'item' | 'currency' | 'title' | 'badge' | 'cosmetic' | 'unlock' | 'points' | 'custom';
+    target: string;
+    amount: number;
+    description?: string;
+}
+export interface Achievement {
+    id: string;
+    name: string;
+    description: string;
+    hint?: string;
+    category: AchievementCategory;
+    rarity: AchievementRarity;
+    tags: string[];
+    icon: string;
+    iconLocked?: string;
+    color?: string;
+    bannerImage?: string;
+    soundEffect?: string;
+    conditions: AchievementCondition[];
+    isProgressBased: boolean;
+    currentProgress: number;
+    maxProgress: number;
+    progressFormat?: string;
+    hasTiers: boolean;
+    tiers?: AchievementTier[];
+    currentTier: number;
+    rewards: AchievementReward[];
+    pointValue: number;
+    isHidden: boolean;
+    showProgressWhenHidden: boolean;
+    revealCondition?: AchievementCondition;
+    chainId?: string;
+    chainOrder?: number;
+    prerequisiteIds?: string[];
+    isUnlocked: boolean;
+    unlockedAt?: number;
+    unlockedBy?: string;
+    platformId?: string;
+    platform?: string;
+    createdAt: number;
+    modifiedAt: number;
+    version: number;
+}
+export interface AchievementChain {
+    id: string;
+    name: string;
+    description: string;
+    achievementIds: string[];
+    completionRewards?: AchievementReward[];
+    isCompleted: boolean;
+}
+export interface Statistic {
+    id: string;
+    name: string;
+    description: string;
+    value: number;
+    type: 'counter' | 'max' | 'min' | 'average' | 'total_time' | 'custom';
+    format?: string;
+    isPublic: boolean;
+    linkedAchievements: string[];
+}
+export interface AchievementProgress {
+    achievementId: string;
+    playerId: string;
+    progress: number;
+    tier: number;
+    isUnlocked: boolean;
+    unlockedAt?: number;
+    progressHistory: ProgressHistoryEntry[];
+}
+export interface ProgressHistoryEntry {
+    timestamp: number;
+    progress: number;
+    reason?: string;
+}
+export declare class AchievementManager {
+    private achievements;
+    private chains;
+    private statistics;
+    private playerProgress;
+    private playerStats;
+    private totalPoints;
+    private onAchievementUnlocked?;
+    private onAchievementProgress?;
+    private onTierUnlocked?;
+    private onChainCompleted?;
+    private onStatisticUpdated?;
+    private onRewardGranted?;
+    private onPointsAdded?;
+    private customTriggerEvaluator?;
+    createAchievement(name: string, category: AchievementCategory): Achievement;
+    getAchievement(id: string): Achievement | undefined;
+    updateAchievement(id: string, updates: Partial<Achievement>): boolean;
+    deleteAchievement(id: string): boolean;
+    getAllAchievements(): Achievement[];
+    getAchievementsByCategory(category: AchievementCategory): Achievement[];
+    createTrigger(type: TriggerType, target: string, operator: ComparisonOperator, value: number | string | boolean): AchievementTrigger;
+    addCondition(achievementId: string, condition: AchievementCondition): boolean;
+    addTier(achievementId: string, name: string, targetValue: number, pointValue?: number): boolean;
+    setTierRewards(achievementId: string, tierIndex: number, rewards: AchievementReward[]): boolean;
+    addReward(achievementId: string, reward: AchievementReward): boolean;
+    createReward(type: AchievementReward['type'], target: string, amount: number): AchievementReward;
+    createChain(name: string, description?: string): AchievementChain;
+    addToChain(chainId: string, achievementId: string): boolean;
+    getChain(chainId: string): AchievementChain | undefined;
+    getAllChains(): AchievementChain[];
+    createStatistic(name: string, type?: Statistic['type'], initialValue?: number): Statistic;
+    getStatistic(id: string): Statistic | undefined;
+    linkStatisticToAchievement(statId: string, achievementId: string): boolean;
+    updateProgress(achievementId: string, playerId: string, progress: number, reason?: string): void;
+    incrementProgress(achievementId: string, playerId: string, amount?: number, reason?: string): void;
+    getProgress(achievementId: string, playerId: string): number;
+    unlockAchievement(achievementId: string, playerId: string): boolean;
+    isUnlocked(achievementId: string, playerId: string): boolean;
+    private checkChainCompletion;
+    updateStatistic(statId: string, playerId: string, value: number): void;
+    incrementStatistic(statId: string, playerId: string, amount?: number): void;
+    getStatisticValue(statId: string, playerId: string): number;
+    processEvent(eventType: string, eventData: Record<string, unknown>, playerId: string): void;
+    private evaluateCondition;
+    private evaluateTrigger;
+    private compare;
+    private grantReward;
+    private addPoints;
+    getTotalPoints(playerId: string): number;
+    setOnAchievementUnlocked(callback: (achievement: Achievement, playerId: string) => void): void;
+    setOnAchievementProgress(callback: (achievement: Achievement, playerId: string, progress: number) => void): void;
+    setOnTierUnlocked(callback: (achievement: Achievement, tier: AchievementTier, playerId: string) => void): void;
+    setOnChainCompleted(callback: (chain: AchievementChain, playerId: string) => void): void;
+    setOnStatisticUpdated(callback: (stat: Statistic, playerId: string, value: number) => void): void;
+    setOnRewardGranted(callback: (reward: AchievementReward, playerId: string) => void): void;
+    setOnPointsAdded(callback: (playerId: string, points: number, total: number) => void): void;
+    setCustomTriggerEvaluator(evaluator: (trigger: AchievementTrigger, playerId: string) => boolean): void;
+    getUnlockedAchievements(playerId: string): Achievement[];
+    getLockedAchievements(playerId: string): Achievement[];
+    getHiddenAchievements(): Achievement[];
+    getVisibleAchievements(playerId: string): Achievement[];
+    getCompletionPercentage(playerId: string): number;
+    getAchievementsByRarity(rarity: AchievementRarity): Achievement[];
+    searchAchievements(query: string): Achievement[];
+    processRetroactive(playerId: string): void;
+    exportAchievements(): string;
+    importAchievements(json: string): boolean;
+    exportProgress(playerId: string): string;
+    importProgress(playerId: string, json: string): boolean;
+}
+export declare function createAchievementManager(): AchievementManager;
+export declare function createAchievementTrigger(type: TriggerType, target: string, operator: ComparisonOperator, value: number | string | boolean): AchievementTrigger;
+export declare function createAchievementCondition(triggers: AchievementTrigger[], logic?: 'and' | 'or'): AchievementCondition;

package/dist/types/editor/AnimationRetargeting.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @file AnimationRetargeting.ts
+ * @description Animation Retargeting system for applying animations cross-skeletons
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Skeleton hierarchy definition
+ * - Bone mapping between source and target skeletons
+ * - Auto-mapping based on bone names
+ * - Manual mapping adjustment
+ * - Bone transforms (rotation, position, scale adjustments)
+ * - Animation clip retargeting
+ * - Root motion handling
+ * - Finger/hand mapping for humanoids
+ * - Mirror animations (left/right swap)
+ * - Blend shape mapping
+ * - IK adjustment options
+ */
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface BoneTransform {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export interface Bone {
+    id: string;
+    name: string;
+    parentId: string | null;
+    localTransform: BoneTransform;
+    worldTransform?: BoneTransform;
+    length: number;
+    children: string[];
+    humanoidBone?: HumanoidBone;
+    constraints?: BoneConstraints;
+}
+export interface BoneConstraints {
+    rotationMin?: Vector3;
+    rotationMax?: Vector3;
+    twist?: {
+        min: number;
+        max: number;
+    };
+    swing?: {
+        yMin: number;
+        yMax: number;
+        xMin: number;
+        xMax: number;
+    };
+}
+export type HumanoidBone = 'Hips' | 'Spine' | 'Chest' | 'UpperChest' | 'Neck' | 'Head' | 'LeftShoulder' | 'LeftUpperArm' | 'LeftLowerArm' | 'LeftHand' | 'RightShoulder' | 'RightUpperArm' | 'RightLowerArm' | 'RightHand' | 'LeftUpperLeg' | 'LeftLowerLeg' | 'LeftFoot' | 'LeftToes' | 'RightUpperLeg' | 'RightLowerLeg' | 'RightFoot' | 'RightToes' | 'LeftThumbProximal' | 'LeftThumbIntermediate' | 'LeftThumbDistal' | 'LeftIndexProximal' | 'LeftIndexIntermediate' | 'LeftIndexDistal' | 'LeftMiddleProximal' | 'LeftMiddleIntermediate' | 'LeftMiddleDistal' | 'LeftRingProximal' | 'LeftRingIntermediate' | 'LeftRingDistal' | 'LeftLittleProximal' | 'LeftLittleIntermediate' | 'LeftLittleDistal' | 'RightThumbProximal' | 'RightThumbIntermediate' | 'RightThumbDistal' | 'RightIndexProximal' | 'RightIndexIntermediate' | 'RightIndexDistal' | 'RightMiddleProximal' | 'RightMiddleIntermediate' | 'RightMiddleDistal' | 'RightRingProximal' | 'RightRingIntermediate' | 'RightRingDistal' | 'RightLittleProximal' | 'RightLittleIntermediate' | 'RightLittleDistal';
+export interface Skeleton {
+    id: string;
+    name: string;
+    bones: Map<string, Bone>;
+    rootBoneId: string;
+    isHumanoid: boolean;
+    humanoidMapping?: Map<HumanoidBone, string>;
+    tPose?: Map<string, BoneTransform>;
+    scale: number;
+    upAxis: 'y' | 'z';
+    forwardAxis: 'z' | 'x' | '-z' | '-x';
+}
+export interface BoneMapping {
+    sourceBoneId: string;
+    targetBoneId: string;
+    mappingType: 'direct' | 'twist' | 'copy' | 'ignore';
+    rotationOffset?: Quaternion;
+    positionOffset?: Vector3;
+    scaleMultiplier?: Vector3;
+    twistWeight?: number;
+    isMirroredPair?: boolean;
+    mirrorBoneId?: string;
+}
+export interface AnimationKeyframe {
+    time: number;
+    value: number | Vector3 | Quaternion;
+    inTangent?: number | Vector3;
+    outTangent?: number | Vector3;
+    interpolation: 'linear' | 'step' | 'cubic' | 'hermite';
+}
+export interface AnimationTrack {
+    boneId: string;
+    property: 'position' | 'rotation' | 'scale' | 'blendShape';
+    keyframes: AnimationKeyframe[];
+    blendShapeName?: string;
+}
+export interface AnimationClip {
+    id: string;
+    name: string;
+    duration: number;
+    frameRate: number;
+    tracks: AnimationTrack[];
+    hasRootMotion: boolean;
+    rootMotionBoneId?: string;
+    isLooping: boolean;
+    loopTime?: number;
+    events?: AnimationEvent[];
+    sourceSkeletonId: string;
+}
+export interface AnimationEvent {
+    time: number;
+    name: string;
+    data?: unknown;
+}
+export interface RetargetingProfile {
+    id: string;
+    name: string;
+    description: string;
+    sourceSkeletonId: string;
+    targetSkeletonId: string;
+    boneMappings: BoneMapping[];
+    globalScale: number;
+    globalRotationOffset: Quaternion;
+    rootMotionScale: Vector3;
+    preserveHipHeight: boolean;
+    adjustArmLength: boolean;
+    adjustLegLength: boolean;
+    useSourcePose: boolean;
+    mirrorMode: 'none' | 'x' | 'z';
+    useFootIK: boolean;
+    useHandIK: boolean;
+    footGroundOffset: number;
+    createdAt: number;
+    modifiedAt: number;
+}
+export interface RetargetingResult {
+    success: boolean;
+    clip?: AnimationClip;
+    warnings: string[];
+    errors: string[];
+    unmappedBones: string[];
+    scaleDifferences: Map<string, number>;
+}
+export declare class AnimationRetargeting {
+    private skeletons;
+    private profiles;
+    private clips;
+    private humanoidNamePatterns;
+    private mirrorPairs;
+    constructor();
+    private buildNamePatterns;
+    private buildMirrorPairs;
+    registerSkeleton(skeleton: Skeleton): void;
+    getSkeleton(id: string): Skeleton | undefined;
+    createSkeleton(name: string, bones: Bone[]): Skeleton;
+    markAsHumanoid(skeletonId: string): boolean;
+    private autoDetectHumanoidMapping;
+    setHumanoidBoneMapping(skeletonId: string, humanoidBone: HumanoidBone, boneId: string): boolean;
+    createRetargetingProfile(name: string, sourceSkeletonId: string, targetSkeletonId: string): RetargetingProfile | null;
+    private autoGenerateMappings;
+    private findMatchingBone;
+    getProfile(id: string): RetargetingProfile | undefined;
+    updateProfile(id: string, updates: Partial<RetargetingProfile>): boolean;
+    setBoneMapping(profileId: string, mapping: BoneMapping): boolean;
+    removeBoneMapping(profileId: string, sourceBoneId: string): boolean;
+    registerClip(clip: AnimationClip): void;
+    getClip(id: string): AnimationClip | undefined;
+    retargetClip(clipId: string, profileId: string): RetargetingResult;
+    private retargetTrack;
+    private retargetKeyframe;
+    private retargetRotation;
+    private retargetPosition;
+    private retargetScale;
+    private mirrorTrack;
+    private adjustRootMotion;
+    getBoneHierarchy(skeletonId: string): BoneHierarchyNode[];
+    getMappingVisualization(profileId: string): MappingVisualization[];
+    serializeProfile(profileId: string): string | null;
+    deserializeProfile(json: string): RetargetingProfile | null;
+    serializeSkeleton(skeletonId: string): string | null;
+    deserializeSkeleton(json: string): Skeleton | null;
+}
+export interface BoneHierarchyNode {
+    id: string;
+    name: string;
+    humanoidBone?: HumanoidBone;
+    children: BoneHierarchyNode[];
+}
+export interface MappingVisualization {
+    sourceBoneId: string;
+    sourceBoneName: string;
+    targetBoneId: string;
+    targetBoneName: string;
+    mappingType: string;
+    hasOffset: boolean;
+    isMirrorPair: boolean;
+}
+export declare function createAnimationRetargeting(): AnimationRetargeting;
+export declare function createBone(name: string, parentId?: string | null, transform?: Partial<BoneTransform>): Bone;
+export declare function createAnimationClip(name: string, sourceSkeletonId: string, duration?: number, frameRate?: number): AnimationClip;

package/dist/types/editor/AssetBrowser.d.ts

@@ -0,0 +1,214 @@
+/**
+ * @file AssetBrowser.ts
+ * @description Advanced Asset Browser with thumbnails, search, tags, favorites
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Thumbnail generation for all asset types
+ * - Advanced search with filters
+ * - Tag management and filtering
+ * - Favorites system
+ * - Recent assets tracking
+ * - Collections/folders
+ * - Asset metadata editing
+ * - Drag & drop support
+ * - Import/export
+ * - Asset dependencies
+ * - Quick preview
+ */
+export type AssetBrowserViewMode = 'grid' | 'list' | 'details' | 'tree';
+export type AssetSortMode = 'name-asc' | 'name-desc' | 'date-asc' | 'date-desc' | 'size-asc' | 'size-desc' | 'type';
+export type BrowserAssetType = 'image' | 'sprite' | 'spritesheet' | 'tilemap' | 'audio' | 'music' | 'sfx' | 'model' | 'material' | 'shader' | 'script' | 'scene' | 'prefab' | 'animation' | 'font' | 'particle' | 'terrain' | 'video' | 'json' | 'other';
+export interface AssetThumbnail {
+    dataUrl: string;
+    width: number;
+    height: number;
+    generated: number;
+}
+export interface AssetDependency {
+    assetId: string;
+    type: 'reference' | 'embedded' | 'linked';
+}
+export interface BrowserAsset {
+    id: string;
+    name: string;
+    type: BrowserAssetType;
+    path: string;
+    size: number;
+    mimeType: string;
+    tags: string[];
+    description: string;
+    author: string;
+    license: string;
+    version: string;
+    customProperties: Record<string, unknown>;
+    createdAt: number;
+    modifiedAt: number;
+    importedAt: number;
+    thumbnail?: AssetThumbnail;
+    thumbnailGenerating?: boolean;
+    usageCount: number;
+    lastUsedAt: number | null;
+    folderId: string;
+    dependencies: AssetDependency[];
+    dependents: string[];
+    isFavorite: boolean;
+    color?: string;
+    notes?: string;
+    importSettings?: Record<string, unknown>;
+}
+export interface AssetFolder {
+    id: string;
+    name: string;
+    path: string;
+    parentId: string | null;
+    color?: string;
+    icon?: string;
+    expanded: boolean;
+    children: string[];
+    assets: string[];
+    createdAt: number;
+    isSystem?: boolean;
+}
+export interface AssetCollection {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    assetIds: string[];
+    createdAt: number;
+    isSmartCollection: boolean;
+    smartFilter?: AssetFilter;
+}
+export interface AssetFilter {
+    types?: BrowserAssetType[];
+    tags?: string[];
+    tagsMode?: 'any' | 'all';
+    search?: string;
+    searchFields?: ('name' | 'tags' | 'description' | 'path')[];
+    dateRange?: {
+        from: number;
+        to: number;
+    };
+    sizeRange?: {
+        min: number;
+        max: number;
+    };
+    favorites?: boolean;
+    recent?: boolean;
+    unused?: boolean;
+    folderId?: string;
+    includeSubfolders?: boolean;
+}
+export interface ImportOptions {
+    folder?: string;
+    generateThumbnail?: boolean;
+    thumbnailSize?: number;
+    autoTag?: boolean;
+    preserveStructure?: boolean;
+    overwriteExisting?: boolean;
+    optimize?: boolean;
+    maxImageSize?: number;
+    imageQuality?: number;
+}
+export declare const DEFAULT_IMPORT_OPTIONS: ImportOptions;
+export interface AssetBrowserConfig {
+    viewMode: AssetBrowserViewMode;
+    sortMode: AssetSortMode;
+    showHiddenFiles: boolean;
+    showSystemFolders: boolean;
+    thumbnailSize: 'small' | 'medium' | 'large';
+    showDetails: boolean;
+    groupByType: boolean;
+    recentCount: number;
+    importOptions: ImportOptions;
+}
+export declare const DEFAULT_BROWSER_CONFIG: AssetBrowserConfig;
+export declare class ThumbnailGenerator {
+    private canvas;
+    private ctx;
+    private audioContext;
+    constructor();
+    generateThumbnail(file: File | Blob, type: BrowserAssetType, size?: number): Promise<AssetThumbnail | null>;
+    private generateImageThumbnail;
+    private generateAudioThumbnail;
+    private generateVideoThumbnail;
+    private generateModelThumbnail;
+    private generateMaterialThumbnail;
+    private generateShaderThumbnail;
+    private generateScriptThumbnail;
+    private generateSceneThumbnail;
+    private generatePrefabThumbnail;
+    private generateFontThumbnail;
+    private generateParticleThumbnail;
+    private generateJsonThumbnail;
+    private generateGenericThumbnail;
+    private drawCheckerboard;
+    private drawPlayIcon;
+    private formatDuration;
+}
+export declare class AssetBrowser {
+    private config;
+    private assets;
+    private folders;
+    private collections;
+    private blobStore;
+    private thumbnailGenerator;
+    private currentFolderId;
+    private selectedIds;
+    private recentAssetIds;
+    private allTags;
+    private onChange?;
+    private onSelectionChange?;
+    private onAssetOpen?;
+    constructor(config?: Partial<AssetBrowserConfig>);
+    private createDefaultCollections;
+    setConfig(config: Partial<AssetBrowserConfig>): void;
+    getConfig(): AssetBrowserConfig;
+    importFiles(files: FileList | File[], options?: ImportOptions): Promise<BrowserAsset[]>;
+    importFile(file: File, options?: ImportOptions): Promise<BrowserAsset | null>;
+    private inferAssetType;
+    private autoGenerateTags;
+    private findOrCreateFolder;
+    private getFolderPath;
+    getAsset(id: string): BrowserAsset | undefined;
+    getAssetBlob(id: string): Blob | undefined;
+    getAllAssets(): BrowserAsset[];
+    getFilteredAssets(filter: AssetFilter): BrowserAsset[];
+    private matchesFilter;
+    getSortedAssets(assets: BrowserAsset[], sortMode?: AssetSortMode): BrowserAsset[];
+    toggleFavorite(assetId: string): void;
+    getFavorites(): BrowserAsset[];
+    markAsUsed(assetId: string): void;
+    getRecentAssets(): BrowserAsset[];
+    getAllTags(): string[];
+    addTag(assetId: string, tag: string): void;
+    removeTag(assetId: string, tag: string): void;
+    getFolder(id: string): AssetFolder | undefined;
+    getRootFolder(): AssetFolder;
+    createFolder(name: string, parentId?: string): AssetFolder;
+    setCurrentFolder(folderId: string): void;
+    getCurrentFolder(): AssetFolder;
+    getCollection(id: string): AssetCollection | undefined;
+    getAllCollections(): AssetCollection[];
+    createCollection(name: string, description?: string): AssetCollection;
+    addToCollection(collectionId: string, assetId: string): void;
+    removeFromCollection(collectionId: string, assetId: string): void;
+    select(assetId: string, addToSelection?: boolean): void;
+    deselect(assetId: string): void;
+    clearSelection(): void;
+    getSelectedAssets(): BrowserAsset[];
+    updateAsset(assetId: string, updates: Partial<BrowserAsset>): void;
+    deleteAsset(assetId: string): void;
+    exportAssetMetadata(): string;
+    importAssetMetadata(json: string): void;
+    setOnChange(callback: () => void): void;
+    setOnSelectionChange(callback: (ids: string[]) => void): void;
+    setOnAssetOpen(callback: (asset: BrowserAsset) => void): void;
+    openAsset(assetId: string): void;
+    formatFileSize(bytes: number): string;
+    getAssetTypeIcon(type: BrowserAssetType): string;
+}
+export declare function createAssetBrowser(config?: Partial<AssetBrowserConfig>): AssetBrowser;
+export declare function createThumbnailGenerator(): ThumbnailGenerator;

package/dist/types/editor/AssetManager.d.ts

@@ -1,5 +1,5 @@
-import type { AssetType, AssetManifest } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { AssetType, AssetManifest } from '../core/types';
 import type { World } from '../ecs/World';
 export interface AssetMetadata {
     id: string;