/**
 * TypeScript interfaces for the Tiled JSON Map Format.
 *
 * Source: Tiled docs "JSON Map Format" (1.11.x)
 * - Map, Layer, Chunk, Object, Text, Tileset (+ Grid, TileOffset, Transformations),
 *   Tile, Frame, Terrain, WangSet (+ WangColor, WangTile), Object Template, Property, Point.
 *
 * Notes:
 * - Field names mirror the JSON schema from Tiled (snake/lower camel as-is).
 * - Optional fields are marked with `?` exactly as per the documentation.
 * - Some fields are present only on certain layer/element kinds (discriminated unions below).
 * - For compatibility with Tiled 1.9+: several elements have a `class` string (optional).
 * - Since Tiled 1.10: `type` on tile/object (formerly `class` in 1.9) is used again in JSON exports.
 */
/**
 * A custom property entry.
 *
 * Doc excerpt:
 * - name: string
 * - type: "string" | "int" | "float" | "bool" | "color" | "file" | "object" | "class"
 * - propertytype: string (name of the custom property type) (since 1.8)
 * - value: depends on type (arbitrary object when type === "class")
 */
export interface TiledPropertyBase {
    name: string;
    /** Property type. Default: "string". */
    type?: TiledPropertyType;
    /** Name of the custom property type (since 1.8), when applicable */
    propertytype?: string;
}
export type TiledPropertyType = "string" | "int" | "float" | "bool" | "color" | "file" | "object" | "class";
export type TiledProperty = (TiledPropertyBase & {
    type?: "string";
    value: string;
}) | (TiledPropertyBase & {
    type: "int";
    value: number;
}) | (TiledPropertyBase & {
    type: "float";
    value: number;
}) | (TiledPropertyBase & {
    type: "bool";
    value: boolean;
}) | (TiledPropertyBase & {
    type: "color";
    value: string;
}) | (TiledPropertyBase & {
    type: "file";
    value: string;
}) | (TiledPropertyBase & {
    type: "object";
    value: number;
}) | (TiledPropertyBase & {
    type: "class";
    value: Record<string, unknown>;
});
export type TiledProperties = TiledProperty[];
export interface TiledMap {
    type?: "map";
    version: string;
    tiledversion?: string;
    /** Number of tile columns / rows */
    width: number;
    height: number;
    /** Map grid tile size */
    tilewidth: number;
    tileheight: number;
    /** Whether the map has infinite dimensions */
    infinite: boolean;
    /** Orientation and render order */
    orientation: "orthogonal" | "isometric" | "staggered" | "hexagonal";
    renderorder?: "right-down" | "right-up" | "left-down" | "left-up";
    /** Hex / stagger specifics */
    hexsidelength?: number;
    staggeraxis?: "x" | "y";
    staggerindex?: "odd" | "even";
    /** Parallax origin (since 1.8) */
    parallaxoriginx?: number;
    parallaxoriginy?: number;
    /** Global counters */
    nextlayerid: number;
    nextobjectid: number;
    /** Visuals */
    backgroundcolor?: string;
    /** Compression level used for tile layer data (defaults -1 = algorithm default) */
    compressionlevel?: number;
    /** Optional class of the map (since 1.9) */
    class?: string;
    /** Composed content */
    layers: TiledAnyLayer[];
    tilesets: TiledMapTileset[];
    /** Custom properties */
    properties?: TiledProperties;
}
interface TiledLayerBase {
    id: number;
    name: string;
    opacity: number;
    visible: boolean;
    x: number;
    y: number;
    offsetx?: number;
    offsety?: number;
    /** Parallax factors (since 1.5) */
    parallaxx?: number;
    parallaxy?: number;
    /** Tint color multiplied with drawn graphics (#RRGGBB or #AARRGGBB) */
    tintcolor?: string;
    /** Optional class (since 1.9) */
    class?: string;
    /** Custom properties */
    properties?: TiledProperties;
    /** Infinite maps only */
    startx?: number;
    starty?: number;
}
export interface TiledTileLayer extends TiledLayerBase {
    type: "tilelayer";
    /** Data can be an array of unsigned ints (GIDs) or base64-encoded string */
    data: number[] | string;
    encoding?: "csv" | "base64";
    compression?: "zlib" | "gzip" | "zstd" | "";
    height: number;
    width: number;
    /** Present on infinite maps */
    chunks?: TiledChunk[];
}
export interface TiledObjectLayer extends TiledLayerBase {
    type: "objectgroup";
    draworder?: "topdown" | "index";
    objects: TiledObject[];
    /** For fixed-size maps, height/width are 0 in examples */
    height?: number;
    width?: number;
}
export interface TiledImageLayer extends TiledLayerBase {
    type: "imagelayer";
    image?: string;
    transparentcolor?: string;
    repeatx?: boolean;
    repeaty?: boolean;
    /** since 1.11.1 */
    imageheight?: number;
    imagewidth?: number;
    /** For fixed-size maps, height/width are not stored; keep optional */
    height?: number;
    width?: number;
}
export interface TiledGroupLayer extends TiledLayerBase {
    type: "group";
    layers: TiledAnyLayer[];
}
export type TiledAnyLayer = TiledTileLayer | TiledObjectLayer | TiledImageLayer | TiledGroupLayer;
export interface TiledChunk {
    data: number[] | string;
    height: number;
    width: number;
    x: number;
    y: number;
}
export interface TiledObject {
    id: number;
    name: string;
    type?: string;
    visible: boolean;
    rotation: number;
    x: number;
    y: number;
    width: number;
    height: number;
    gid?: number;
    ellipse?: boolean;
    point?: boolean;
    polygon?: TiledPoint[];
    polyline?: TiledPoint[];
    text?: TiledText;
    template?: string;
    properties?: TiledProperties;
}
export interface TiledText {
    text: string;
    bold?: boolean;
    italic?: boolean;
    underline?: boolean;
    strikeout?: boolean;
    kerning?: boolean;
    wrap?: boolean;
    color?: string;
    fontfamily?: string;
    pixelsize?: number;
    halign?: "center" | "right" | "justify" | "left";
    valign?: "center" | "bottom" | "top";
}
export interface TiledPoint {
    x: number;
    y: number;
}
/** Tileset as embedded in a map (with firstgid) */
export interface TiledMapTileset extends TiledTilesetCommon {
    /** Global ID of the first tile in the set */
    firstgid: number;
    /** If this is an external TSX/JSON tileset reference */
    source?: string;
}
/** Tileset file (when exported/embedded without firstgid) */
export interface TiledTileset extends TiledTilesetCommon {
    type?: "tileset";
    version: string;
}
export interface TiledTilesetCommon {
    name: string;
    tilewidth: number;
    tileheight: number;
    tilecount: number;
    columns: number;
    /** Optional class (since 1.9) */
    class?: string;
    image?: string;
    imagewidth?: number;
    imageheight?: number;
    margin?: number;
    spacing?: number;
    transparentcolor?: string;
    /** Rendering options (since 1.9) */
    tilerendersize?: "tile" | "grid";
    fillmode?: "stretch" | "preserve-aspect-fit";
    /** Alignment of tile objects (since 1.4) */
    objectalignment?: "unspecified" | "topleft" | "top" | "topright" | "left" | "center" | "right" | "bottomleft" | "bottom" | "bottomright";
    /** Embedded tile definitions */
    tiles?: TiledTile[];
    /** Collisions & grid */
    grid?: TiledGrid;
    tileoffset?: TiledTileOffset;
    transformations?: TiledTransformations;
    /** Terrain & Wang */
    terrains?: TiledTerrain[];
    wangsets?: TiledWangSet[];
    /** Editor version used to save */
    tiledversion?: string;
    /** Custom properties */
    properties?: TiledProperties;
}
export interface TiledGrid {
    height: number;
    width: number;
    orientation: "orthogonal" | "isometric";
}
export interface TiledTileOffset {
    x: number;
    y: number;
}
export interface TiledTransformations {
    hflip: boolean;
    vflip: boolean;
    rotate: boolean;
    /** Whether untransformed tiles remain preferred */
    preferuntransformed: boolean;
}
export interface TiledTile {
    id: number;
    type?: string;
    image?: string;
    imagewidth?: number;
    imageheight?: number;
    /** sub-rectangle within the tileset image (since 1.9) */
    x?: number;
    y?: number;
    width?: number;
    height?: number;
    /** Collision/object shapes for this tile (optional) */
    objectgroup?: TiledObjectLayer;
    /** Probability weight (editor) */
    probability?: number;
    /** Custom data */
    properties?: TiledProperties;
    /** Legacy terrain info (replaced by Wang sets since 1.5) */
    terrain?: [number, number, number, number];
    /** Animation frames for animated tiles */
    animation?: TiledFrame[];
}
export interface TiledFrame {
    duration: number;
    tileid: number;
}
export interface TiledTerrain {
    name: string;
    tile: number;
    properties?: TiledProperties;
}
export interface TiledWangSet {
    name: string;
    type: "corner" | "edge" | "mixed";
    tile: number;
    colors: TiledWangColor[];
    properties?: TiledProperties;
    /** Optional class (since 1.9) */
    class?: string;
    /** Wang tiles entries */
    wangtiles?: TiledWangTile[];
}
export interface TiledWangColor {
    name: string;
    color: string;
    tile: number;
    probability: number;
    properties?: TiledProperties;
    /** Optional class (since 1.9) */
    class?: string;
}
export interface TiledWangTile {
    tileid: number;
    /** Array of Wang color indexes (uchar[8]) */
    wangid: number[];
}
export interface TiledObjectTemplate {
    type: "template";
    object: TiledObject;
    tileset?: TiledTileset | TiledMapTileset;
}
/** Global Tile ID type alias (unsigned int in JSON) */
export type TiledGID = number;
/** A tile layer data cell is a GID or 0 (empty). */
export type TiledCell = TiledGID;
export {};
//# sourceMappingURL=types.d.ts.map