/**
 * THE CAPITAL
 *
 * The walled capital of the northern kingdoms, in the open green east of the
 * Thaw. Redesigned 2026-09-25 from James's masterplan and district sheets
 * (design-references/capital-*; the layout spec and its checking plan script
 * are summarised in the phase-1 commit). The plan in one breath:
 *
 * - One north-south spine, the Royal Way (u 149-155), from the North Gate
 *   past Victory Plaza, the Crown Cross and the Noble Cross to the South
 *   Gate. Both of those gates are built and barred.
 * - Two east-west primaries: Crown Street (v 62-66) the full width of the
 *   city on the painted road, and the King's Road (v 82-86, the keep axis,
 *   CAPITAL_AVENUE_Z) from the Great Gate in the west wall to the Crown
 *   Cross and up the ramp to the keep. The Harbour Road runs the same rows
 *   from the East Gate to the mound's foot.
 * - The keep on its mound east of the Way, still facing west; the districts
 *   where the masterplan paints them: Trade NW, Temple Gardens NE, the
 *   Westgate Outpost, Forge and Military Ward west of the Way, the Keep and
 *   the Royal Quarter centre-east, the Noble Quarter SE.
 *
 * CITY-LOCAL TILES. Every plan table below is written in city-local tiles,
 * `u = x - CAPITAL_MIN_X` (0..280, west to east) and `v = z - CAPITAL_NORTH_Z`
 * (0..168, north to south): the walls are u 0-1, u 279-280, v 0-1 and
 * v 167-168, the buildable interior u 2-278, v 2-166. `cu()` / `cv()` turn
 * them into world tiles; every row also carries its world rect or tile, so
 * nothing downstream has to convert by hand. Never write a world literal for
 * a Capital coordinate: the map has already moved under the city once.
 *
 * World tiles; the north pad is part of the grid, so no toWorldZ.
 * Backend builder: capitalCity.ts. Assets: capitalAssets.ts (keep, statue,
 * fountain), capitalFabric.ts (walls, gatehouse, bridge, buildings, props),
 * buildingModels.ts (the Blender buildings, kind `capitalbuilding`).
 */
