import { TextureOptions, TexturePreset } from "./texturePresets.js";
import { TileMapData } from "../tilemap/types.js";
import { Loader } from "three";
import { NormalSourceDescriptor } from "@three-flatland/normals";
import { BakedAssetLoaderOptions } from "@three-flatland/bake";
//#region src/loaders/LDtkLoader.d.ts
/**
 * Option shape for the `normals` field on `LDtkLoaderOptions`.
 *
 * - `false` — no normals generated.
 * - `true` — auto-synthesize a descriptor from each tileset's tile
 *   custom data (reads `tileDir`, `tileCap`, etc.).
 * - `NormalSourceDescriptor` — user provides defaults (and optionally
 *   regions). The loader merges in tile-derived regions if the
 *   descriptor doesn't already specify them.
 */
type LDtkNormalsOption = false | true | NormalSourceDescriptor;
/**
 * LDtk JSON format types.
 */
interface LDtkProject {
  jsonVersion: string;
  worldLayout: 'Free' | 'GridVania' | 'LinearHorizontal' | 'LinearVertical';
  worldGridWidth: number;
  worldGridHeight: number;
  defaultGridSize: number;
  bgColor: string;
  defs: LDtkDefs;
  levels: LDtkLevel[];
}
interface LDtkDefs {
  layers: LDtkLayerDef[];
  entities: LDtkEntityDef[];
  tilesets: LDtkTilesetDef[];
  enums: LDtkEnumDef[];
}
interface LDtkLayerDef {
  uid: number;
  identifier: string;
  type: 'IntGrid' | 'Entities' | 'Tiles' | 'AutoLayer';
  gridSize: number;
  tilesetDefUid?: number;
}
interface LDtkTilesetDef {
  uid: number;
  identifier: string;
  relPath: string;
  pxWid: number;
  pxHei: number;
  tileGridSize: number;
  spacing: number;
  padding: number;
  __cWid: number;
  __cHei: number;
  customData: Array<{
    tileId: number;
    data: string;
  }>;
  enumTags: Array<{
    enumValueId: string;
    tileIds: number[];
  }>;
}
interface LDtkEntityDef {
  uid: number;
  identifier: string;
  width: number;
  height: number;
  color: string;
  fieldDefs: LDtkFieldDef[];
}
interface LDtkFieldDef {
  uid: number;
  identifier: string;
  type: string;
  defaultValue: unknown;
}
interface LDtkEnumDef {
  uid: number;
  identifier: string;
  values: Array<{
    id: string;
    color: number;
  }>;
}
interface LDtkLevel {
  uid: number;
  identifier: string;
  worldX: number;
  worldY: number;
  pxWid: number;
  pxHei: number;
  bgColor: string;
  layerInstances: LDtkLayerInstance[];
  fieldInstances: LDtkFieldInstance[];
}
interface LDtkLayerInstance {
  __identifier: string;
  __type: 'IntGrid' | 'Entities' | 'Tiles' | 'AutoLayer';
  __cWid: number;
  __cHei: number;
  __gridSize: number;
  __tilesetDefUid?: number;
  __tilesetRelPath?: string;
  levelId: number;
  layerDefUid: number;
  pxOffsetX: number;
  pxOffsetY: number;
  visible: boolean;
  intGridCsv?: number[];
  autoLayerTiles?: LDtkTile[];
  gridTiles?: LDtkTile[];
  entityInstances?: LDtkEntityInstance[];
}
interface LDtkTile {
  px: [number, number];
  src: [number, number];
  f: number;
  t: number;
}
interface LDtkEntityInstance {
  __identifier: string;
  __grid: [number, number];
  __tags: string[];
  __tile?: {
    tilesetUid: number;
    x: number;
    y: number;
    w: number;
    h: number;
  };
  defUid: number;
  px: [number, number];
  width: number;
  height: number;
  fieldInstances: LDtkFieldInstance[];
  iid: string;
}
interface LDtkFieldInstance {
  __identifier: string;
  __type: string;
  __value: unknown;
}
/**
 * Options for loading an LDtk project.
 */
