/**
 * The Arcane Realms' Blender kit (phase 2, 2026-10-08): the 35-piece environment asset sheet
 * (`ASSET-SHEET-35-pieces.png`, design-references arcane-lands-assets) built as painted low-poly GLBs in
 * dreadwoods-backend/quest-workshop (district `arcane`, scripts `arc*_v00N.py` on `arclib.py`), placed as the
 * `dreadmodel` kind with style `<model>-<facing>`, each model a footprint in CAPITAL_BUILDING_MODELS (spread from
 * ARCANE_KIT_MODELS below) and a GLB at the frontend's `public/assets/models/props/buildings/<model>.glb`.
 *
 * The land's layout (ARCANE_BUILDINGS, ARCANE_SLOTS, the dressing in the backend's arcaneLands.ts) does not change:
 * this file only says which kit model stands where a phase 1 placeholder stood (ARCANE_KIT_BUILDINGS, by building id)
 * and which models answer for each sheet piece (ARCANE_KIT_PIECES). A piece with no model yet keeps its placeholder.
 */
import type { ArcaneAssetPiece } from './arcaneLands.js';
import type { CapitalBuildingModel } from './constants.js';
export type ArcaneKitModel = CapitalBuildingModel & {
    /** What a player sees on hover. */
    readonly name: string;
    /** The sheet piece it builds. */
    readonly piece: ArcaneAssetPiece;
    /**
     * A walk-in's furniture (kit 2, 2026-10-08): the room tiles its tables, dais and stores fill, in the model's own
     * frame (the door on +Z), blocked like the walls so nobody walks through a table. Measured from the build script
     * (the FURNITURE list it prints), never guessed; benches, rugs and shelves against the walls are not listed.
     */
    readonly furniture?: ReadonlyArray<readonly [number, number]>;
    /**
     * A deck over water (the Runed Lake Dock): the tiles of its footprint that are laid as boards over the water, in
     * the model's own frame, so the land pass turns that water to a walkable deck at the shore's height.
     */
    readonly deck?: ReadonlyArray<readonly [number, number]>;
};
/** Every kit model's footprint, collision and name (the same table CAPITAL_BUILDING_MODELS spreads in). */
export declare const ARCANE_KIT_MODELS: Readonly<Record<string, ArcaneKitModel>>;
/**
 * Group 5, the sky (arcsky_v001.py): the floating city and the floating rock clusters are drawn by the client's sky
 * (ArcaneSky.ts) from these files, never placed as entities. The city is built 13 tiles in radius (ARCANE_SPIRE.size / 2),
 * the rocks at radius 1 and scaled by each rock's `size`.
 */
export declare const ARCANE_SKY_MODELS: {
    readonly city: "assets/models/props/arcane/arcanefloatingcity.glb";
    readonly rock: "assets/models/props/arcane/arcanefloatingrock.glb";
    readonly rockCrystal: "assets/models/props/arcane/arcanefloatingrockcrystal.glb";
};
export declare const ARCANE_SKY_CITY_RADIUS = 13;
/**
 * The bridges' parapet rows, piece by piece (the backend's arcaneLands.ts lays a parapet tile `i` of `count` along
 * each side of a terrain bridge): a pillar every sixth tile, a five-tile arched span between pillars where one fits,
 * a plain parapet tile at the ends. `null` is a tile a span already covers (place nothing; the row still blocks);
 * `undefined` means the kit has no bridge yet (place the phase 1 stand-in). The facing turns each piece's fascia to
 * the bridge's outer side: the west row of a north-south bridge is as built (`s`), the east row turned (`n`), and an
 * east-west bridge's north row `w`, its south row `e`.
 */
export declare function arcaneBridgePiece(side: 'n' | 'e' | 's' | 'w', i: number, count: number): string | null | undefined;
/** Where a bridge's pillars stand along a parapet row of `count` tiles: both ends and every sixth tile between. */
export declare function arcaneBridgePiers(count: number): number[];
export declare const ARCANE_KIT_MODEL_IDS: readonly string[];
/**
 * The kit model (with its facing) that replaces a placeholder building, by ARCANE_BUILDINGS id. A building not listed
 * keeps its phase 1 stand-in. The facing letter is the building's own (the style's last letter).
 */