import { SurfaceType, type EntityKind } from './constants.js';
/** The outer wall: two tiles thick, these are the OUTER rows. */
export declare const CAPITAL_MIN_X = 480;
export declare const CAPITAL_MAX_X = 760;
export declare const CAPITAL_NORTH_Z = 76;
export declare const CAPITAL_SOUTH_Z = 244;
export declare const CAPITAL_WALL_THICK = 2;
export declare const CAPITAL_BASTION_EVERY = 16;
/** Inside the wall: the first row a building can stand on. */
export declare const CAPITAL_INNER_MIN_X: number;
export declare const CAPITAL_INNER_MAX_X: number;
export declare const CAPITAL_INNER_NORTH_Z: number;
export declare const CAPITAL_INNER_SOUTH_Z: number;
/** City-local column to world x: u 0 is the west wall's outer row. */
export declare function cu(u: number): number;
/** City-local row to world z: v 0 is the north wall's outer row. */
export declare function cv(v: number): number;
/** World x back to a city-local column. */
export declare function capU(x: number): number;
/** World z back to a city-local row. */
export declare function capV(z: number): number;
/** A city-local tile as a world tile. */
export declare function capWorld(u: number, v: number): {
    x: number;
    z: number;
};
/** A city-local rect (inclusive) as a world rect (inclusive). */
export declare function capWorldRect(r: {
    u0: number;
    u1: number;
    v0: number;
    v1: number;
}): {
    minX: number;
    maxX: number;
    minZ: number;
    maxZ: number;
};
/** The moat: eight tiles of water outside the wall; the north side runs into the sea. */
export declare const CAPITAL_MOAT_W = 8;
export declare const CAPITAL_MOAT_MIN_X: number;
export declare const CAPITAL_MOAT_MAX_X: number;
export declare const CAPITAL_MOAT_NORTH_Z: number;
export declare const CAPITAL_MOAT_SOUTH_Z: number;
/** The King's Road's rows: the keep axis, the Great Gate and the East Gate. 160 after the northern extension. */
export declare const CAPITAL_AVENUE_Z: number;
export declare const CAPITAL_AVENUE_HALF_W = 2;
/** The basin before the main gate: the moat widened west so the bridge is long. */
export declare const CAPITAL_POOL: {
    readonly minX: number;
    readonly maxX: number;
    readonly minZ: number;
    readonly maxZ: number;
};
/** Ground inside the walls; the bank outside the moat; the water. */
export declare const CAPITAL_FLOOR_H = 2;
export declare const CAPITAL_BANK_H = 1;
export declare const CAPITAL_MOAT_H = 0;
/** Everything the city owns, for the sweep, the levelling and the discovery zone. */
export declare const CAPITAL_WORKS: {
    readonly minX: number;
    readonly maxX: number;
    readonly minZ: number;
    readonly maxZ: number;
};
/** The Royal Way: seven wide (u 149-155, Path kerbs on its outer columns), a grass verge four wide either side. */
export declare const CAPITAL_ROYAL_WAY_X: number;
export declare const CAPITAL_ROYAL_WAY_HALF_W = 3;
export declare const CAPITAL_ROYAL_WAY_VERGE = 4;
/** Crown Street, five wide on the painted road (v 62-66). */
export declare const CAPITAL_CROWN_Z: number;
/** The Noble Walk, five wide along the mound's south foot (v 102-106). */
export declare const CAPITAL_NOBLE_WALK_Z: number;
/** Primary routes are five wide: half-width two, Stone with Path kerb rows. */
export declare const CAPITAL_PRIMARY_HALF_W = 2;
/** Every gate passage is five wide. */
export declare const CAPITAL_GATE_HALF_W = 2;
/** The Great Gate in the west wall, open: the land arrival (decision D1-B, unchanged). */
export declare const CAPITAL_MAIN_GATE: {
    readonly x: 480;
    readonly z: number;
};
/** The East Gate, open: the harbour's Dock Gate. */
export declare const CAPITAL_EAST_GATE: {
    readonly x: 760;
    readonly z: number;
};
/** The North Gate at the Way's north end: built, barred (the sea is beyond it). */
export declare const CAPITAL_NORTH_GATE: {
    readonly x: number;
    readonly z: 76;
};
/**
 * The South Gate at the Way's south end, the Dreadwoods gate. Open since
 * James's word on D2 (2026-09-25, "yes we should add a pathway to
 * dreadwoods"): the South Bridge carries the Way over the moat to the
 * Dreadwoods north gate, straight into the PvP woods.
 */
export declare const CAPITAL_SOUTH_GATE: {
    readonly x: number;
    readonly z: 244;
};
/**
 * The four city gates as the builder places them. `style` is the gatehouse
 * style (constants.ts `visitGatehouseOffsets`): a `shut` token keeps the
 * passage blocked in the shared collision, so a barred gate needs nothing
 * else from the builder, and the wall rows under it stay unpaved. The
 * facing letter is always the LAST token (the frontend turns by it).
 */