interface LDtkLoaderOptions extends BakedAssetLoaderOptions {
  /** Texture preset or custom options. Overrides loader and global defaults. */
  texture?: TexturePreset | TextureOptions;
  /**
   * Normal-map generation. When truthy, the loader synthesizes a
   * descriptor from each tileset's tile custom data (`tileDir`,
   * `tileCap*`, etc.), probes for a baked `.normal.png` sibling with
   * a matching descriptor hash, and falls back to an in-memory bake.
   *
   * The resulting texture is attached to `TilesetData.normalMap`,
   * 1:1 co-registered with the tileset image.
   */
  normals?: LDtkNormalsOption;
}
/**
 * Loader for LDtk JSON format.
 *
 * Extends Three.js's Loader class for compatibility with R3F's useLoader.
 * Supports:
 * - Single level or multi-level projects
 * - Tile layers (Tiles, AutoLayer, IntGrid)
 * - Entity layers
 * - IntGrid collision data
 * - Tile flip flags
 * - Custom field data
 *
 * @example
 * ```typescript
 * // Three.js usage - static API
 * const mapData = await LDtkLoader.load('/maps/world.ldtk', 'Level_0')
 *
 * // Override for this load
 * const mapData = await LDtkLoader.load('/maps/world.ldtk', 'Level_0', { texture: 'smooth' })
 *
 * // R3F usage - works with useLoader (loads first level)
 * import { LDtkLoader } from 'three-flatland/react';
 * const mapData = useLoader(LDtkLoader, '/maps/world.ldtk');
 *
 * // Override preset via extension
 * const mapData = useLoader(LDtkLoader, '/maps/world.ldtk', (loader) => {
 *   loader.preset = 'smooth';
 *   loader.levelId = 'Level_1';  // Specify level to load
 * });
 *
 * // Set loader-level default
 * LDtkLoader.options = 'pixel-art'
 * ```
 */
declare class LDtkLoader extends Loader<TileMapData> {
  private static cache;
  /**
   * Texture options for this loader class.
   * When undefined, falls through to TextureConfig.options.
   */
  static options: TexturePreset | TextureOptions | undefined;
  /**
   * Instance-level preset override.
   * Set via R3F's useLoader extension callback.
   */
  preset: TexturePreset | TextureOptions | undefined;
  /**
   * Level ID to load (for R3F useLoader).
   * If undefined, loads the first level.
   *
   * @example
   * ```tsx
   * const mapData = useLoader(LDtkLoader, '/maps/world.ldtk', (loader) => {
   *   loader.levelId = 'Level_1';
   * });
   * ```
   */
  levelId: string | number | undefined;
  /**
   * Normal-map generation. See {@link LDtkLoaderOptions.normals}.
   */
  normals: LDtkNormalsOption;
  /**
   * Generate this tilemap's tileset normal maps in the browser on
   * every load instead of loading pre-baked sidecars. The in-memory
   * bake runs on every load; sidecar probes and "no baked sibling"
   * warns are skipped. Not a dev-iteration knob.
   * See {@link BakedAssetLoaderOptions.forceRuntime}.
   */
  forceRuntime: boolean;
  /**
   * Load an LDtk level asynchronously (for R3F useLoader compatibility).
   * Presets and levelId are automatically applied from instance properties.
   */
  loadAsync(url: string): Promise<TileMapData>;
  /**
   * Load a single level from an LDtk project (static method for Three.js usage).
   */
  static load(url: string, levelId?: string | number, options?: LDtkLoaderOptions): Promise<TileMapData>;
  /**
   * Load the LDtk project file.
   */
  static loadProject(url: string): Promise<LDtkProject>;
  /**
   * Load project without caching.
   */
  private static loadProjectUncached;
  /**
   * Parse a single level.
   */
  private static parseLevel;
  /**
   * Parse a tileset definition.
   */
  private static parseTileset;
  /**
   * Build a normal-source descriptor for a tileset from its tile
   * custom data and hand it to `resolveNormalMap`. Each tagged tile
   * emits a cap/face region pair via `tilesetToRegions`; untagged
   * tiles emit a single flat region per cell.
   */
  private static resolveTilesetNormals;
  /**
   * Calculate UV for a tile.
   */
  private static calculateUV;
  /**
   * Parse a tile layer.
   */
  private static parseTileLayer;
  /**
   * Parse an entity layer.
   */
  private static parseEntityLayer;
  /**
   * Parse IntGrid layer as collision data.
   */
  private static parseIntGridLayer;
  /**
   * Parse field instances to properties.
   */
  private static parseFieldInstances;
  /**
   * Parse LDtk color string.
   */
  private static parseColor;
  /**
   * Load a texture with the specified options.
   */
  private static loadTexture;
  /**
   * Get all level identifiers from a project.
   */
  static getLevelIds(url: string): Promise<string[]>;
  /**
   * Clear the cache.
   */
  static clearCache(): void;
}
//#endregion
export { LDtkLoader, LDtkLoaderOptions, LDtkNormalsOption };
//# sourceMappingURL=LDtkLoader.d.ts.map