export declare const ARCANE_KIT_BUILDINGS: Readonly<Record<string, string>>;
/**
 * The kit models that answer for a sheet piece in the land's dressing (the Rune Isle's obelisks and stones, the shore
 * waystones, the shrine's pedestal...), in the order a `variant` index picks from. Unlisted: still the placeholder.
 */
export declare const ARCANE_KIT_PIECES: Readonly<Partial<Record<ArcaneAssetPiece, readonly string[]>>>;
/**
 * The kit style that fills a slot phase 1 kept clear (ARCANE_SLOTS, by its `asset`): the model with its facing. A
 * slot not listed stays clear ground.
 */
export declare const ARCANE_KIT_SLOTS: Readonly<Partial<Record<ArcaneAssetPiece, string>>>;
/**
 * Where a slot's model stands relative to its slot tile (kit 2): the dock's land end IS the slot tile (the west
 * water's south shore), its deck running four tiles north of its middle out over the lake, so the model's tile is
 * four north of the slot. Unlisted slots stand on their tile.
 */
export declare const ARCANE_KIT_SLOT_OFFSETS: Readonly<Partial<Record<ArcaneAssetPiece, readonly [number, number]>>>;
/** A slot's kit piece as the land pass places it: the style, its tile and the deck tiles it lays over the water. */
export declare function arcaneKitSlot(slot: {
    asset: ArcaneAssetPiece;
    x: number;
    z: number;
}): {
    style: string;
    x: number;
    z: number;
    deck: Array<{
        x: number;
        z: number;
    }>;
} | null;
/**
 * The gardens round a kit walk-in (kit 2, group 7's Hedge and Flower Bed): a flower bed either side of the door on
 * the apron outside the front wall, and a hedge run along the outside of the back wall, in zone-local tiles with the
 * hedge turned to run along the wall. Only the Arcanum's houses, the hut, the hall and the keep have them; the land
 * pass skips any tile that is not open land.
 */
export declare function arcaneKitGardens(buildingId: string, bx: number, bz: number): Array<{
    x: number;
    z: number;
    style: string;
}>;
/**
 * The Rune Fields' pen (the Wooden Fence's slot, ARCANE_SLOTS `wooden-fence`): a rectangle of fence tiles round the
 * slot with a gap on its south side, in zone-local tiles. A row along x is laid `s` (the rail runs along world x), a
 * column along z is laid `e`.
 */
export declare function arcaneFencePen(slot: {
    x: number;
    z: number;
}): Array<{
    x: number;
    z: number;
    style: string;
}>;
export declare function arcaneKitSlotStyle(piece: ArcaneAssetPiece): string | null;
/** The kit model for a piece's `variant`, or null while the piece has no model (keep the placeholder). */
export declare function arcaneKitPiece(piece: ArcaneAssetPiece, variant?: number): string | null;
/** The kit style for a placeholder building, or null. */
export declare function arcaneKitBuildingStyle(buildingId: string): string | null;
/**
 * The tiles a kit walk-in's furniture fills, turned to the style's facing (world offsets from the building's tile), or
 * an empty list for a model with no furniture. The collision blocks them with the walls.
 */
export declare function arcaneKitFurnitureTiles(style: string | undefined): Array<[number, number]>;
/** The tiles a kit deck lays as boards over the water (world offsets from its tile), or an empty list. */
export declare function arcaneKitDeckTiles(style: string | undefined): Array<[number, number]>;
/** The model id at the head of a kit style, when it is one of the kit's. */
export declare function arcaneKitModelId(style: string | undefined): string | null;
/** A facing letter from a direction (dx, dz in world tiles): the way a piece's front should look. */
export declare function arcaneFacingToward(dx: number, dz: number): 'n' | 'e' | 's' | 'w';
//# sourceMappingURL=arcaneKit.d.ts.map