export declare const CAPITAL_GATES: ReadonlyArray<{
    id: 'west' | 'east' | 'north' | 'south';
    name: string;
    x: number;
    z: number;
    style: string;
    open: boolean;
}>;
/** The first interior tile inside each open gate's passage, where the walks are measured from. */
export declare const CAPITAL_WEST_MOUTH: {
    readonly u: 2;
    readonly v: 84;
    readonly x: number;
    readonly z: number;
};
export declare const CAPITAL_EAST_MOUTH: {
    readonly u: number;
    readonly v: 84;
    readonly x: number;
    readonly z: number;
};
/** The bridge over the pool: seven rows, the outer two carry the parapet and the knights. */
export declare const CAPITAL_BRIDGE_MIN_X: number;
/** The bridge's crown: the middle third of the deck stands one height up. */
export declare const CAPITAL_BRIDGE_CROWN_H: number;
export declare const CAPITAL_BRIDGE_MAX_X: number;
export declare const CAPITAL_BRIDGE_HALF_W = 3;
/** The barbican on the far bank, astride the road before the bridge. */
export declare const CAPITAL_BARBICAN: {
    readonly x: number;
    readonly z: number;
};
export declare const CAPITAL_BRIDGE_KNIGHTS: ReadonlyArray<{
    x: number;
    z: number;
    facing: 'n' | 's' | 'e' | 'w';
}>;
/**
 * The South Bridge (D2): the Way's seven rows carried on over the south moat,
 * from the South Gate's passage to the grass strip under the Dreadwoods
 * north wall. The deck is terrain at the city floor, the parapets run along
 * its east and west edges.
 */
export declare const CAPITAL_SOUTH_BRIDGE: {
    readonly minX: number;
    readonly maxX: number;
    readonly minZ: number;
    readonly maxZ: number;
};
/** The rows that cross water (the moat); the rest of the bridge is its landing on the strip. */
export declare const CAPITAL_SOUTH_BRIDGE_DECK_MAX_Z: number;
export declare function onCapitalSouthBridge(x: number, z: number): boolean;
/** The Dreadwoods gate the South Bridge meets: five tiles cut from the woods' north wall on the Way's line. */
export declare const DREADWOODS_NORTH_GATE_X: number;
export declare const DREADWOODS_NORTH_GATE_HALF_W = 2;
export declare function inDreadwoodsNorthGate(x: number, z: number): boolean;
/** The road in, gate throat included, until it gives out in the ash. */
export declare const DREADWOODS_NORTH_ROAD_INNER_TILES = 8;
export declare function inDreadwoodsNorthRoad(x: number, z: number): boolean;
/** The ring lane inside the wall: three wide, one tile in (u 2-4, u 276-278, v 2-4, v 164-166). */
export declare const CAPITAL_RING_INSET = 1;
export declare const CAPITAL_STREET_HALF_W = 1;
/**
 * The keep's mound: a plateau at CAPITAL_MOUND_H with a slope of one height
 * a tile all round it (u 160-220, v 66-102), the King's Road climbing the
 * west slope as the ramp (u 160-165) to the Inner Gate. Crown Street runs on
 * its north foot, the Noble Walk on its south foot, the Harbour Road stops at
 * its east foot.
 */
export declare const CAPITAL_MOUND_H = 8;
export declare const CAPITAL_PLATEAU: {
    readonly minX: number;
    readonly maxX: number;
    readonly minZ: number;
    readonly maxZ: number;
};
/** The inner gatehouse on the plateau's west edge; the curtain runs round the edge with this one gap. */
export declare const CAPITAL_INNER_GATE: {
    readonly x: number;
    readonly z: number;
};
/**
 * The keep, thirty tiles in from the plateau's west edge, door west onto the
 * Audience Court (decision D3 default). Its half-extents are constants.ts's
 * CASTLE_KEEP_HALF_X/Z (the collision and the asset read those).
 */
export declare const CAPITAL_KEEP: {
    readonly x: number;
    readonly z: number;
};
/** The King's Statue in the Audience Court, between the Inner Gate and the keep door. */
export declare const CAPITAL_KING_STATUE: {
    readonly x: number;
    readonly z: number;
};
/** The King's Fountain on the Way's axis in the Crown Cross; the Way splits round it. */
export declare const CAPITAL_KINGS_FOUNTAIN: {
    readonly x: number;
    readonly z: number;
};
/**
 * The stand in the Drill Square with a clear three-tile ring round it: the
 * outfit capture pass, walk-capture and the smokes' closing /tp use it.
 */
