a simple type declaration file for `Tiled Map JSON` (.tmj).

tiledmap-types.ts

declare module 'TiledMap' {

    export namespace TMX {
    // cSpell:disable

        export interface Map {
            backgroundcolor?: string;
            class?: string;
            compressionlevel: number;
            height: number;
            hexsidelength?: number; // hexagonal maps only
            infinite: boolean;
            layers: Layer[];
            nextlayerid: number;
            nextobjectid: number;
            orientation: Orientation;
            parallaxoriginx: number;
            parallaxoriginy: number;
            properties: Property[];
            renderorder: RenderOrder;
            staggeraxis?: StaggerAxis; // staggered / hexagonal maps only
            staggerindex?: StaggerIndex; // staggered / hexagonal maps only
            tiledversion: string;
            tileheight: number;
            tilesets: Tileset[];
            tilewidth: number;
            type: 'map';
            version: string;
            width: number;
        }

        export interface Layer {
            chunks?: Chunk[]; // tilelayer only
            class?: string;
            compression?: Compression; // tilelayer only
            data?: Uint32Array | number[] | string; // tilelayer only
            draworder?: DrawOrder; // objectgroup only
            encoding?: Encoding; // tilelayer only
            height?: number; // tilelayer only
            id: number;
            image?: string; // imagelayer only
            imageheight?: number; // imagelayer only
            imagewidth?: number; // imagelayer only
            layers?: Layer[]; // group only
            locked: boolean;
            name: string;
            objects?: Object[]; // objectgroup only
            offsetx: number;
            offsety: number;
            opacity: number;
            parallaxx: number;
            parallaxy: number;
            properties: Property[];
            repeatx?: boolean; // imagelayer only
            repeaty?: boolean; // imagelayer only
            startx: number;
            starty: number;
            tintcolor?: string;
            transparentcolor?: string; // imagelayer only
            type: LayerType;
            visible: boolean;
            width: number; // tilelayer only
            x: number;
            y: number;
        }

        export interface Chunk {
            data: Uint32Array | number[] | string;
            height: number;
            width: number;
            x: number;
            y: number;
        }

        export interface Object {
            ellipse: boolean;
            gid: number;
            height: number;
            id: number;
            name: string;
            point: boolean;
            polygon: Point[];
            polyline: Point[];
            properties: Property[];
            rotation: number;
            template: string;
            text?: Text; // text objects only
            type?: string;
            visible: boolean;
            width: number;
            x: number;
            y: number;
        }

        export interface Text {
            bold: boolean;
            color: string;
            fontfamily: string;
            halign: HAlign;
            italic: boolean;
            kerning: boolean;
            pixelsize: number;
            strikeout: boolean;
            text: string;
            underline: boolean;
            valign: VAlign;
            wrap: boolean;
        }

        export interface Tileset {
            backgroundcolor?: string;
            class?: string;
            columns: number;
            fillmode: FillMode;
            firstgid: number;
            grid?: Grid;
            image: string;
            imageheight: number;
            imagewidth: number;
            margin: number;
            name: string;
            objectalignment: ObjectAlignment;
            properties: Property[];
            source: string;
            spacing: number;
            terrains?: Terrain[];
            tilecount: number;
            tiledversion: string;
            tileheight: number;
            tileoffset?: TileOffset;
            tilerendersize: TileRenderSize;
            tiles?: Tile[];
            tilewidth: number;
            transformations?: Transformation;
            transparentcolor?: string;
            type: 'tileset';
            version: string;
            wangsets: WangSet[];
        }

        export interface Grid {
            height: number;
            orientation: GridOrientation;
            width: number;
        }

        export interface TileOffset {
            x: number;
            y: number;
        }

        export interface Transformation {
            hflip: boolean;
            vflip: boolean;
            rotate: boolean;
            preferuntransformed: boolean;
        }

        export interface Tile {
            animation: Frame[];
            id: number;
            image?: string;
            imageheight: number;
            imagewidth: number;
            x: number;
            y: number;
            width: number;
            height: number;
            objectgroup?: ObjectGroup;
            probability?: number;
            properties: Property[];
            terrain?: number[];
            type?: string;
        }

        export interface Frame {
            duration: number;
            tileid: number;
        }

        export interface Terrain {
            name: string;
            properties: Property[];
            tile: number;
        }

        export interface WangSet {
            class?: string;
            colors: string;
            name: string;
            properties: Property[];
            tile: number;
            type: WangType;
        }

        export interface WangColor {
            class?: string;
            color: string;
            name: string;
            probability: number;
            properties: Property[];
            tile: number;
        }

        export interface WangTile {
            tileid: number;
            wangid: Uint8Array | number[];
        }

        export interface ObjectTemplate {
            type: 'template';
            tileset?: Tileset;
            object: Object;
        }

        export interface Property {
            name: string;
            type: PropertyType;
            propertytype: string;
            value: string | number | boolean | object;
        }

        export interface Point {
            x: number;
            y: number;
        }


        /////////////////////////////
        //
        // Custom Enum-like Types
        //
        /////////////////////////////

        export type Orientation = 'orthogonal' | 'isometric' | 'staggered' | 'hexagonal';
        export type GridOrientation = 'orthogonal' | 'isometric';
        export type RenderOrder = 'right-down' | 'right-up' | 'left-down' | 'left-up';
        export type DrawOrder = 'topdown' | 'index';
        export type Encoding = 'csv' | 'base64';

        export type StaggerAxis = 'x' | 'y';
        export type StaggerIndex = 'odd' | 'even';
        export type Compression = 'zlib' | 'gzip' | 'zstd' | '';
        export type LayerType = 'tilelayer' | 'objectgroup' | 'imagelayer' | 'group';
        export type HAlign = 'center' | 'right' | 'justify' | 'left';
        export type VAlign = 'center' | 'bottom' | 'top';
        export type ObjectAlignment = 'unspecified' | 'topleft' | 'top' | 'topright' | 'left' | 'center' | 'right' | 'bottomleft' | 'bottom' | 'bottomright';

        export type PropertyType = 'string' | 'int' | 'float' | 'bool' | 'color' | 'file' | 'object' | 'class';
        export type FillMode = 'stretch' | 'preserve-aspect-fit';
        export type WangType = 'corner' | 'edge' | 'mixed';

        export type TileRenderSize = 'tile' | 'grid';


        /////////////////////////////
        //
        // Custom Interfaces
        //
        /////////////////////////////

        export interface TileLayer extends Layer {
            type: 'tilelayer';
            chunks: Chunk[]; // tilelayer only
            compression: Compression; // tilelayer only
            data: Uint32Array | number[] | string; // tilelayer only
            encoding: Encoding; // tilelayer only
            height: number; // tilelayer only
            width: number; // tilelayer only
        }

        export interface ImageLayer extends Layer {
            type: 'imagelayer';
            image: string; // imagelayer only
            imageheight: number; // imagelayer only
            imagewidth: number; // imagelayer only
            repeatx: boolean; // imagelayer only
            repeaty: boolean; // imagelayer only
            transparentcolor: string; // imagelayer only
        }

        export interface ObjectGroup extends Layer {
            type: 'objectgroup';
            draworder: DrawOrder; // objectgroup only
            objects: Object[]; // objectgroup only
        }

        export interface PixelCoord extends Point {
            // x: number;
            // y: number;
        }

        export interface TileCoord {
            col: number;
            row: number;
        }

    // cSpell:enable
    }

}

the cSpell:.... is used to disable cSpell extention , because the cSpell will report many warings for the keys in these interfaces.