import type { AssetContainer } from "@babylonjs/core/assetContainer";
import type { Skeleton } from "@babylonjs/core/Bones/skeleton";
import type { SceneLoaderPluginOptions } from "@babylonjs/core/Loading/sceneLoader";
import { type ISceneLoaderPluginAsync, type ISceneLoaderProgressEvent } from "@babylonjs/core/Loading/sceneLoader";
import type { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
import { Mesh } from "@babylonjs/core/Meshes/mesh";
import type { IFileRequest } from "@babylonjs/core/Misc/fileRequest";
import type { LoadFileError } from "@babylonjs/core/Misc/fileTools";
import type { WebRequest } from "@babylonjs/core/Misc/webRequest";
import type { Scene } from "@babylonjs/core/scene";
import type { Nullable } from "@babylonjs/core/types";
import type { IBuildMaterialResult, IBuildMorphResult, IMmdModelBuildGeometryResult, IMmdModelLoaderOptions } from "../mmdModelLoader";
import { type IMmdModelLoadState, MmdModelLoader } from "../mmdModelLoader";
import type { MmdModelMetadata } from "../mmdModelMetadata";
import type { ILogger } from "../Parser/ILogger";
import type { IProgressTask, Progress } from "../progress";
import { BpmxObject } from "./Parser/bpmxObject";
/**
 * Options for loading BPMX model
 */
export interface IBpmxLoaderOptions extends IMmdModelLoaderOptions {
    /**
     * Use single mesh for single geometry model (defalut: true)
     *
     * If there is only one geometry in the model, we don't need to create root node for create mesh
     *
     * Instead, we use root node as render
     */
    readonly useSingleMeshForSingleGeometryModel: boolean;
}
interface IBpmxLoadState extends IMmdModelLoadState {
    readonly useSingleMeshForSingleGeometryModel: boolean;
}
interface IBpmxBuildGeometryResult extends IMmdModelBuildGeometryResult {
}
/**
 * BpmxLoader is a loader that loads models in BPMX format
 *
 * BPMX is a single binary file format that contains all the data of a model
 */
export declare class BpmxLoader extends MmdModelLoader<IBpmxLoadState, BpmxObject, IBpmxBuildGeometryResult> implements IBpmxLoaderOptions, ISceneLoaderPluginAsync, ILogger {
    /**
     * Use single mesh for single geometry model (defalut: true)
     *
     * If there is only one geometry in the model, we don't need to create root node for create mesh
     *
     * Instead, we use root node as render
     */
    useSingleMeshForSingleGeometryModel: boolean;
    /**
     * Create a new BpmxLoader
     *
     * @param options babylon.js scene loader options
     * @param loaderOptions Overriding options, typically pass global BpmxLoader instance as loaderOptions
     */
    constructor(options?: Partial<IBpmxLoaderOptions>, loaderOptions?: IBpmxLoaderOptions);
    loadFile(scene: Scene, fileOrUrl: string | File | ArrayBufferView, _rootUrl: string, onSuccess: (data: IBpmxLoadState, responseURL?: string | undefined) => void, onProgress?: ((ev: ISceneLoaderProgressEvent) => void) | undefined, useArrayBuffer?: boolean | undefined, onError?: ((request?: WebRequest | undefined, exception?: LoadFileError | undefined) => void) | undefined): Nullable<IFileRequest>;
    createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync;
    protected _parseFileAsync(arrayBuffer: ArrayBufferLike): Promise<BpmxObject>;
    protected _getProgressTaskCosts(state: IBpmxLoadState, modelObject: BpmxObject): IProgressTask[];
    protected _buildGeometryAsync(state: IBpmxLoadState, modelObject: BpmxObject, scene: Scene, assetContainer: Nullable<AssetContainer>, progress: Progress): Promise<IBpmxBuildGeometryResult>;
    protected _buildMaterialAsync(state: IBpmxLoadState, modelObject: BpmxObject, rootMesh: Mesh, meshes: Mesh[], textureNameMap: Nullable<Map<BaseTexture, string>>, scene: Scene, assetContainer: Nullable<AssetContainer>, rootUrl: string, progress: Progress): Promise<IBuildMaterialResult>;
    protected _buildSkeletonAsync(state: IBpmxLoadState, modelObject: BpmxObject, meshes: Mesh[], scene: Scene, assetContainer: Nullable<AssetContainer>, bonesMetadata: MmdModelMetadata.Bone[] | MmdModelMetadata.SerializationBone[], progress: Progress): Promise<Nullable<Skeleton>>;
    protected _buildMorphAsync(state: IBpmxLoadState, modelObject: BpmxObject, buildGeometryResult: IBpmxBuildGeometryResult, scene: Scene, assetContainer: Nullable<AssetContainer>, progress: Progress): Promise<IBuildMorphResult>;
}
export {};