export declare const CAPITAL_DRILL_STAND: {
    readonly x: number;
    readonly z: number;
};
/** The road in: from the Thaw arch's east road, round to the barbican. */
export declare const CAPITAL_ROAD: ReadonlyArray<{
    x: number;
    z: number;
}>;
/** A city-local rect, inclusive, with its world rect. */
export type CapRect = {
    readonly id: string;
    readonly u0: number;
    readonly u1: number;
    readonly v0: number;
    readonly v1: number;
    readonly minX: number;
    readonly maxX: number;
    readonly minZ: number;
    readonly maxZ: number;
};
/** A city-local tile with its world tile. */
export type CapTile = {
    readonly u: number;
    readonly v: number;
    readonly x: number;
    readonly z: number;
};
/** The district identities (spec A.4): banner emblems and roof tokens. */
export type CapitalEmblem = 'tree' | 'scales' | 'crown' | 'anvil' | 'hammers-red' | 'lion' | 'cross' | 'trident' | 'anchor';
/** Roof colour tokens: blue slate everywhere in the Capital; the four manors are blue, green, red and purple. */
export type CapitalRoofToken = 'blue' | 'green' | 'red' | 'purple' | 'slate' | 'tan';
/**
 * Ground tokens and the surface each is laid in. The Capital's paving
 * (frontend CapitalPaving.ts) draws Stone as big flags and Path as setts, so
 * 'flag' is Stone and 'setts' is Path. There is no gravel surface yet: the
 * temple and noble walks are laid as Path until there is one.
 */
export type CapitalGround = 'stone' | 'flag' | 'setts' | 'path' | 'gravel' | 'dirt' | 'grass';
export declare function capitalSurface(ground: CapitalGround): SurfaceType;
/**
 * The routes (spec A.2). `primary` and `way` are the wide stone roads with
 * Path kerb rows on their outer rows (kerb: true); lanes and walks take their
 * district's ground. Lamps stand every `lamps.every` tiles on the kerbs,
 * alternating sides, never on the paving. The Way's verges (grass, `verge`
 * tiles wide either side) carry a tree every 8 alternating with a crown pole
 * every 8 on the kerbs; inside a plaza the verge is paved over.
 */
export type CapitalRouteKind = 'primary' | 'way' | 'lane' | 'walk';
export type CapitalRoute = CapRect & {
    readonly name: string;
    readonly kind: CapitalRouteKind;
    readonly surface: Extract<CapitalGround, 'stone' | 'flag' | 'path' | 'gravel' | 'dirt'>;
    readonly kerb?: boolean;
    readonly lamps?: {
        readonly every: number;
        readonly alternate: boolean;
    };
    readonly verge?: number;
};
export declare const CAPITAL_ROUTES: ReadonlyArray<CapitalRoute>;
/**
 * The plazas, squares, courts and door aprons (spec A.3). `apron` rows are
 * the paved strips that join a door to a route. `forLandmark` names the
 * building an apron serves: until that building stands (capitalPlacementNow),
 * the apron is not laid and the ground under it shows through (paving that
 * ends at nothing reads as unfinished work). The row stays in the table, so
 * the rect stays reserved and the later phase needs no re-plan.
 */
export type CapitalPlaza = CapRect & {
    readonly name: string;
    readonly surface: Extract<CapitalGround, 'stone' | 'setts' | 'flag' | 'gravel'>;
    readonly apron?: boolean;
    readonly forLandmark?: string;
};
export declare const CAPITAL_PLAZAS: ReadonlyArray<CapitalPlaza>;
/**
 * The greens: lawns, gardens, orchards, the graveyard, the paddock and the
 * Way's verges. A `wall` rings the rect's edge tiles (the builder lays one
 * gardenwall run entity per straight run, constants.ts `gardenWallRunStyle`)
 * except at the `gates` tiles, which are openings (a gate piece, or nothing
 * for a wide opening). `groves` is how many merged grove entities
 * (`tree grove-3` / `grove-5`) to scatter on the tiles that end as lawn,
 * seeded by the row's id so moving anything else reshuffles nothing.
 */
export type CapitalGreenKind = 'lawn' | 'garden' | 'orchard' | 'graveyard' | 'paddock' | 'verge';
export type CapitalWallLook = 'garden' | 'hedge' | 'noble' | 'fence';
export type CapitalGreen = CapRect & {
    readonly name: string;
    readonly kind: CapitalGreenKind;
    readonly wall?: CapitalWallLook;
    readonly gates?: ReadonlyArray<readonly [number, number]>;
    readonly groves?: number;
};
export declare const CAPITAL_GREENS: ReadonlyArray<CapitalGreen>;
/**
 * The working yards (Dirt). A fenced yard is ringed by a fence run with its
 * `gates` tiles open (the Charcoal Yard's nine are its open side onto Anvil
 * Square). Gates listed off the ring are harmless (the plan script kept one
 * on the Drill Lane). A yard with a later `phase` than CAPITAL_BUILD_PHASE is
 * not laid yet: its ground stays lawn (a bare dirt lot with nothing in it
 * reads as unfinished).
 */
export type CapitalYard = CapRect & {
    readonly name: string;
    readonly surface: Extract<CapitalGround, 'dirt' | 'stone'>;
    readonly fence?: boolean;
    readonly gates?: ReadonlyArray<readonly [number, number]>;
    readonly phase?: 1 | 2 | 3;
};
export declare const CAPITAL_YARDS: ReadonlyArray<CapitalYard>;
export type CapitalDistrictId = 'capital-castle' | 'capital-merchant' | 'capital-gate' | 'capital-market' | 'capital-smiths' | 'capital-garrison' | 'capital-temple' | 'capital-noble';
export type CapitalDistrict = CapRect & {
    readonly id: CapitalDistrictId;
    readonly label: string;
    readonly street: 'path' | 'dirt' | 'stone' | 'gravel';
    readonly roofs: ReadonlyArray<CapitalRoofToken>;
    readonly emblem: CapitalEmblem;
};
export declare const CAPITAL_DISTRICTS: ReadonlyArray<CapitalDistrict>;
/**
 * The phase the city is built to. A plan row whose `phase` is later than
 * this stands as its `standIn` if the stand-in's phase has come, and
 * otherwise is not built yet; its footprint is still reserved, so the later
 * phase lands on a clear plot and reshuffles nothing.
 */
export declare const CAPITAL_BUILD_PHASE: 1 | 2 | 3;
/** Kinds a plan row can be placed as today (every one an EntityKind). */
export type CapitalPlacedKind = Extract<EntityKind, 'stonehouse' | 'temple' | 'forgehall' | 'warehouse' | 'manor' | 'castle' | 'citywall' | 'capitalbuilding' | 'marketstall' | 'statue' | 'fountain' | 'hoodedstatue' | 'yardprop' | 'caveentrance'>;
/** Kinds the plan names for a later phase that do not exist yet (the phase-2 shed, the phase-3 crypt). */
export type CapitalFutureKind = 'shed' | 'mausoleum';
export type CapitalStandIn = {
    readonly kind: CapitalPlacedKind;
    readonly style: string;
    /** When the stand-in arrives (default 1). */
    readonly phase?: 1 | 2 | 3;
    /** Its own centre when it is not the plot's (city-local). */
    readonly u?: number;
    readonly v?: number;
};
export type CapitalFacing = 'n' | 's' | 'e' | 'w';
/**
 * A building's door as the plan checked it: the door tile on the footprint
 * ring (the middle of the facing side) and the mouth width (1 for a door;
 * 3, 5 or 7 for an open-fronted shed or hall). The approach tile is the one
 * outside it; nothing may stand on either.
 */
export type CapitalDoor = CapTile & {
    readonly facing: CapitalFacing;
    readonly mouth: number;
};
export type CapitalLandmark = {
    readonly id: string;
    readonly name: string;
    readonly district: CapitalDistrictId;
    /** The final building (at `phase`). */
    readonly kind: CapitalPlacedKind | CapitalFutureKind;
    readonly style: string;
    readonly phase: 1 | 2 | 3;
    readonly standIn?: CapitalStandIn;
    /** Centre tile. */
    readonly u: number;
    readonly v: number;
    readonly x: number;
    readonly z: number;
    /** The plot the plan reserved (the final building's footprint). */
    readonly footprint: CapRect;
    /** null for a solid building (no way in). */
    readonly door: CapitalDoor | null;
    /** Paved forecourt, lights and (civic fronts) banners, as heroFront() lays them. */
    readonly heroFront?: boolean;
    /**
     * A free-standing placard naming the place (never a trade description),
     * stood beside the door's approach, never on its axis. Only for a front
     * whose asset hangs no sign of its own (the stonehouse trade variants,
     * bank, inn, lodge, clothes, shop, kitchen and potion, hang theirs), and
     * only once something inside serves the player: the halls standing in for
     * the Guild Hall, the Barracks and the Royal Administration get theirs
     * with their staff (phase 2).
     */
    readonly board?: string;
    readonly emblem?: CapitalEmblem;
};
/**
 * The buildings, in placing order (spec B, plan script `B`). Phase-1 rows
 * are REUSE kinds on their final plots; the Trade Hall stands as its
 * Blender building (decision D5); the Capital Bank, the Royal
 * Administration and the Barracks stand as their stand-ins; the sheds, the
 * new stonehouse variants and the crypt wait for phases 2 and 3.
 */
export declare const CAPITAL_LANDMARKS: ReadonlyArray<CapitalLandmark>;
/**
 * The monuments: statues and fountains on their plinths, solid. `size` is
 * the square the plan reserves (a 5x5 stepped plinth, or 3x3): a statue
 * fills and blocks it with its stepped plinth, a 3x3 fountain basin stands
 * in the middle of a 5x5; keep dressing off the whole square.
 */
export type CapitalMonument = {
    readonly id: string;
    readonly name: string;
    readonly district: CapitalDistrictId;
    readonly kind: Extract<CapitalPlacedKind, 'statue' | 'fountain' | 'capitalbuilding' | 'hoodedstatue'>;
    readonly style: string;
    readonly phase: 1 | 2 | 3;
    readonly standIn?: CapitalStandIn;
    readonly u: number;
    readonly v: number;
    readonly x: number;
    readonly z: number;
    readonly size: 3 | 5;
    readonly footprint: CapRect;
};
export declare const CAPITAL_MONUMENTS: ReadonlyArray<CapitalMonument>;
/**
 * What stands for a plan row in `phase` (default CAPITAL_BUILD_PHASE): the
 * row itself once its phase has come, else its stand-in once the stand-in's
 * phase has come, else null (not built yet; the plot stays reserved).
 */
export declare function capitalPlacementNow(row: {
    kind: CapitalPlacedKind | CapitalFutureKind;
    style: string;
    phase: 1 | 2 | 3;
    u: number;
    v: number;
    standIn?: CapitalStandIn;
}, phase?: number): {
    kind: CapitalPlacedKind;
    style: string;
    u: number;
    v: number;
    x: number;
    z: number;
    standIn: boolean;
} | null;
/** The tiles a door opens on the ring: its middle tile and the rest of its mouth, along the facing side. */
export declare function capitalDoorTiles(door: CapitalDoor): CapTile[];
/** The approach tiles: one step out from each door tile. Nothing may stand on these (nor on the door). */
export declare function capitalDoorApproach(door: CapitalDoor): CapTile[];
/**
 * The working stations (spec B.11), each on its exact tile: the builder
 * places them with tileProp and asserts (throws in dev, logs in prod); the
 * smoke checks each exists unsnapped with a free standable tile within
 * `range` (the game's own reach constant). `inside` is the landmark it
 * belongs to. Stoves and campfires must be placed at build time: world.ts
 * registers cook spots once.
 *
 * Phase 1: 3 bank chests, 5 furnaces, 5 anvils, 3 charcoal mounds, 12
 * training dummies, 2 shrines (bare: the ice-seal look until the Temple
 * Altar style), the Cookhouse and inn stoves, the muster campfire, 4
 * bounty boards and the Ranger Hall bench. The Main Forge's four stand in
 * the open Furnace Yard until its building (phase 2).
 */
export type CapitalStation = CapTile & {
    readonly id: string;
    readonly kind: EntityKind;
    readonly style?: string;
    readonly scale?: number;
    readonly range: number;
    readonly inside?: string;
    readonly phase: 1 | 2 | 3;
};
export declare const CAPITAL_STATIONS: ReadonlyArray<CapitalStation>;
/**
 * The market stalls: four clusters of three round a keeper's tile (the
 * counters front outward, the keeper serves from the middle), plus the Food
 * Court's row of three fronting the court. Style `<goods>-<facing>` as
 * marketStall.ts reads it; the covered trader's cluster sells pots until its
 * canopy restyle (phase 3). Keepers arrive in phase 2 (CAPITAL_NPC_SPOTS).
 */
export type CapitalStall = CapTile & {
    readonly id: string;
    readonly cluster: 'produce' | 'fish' | 'cloth' | 'trader' | 'food';
    readonly goods: 'produce' | 'fish' | 'cloth' | 'pots';
    readonly facing: CapitalFacing;
    readonly style: string;
    readonly phase: 1 | 2 | 3;
};
export declare const CAPITAL_STALLS: ReadonlyArray<CapitalStall>;
/**
 * Wayfinding and the gate braziers, placed by the plan and kept off every
 * door approach. Fingerposts name places only; `capitalFingerpostStyle`
 * builds their signpost style. The braziers stand beside the gate guards'
 * tiles, never on them (finding F5).
 */
export type CapitalFixture = CapTile & {
    readonly id: string;
    readonly kind: 'signpost' | 'yardprop';
    readonly style: string;
    readonly names?: ReadonlyArray<string>;
};
/** A fingerpost's signpost style: `fingerpost-<place>|<place>|...`. The frontend draws one slat per place. */
export declare function capitalFingerpostStyle(names: ReadonlyArray<string>): string;
/** The places on a `fingerpost-` style, or null for any other style. */
export declare function parseFingerpostStyle(style: string | undefined): string[] | null;
export declare const CAPITAL_FIXTURES: ReadonlyArray<CapitalFixture>;
/**
 * The tiles the phase-2 NPC roster (spec B.10) will stand on. Nothing is
 * spawned here in phase 1; the builder keeps these tiles free of dressing
 * and furniture so the roster lands without moving anything. `role` is the
 * intended kind (and shop), not yet an NpcKind.
 */
export type CapitalNpcSpot = CapTile & {
    readonly id: string;
    readonly name: string;
    readonly role: string;
};
export declare const CAPITAL_NPC_SPOTS: ReadonlyArray<CapitalNpcSpot>;
/**
 * The Capital's guards (2026-09-21, redesigned 2026-09-25): level 40 in
 * steel, in pairs, 14 of them. Inside the Great Gate, on the Audience Court
 * either side of the keep's door, just inside the throne hall's door, inside
 * the East Gate, at the harbour end of its bridge, and in the courts of the
 * two barred gates. `faceX`/`faceZ` is what each pair watches. The hall pair
 * is `still`: the hall's furniture is client-side and a pacing guard would
 * walk through the feast tables. The first post is the admin links' Great
 * Gate guard; keep it first.
 */
export declare const CAPITAL_GUARD_POSTS: ReadonlyArray<{
    id: string;
    x: number;
    z: number;
    faceX: number;
    faceZ: number;
    still?: true;
}>;
/**
 * The walking budgets (spec A.6), read by capital-smoke.ts: an 8-way walk
 * with no corner cutting from `from` to `to` must take at most `max` tiles.
 * `to` is a landmark id (its door tile), a station id (the nearest tile
 * within the station's range) or a tile (the nearest tile within `range`).
 * `planned` is what the plan script measured.
 */
export type CapitalWalkBudget = {
    readonly id: string;
    readonly from: CapTile;
    readonly to: string | (CapTile & {
        readonly range?: number;
    });
    readonly max: number;
    readonly planned: number;
};
export declare const CAPITAL_WALK_BUDGETS: ReadonlyArray<CapitalWalkBudget>;
export declare function inCapitalWalls(x: number, z: number): boolean;
/** Any tile of the two-thick outer wall. */
export declare function onCapitalWall(x: number, z: number): boolean;
export declare function inCapitalInterior(x: number, z: number): boolean;
export declare function onCapitalBridge(x: number, z: number): boolean;
/**
 * The water of the moat and the pool, the bridge excepted. The wall side of
 * the moat is a straight retaining edge; the outer bank wanders a tile or
 * two so it is a river and not a trench, and the pool before the Great Gate
 * is a rounded basin (an ellipse from the gate) rather than a box.
 */
export declare function inCapitalMoat(x: number, z: number): boolean;
export declare function inCapitalPlateau(x: number, z: number): boolean;
/** The mound's height at a tile: the plateau, or the slope down from it, or the floor. */
export declare function capitalMoundHeight(x: number, z: number): number;
/**
 * The route on a tile, in paint order: the Royal Way over the primaries over
 * the lanes and walks. Interior tiles only.
 */
export declare function capitalRouteAt(x: number, z: number): CapitalRoute | undefined;
export declare function capitalPlazaAt(x: number, z: number): CapitalPlaza | undefined;
export declare function capitalGreenAt(x: number, z: number): CapitalGreen | undefined;
export declare function capitalYardAt(x: number, z: number): CapitalYard | undefined;
export type CapitalGroundLayer = 'way' | 'primary' | 'lane' | 'walk' | 'plaza' | 'plateau' | 'mound' | 'green' | 'yard' | 'lawn';
/**
 * What the plan lays on an interior tile, in the builder's paint order
 * (spec G.2): the Royal Way, then the primaries, the lanes and walks, the
 * plazas, the mound (plateau Stone, banks Grass), the greens and yards, and
 * lawn under everything. Kerb rows of the kerbed routes are Path. Buildings
 * floor their own footprints on top (buildingFloorSurface); the gate
 * passages and the keep are the builder's. What is not built in this phase
 * is not laid: an apron whose building does not stand yet, a yard of a later
 * phase (the rects stay in the tables, reserved).
 */
export declare function capitalGroundAt(x: number, z: number): {
    layer: CapitalGroundLayer;
    id?: string;
    surface: SurfaceType;
} | undefined;
/** The ring lane inside the wall. */
export declare function onCapitalRingRoad(x: number, z: number): boolean;
/** The Royal Way's paving (u 149-155, the North Gate to the South Gate). */
export declare function onCapitalWay(x: number, z: number): boolean;
/**
 * The keep axis: the King's Road's rows from the Great Gate to the Inner
 * Gate on the plateau's edge (it crosses the Way at the Crown Cross and
 * climbs the ramp).
 */
export declare function onCapitalAvenue(x: number, z: number): boolean;
/** A primary route tile (Crown Street, the King's Road and its ramp, the Harbour Road); not the Way. */
export declare function onCapitalPrimary(x: number, z: number): boolean;
/** A street tile: any route in the table (the Way, the primaries, the lanes and walks, the ring lane). */
export declare function onCapitalStreet(x: number, z: number): boolean;
/** A plaza, square, court or door apron tile. */
export declare function onCapitalPlaza(x: number, z: number): boolean;
export declare function capitalDistrictAt(x: number, z: number): CapitalDistrict | undefined;
//# sourceMappingURL=capital.d.ts.map