@adatechnology/game-urban 0.0.0-stage → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1769 @@
+import * as _adatechnology_game_floorplan from '@adatechnology/game-floorplan';
+import { SilhouettePart, SilhouetteWindow, RandomSource, Silhouette } from '@adatechnology/game-floorplan';
+export { RandomSource, Silhouette, SilhouettePart, SilhouetteWindow } from '@adatechnology/game-floorplan';
+import { DeepPartial } from '@adatechnology/game-contracts';
+import { Region } from '@adatechnology/game-vegetation-species';
+
+type Trig = 'sin' | 'cos';
+type Point = readonly [number, number];
+type Rect = readonly [number, number, number, number];
+/** One term of a rolling surface. `product`: `fx(kx·px) · fy(ky·py) · amplitude`. `diagonal`: `sin(kx·px + ky·py) · amplitude`. */
+type Wave = {
+    kind: 'product';
+    x: readonly [Trig, number];
+    y: readonly [Trig, number];
+    amplitude: number;
+} | {
+    kind: 'diagonal';
+    kx: number;
+    ky: number;
+    amplitude: number;
+};
+/** A factor of a mask: a smoothstep along one axis. With `fullUntil`, everything before that value counts as 1. */
+type Ramp = {
+    axis: 'x' | 'y';
+    from: number;
+    to: number;
+    fullUntil?: number;
+};
+/** A region that adds relief: `mask · (level + waves)`. The mask is the product of its ramps. */
+type TerrainLayer = {
+    id: string;
+    mask: readonly Ramp[];
+    level: number;
+    waves: readonly Wave[];
+};
+/** Levels a rectangle (a city) towards `level`, from `margin` outside it to the inside, by a smoothstep of the distance to its nearest edge. */
+type Flatten = {
+    id: string;
+    rect: Rect;
+    margin: number;
+    edge: readonly [number, number];
+    level: number;
+};
+/** The bed of a river: a fixed height, or `below` the surrounding ground but never lower than `floor`. */
+type RiverBed = {
+    fixed: number;
+} | {
+    below: number;
+    floor: number;
+};
+/** A river as a polyline; the ground eases from the bed to the land between the two distances of `width`. */
+type River = {
+    id: string;
+    points: readonly Point[];
+    width: readonly [number, number];
+    bed: RiverBed;
+};
+/** A lake as an ellipse; the ground eases from `level` to the land between the two fractions of `edge` and is untouched past `reach`. */
+type Lake = {
+    id: string;
+    center: Point;
+    radius: Point;
+    level: number;
+    edge: readonly [number, number];
+    reach: number;
+};
+/** Where trees grow: the strongest of the masked zones and a patchy noise. */
+type ForestOptions = {
+    zones: readonly {
+        mask: readonly Ramp[];
+    }[];
+    patch?: {
+        waves: readonly Wave[];
+        edge: readonly [number, number];
+        weight: number;
+    };
+};
+/** What colours a vertex, tried in this order; the first rule that matches wins. */
+type ColorRule = {
+    kind: 'below';
+    height: number;
+    color: number;
+} | {
+    kind: 'above';
+    height: number;
+    color: number;
+} | {
+    kind: 'ellipse';
+    center: Point;
+    radius: Point;
+    color: number;
+} | {
+    kind: 'rects';
+    rects: readonly Rect[];
+    margin: number;
+    color: number;
+} | {
+    kind: 'forest';
+    above: number;
+    color: number;
+};
+/** Map coordinates (the ground plan) to world metres: `world = map · scale + origin`. The mesh is a square of `size` metres with `segments` cells a side. */
+type WorldFrame = {
+    size: number;
+    scale: number;
+    origin: number;
+    segments: number;
+};
+/** Everything that makes a terrain; the numbers of a place live in the game, not here. */
+type TerrainOptions = {
+    world: WorldFrame;
+    base: {
+        level: number;
+        waves: readonly Wave[];
+    };
+    layers: readonly TerrainLayer[];
+    flatten: readonly Flatten[];
+    rivers: readonly River[];
+    lakes: readonly Lake[];
+    forest: ForestOptions;
+    colors: readonly ColorRule[];
+    /** Colours of the open ground, picked by a hash of the map cell. */
+    fields: {
+        colors: readonly number[];
+        cell: Point;
+    };
+    /** The water plane under the whole terrain. */
+    water: {
+        level: number;
+        color: number;
+        roughness: number;
+        metalness: number;
+    };
+    /** Shape of the last touch: changes the height after every layer, river and lake. */
+    custom?: (px: number, py: number, height: number) => number;
+};
+/** The ground as numbers a drawer turns into a mesh: a grid of `segments + 1` vertices a side, rows along z. */
+type TerrainGrid = {
+    segments: number;
+    size: number;
+    /** x and z of each vertex in world metres. */
+    x: Float32Array;
+    z: Float32Array;
+    heights: Float32Array;
+    /** Colour of each vertex as 0xRRGGBB. */
+    colors: Uint32Array;
+};
+
+/** How a drawer treats a part when the default (standard material, rough 0.9, shadows on) is not what the team's page does. */
+type PartStyle = {
+    /** Metal and paint of the standard material. */
+    roughness?: number;
+    metalness?: number;
+    /** Shadows: boxes, cylinders, cones and prisms cast and receive by default, planes only receive, crowns only cast, signs and lines neither. */
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+};
+type Styled<TPart> = TPart & {
+    style?: PartStyle;
+};
+/** A cone (pointed cap of an iron pole, pine foliage); `y` is the centre. Flat shaded. */
+type ConePart = {
+    shape: 'cone';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+    height: number;
+    color: number;
+    segments: number;
+    style?: PartStyle;
+};
+/** A rough ball of leaves (a dodecahedron of the given radius). Casts shadows only. */
+type CrownPart = {
+    shape: 'crown';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+    color: number;
+    style?: PartStyle;
+};
+/** Half (or any arc) of a cylinder lying down, for a barrel-vault roof. Casts shadows only. `rotation` and `scale` are the mesh's own. */
+type VaultPart = {
+    shape: 'vault';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+    length: number;
+    arc: number;
+    segments: number;
+    color: number;
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    style?: PartStyle;
+};
+/** The ground: a square mesh of the grid's vertices with a colour each, flat shaded, that casts and receives shadows. */
+type TerrainPart = {
+    shape: 'terrain';
+    parent: number;
+    grid: TerrainGrid;
+    style?: PartStyle;
+};
+/** A flat rectangle lying on the ground (`y` is its height). */
+type PlanePart = {
+    shape: 'plane';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    depth: number;
+    color: number;
+    style?: PartStyle;
+};
+/** Text over one or more lines on a canvas texture (street names, strip labels). */
+type LabelPart = {
+    shape: 'label';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    ry: number;
+    lines: string[];
+    background: string;
+    foreground: string;
+    font: string;
+    canvas: {
+        width: number;
+        height: number;
+    };
+};
+/** A real light. A lamp that did not get one from the budget keeps its glowing lens and has no part like this. */
+type LightPart = {
+    shape: 'light';
+    kind: 'point';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    color: number;
+    intensity: number;
+    distance: number;
+    decay: number;
+    flicker: boolean;
+} | {
+    shape: 'light';
+    kind: 'spot';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    color: number;
+    intensity: number;
+    distance: number;
+    decay: number;
+    angle: number;
+    penumbra: number;
+    /** Where the beam points at rest. */
+    target: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** When set the target circles the light: `target = (x + sin(t·speed + x)·radius, 0, z + cos(t·speed + x)·radius)`. */
+    sweep?: {
+        speed: number;
+        radius: number;
+    };
+};
+/**
+ * A thing another package draws where the scene says: a vehicle of the fleet or a plant of the species pack. The scene keeps only
+ * what to put and where; the drawer asks the resolver of that kind for an object (nothing is drawn when it has none).
+ * `y` is the base on the ground, `color` the body paint of a vehicle (omitted: the palette of its group by `seed`).
+ */
+type PlacementPart = {
+    shape: 'placement';
+    parent: number;
+    kind: 'vehicle' | 'plant';
+    /** Id of the vehicle in the fleet or of the species in the pack. */
+    id: string;
+    x: number;
+    y: number;
+    z: number;
+    ry: number;
+    scale: number;
+    color?: number;
+    seed: number | string;
+};
+/** The parts of an urban scene: the silhouette vocabulary of game-floorplan plus what streets and poles need. */
+type UrbanPart = Styled<SilhouettePart> | ConePart | CrownPart | PlanePart | VaultPart | TerrainPart | LabelPart | LightPart | PlacementPart;
+/** One small box drawn as an instance of a single mesh (dashes of a road, sandbags). `y` is the base. */
+type ItemBox = {
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    depth: number;
+    color: number;
+    rx: number;
+    ry: number;
+    rz: number;
+};
+/** Everything a pole, a street, a block or a prop adds to a scene, in the order the team's page adds it. */
+type UrbanScene = {
+    parts: UrbanPart[];
+    items: ItemBox[];
+    windows: {
+        lit: SilhouetteWindow[];
+        dark: SilhouetteWindow[];
+    };
+};
+/** The lights a scene may spend. Every lamp that is on takes one, and the first ones win; the rest keep only their glowing lens. */
+type LightBudget = {
+    /** Lights left. It goes below zero when more lamps ask than the budget had, as the team's counter does. */
+    left: number;
+    /** True while the budget lasts (spends one either way). */
+    take(): boolean;
+};
+
+/** The team's counter: `take()` is `left-- > 0`, so the count keeps falling after the budget is spent. */
+declare function createLightBudget(count: number): LightBudget;
+
+type BoxOptions = {
+    parent?: number;
+    ry?: number;
+    rz?: number;
+    emissive?: boolean;
+    style?: PartStyle;
+};
+type UrbanBuilderOptions = {
+    /** Lights the scene may spend; omitted means no limit. */
+    budget?: LightBudget;
+};
+/**
+ * Collects the parts of an urban scene the way the team's page adds them to its root: every helper appends in call order, so a
+ * scene drawn with the same seeded random has the same parts, the same instances and the same windows.
+ * Heights follow the page: `y` is the base of a box, a cylinder, a cone and a prism, and the centre of a crown.
+ */
+declare function createUrbanBuilder(random: RandomSource, options?: UrbanBuilderOptions): {
+    random: RandomSource;
+    pick: <TEntry>(list: readonly TEntry[]) => TEntry;
+    lights: LightBudget;
+    parts: UrbanPart[];
+    items: ItemBox[];
+    windows: {
+        lit: _adatechnology_game_floorplan.SilhouetteWindow[];
+        dark: _adatechnology_game_floorplan.SilhouetteWindow[];
+    };
+    group: (x: number, y: number, z: number, ry?: number, parent?: number) => number;
+    box: (x: number, y: number, z: number, width: number, height: number, depth: number, color: number, o?: BoxOptions) => void;
+    cylinder: (x: number, y: number, z: number, radiusTop: number, radiusBottom: number, height: number, color: number, parent?: number, segments?: number, style?: PartStyle) => void;
+    cone: (x: number, y: number, z: number, radius: number, height: number, color: number, parent?: number, segments?: number) => void;
+    prism: (x: number, y: number, z: number, width: number, height: number, depth: number, color: number, parent?: number, ry?: number) => void;
+    plane: (x: number, y: number, z: number, width: number, depth: number, color: number, style?: PartStyle, parent?: number) => void;
+    vault: (part: Omit<Extract<UrbanPart, {
+        shape: "vault";
+    }>, "shape" | "parent"> & {
+        parent?: number;
+    }) => void;
+    terrain: (grid: TerrainGrid, parent?: number) => void;
+    crown: (x: number, y: number, z: number, radius: number, color: number, parent?: number) => void;
+    line: (points: [number, number, number][], color: number, parent?: number) => void;
+    label: (lines: string[], x: number, y: number, z: number, width: number, height: number, ry: number, o: {
+        background: string;
+        foreground: string;
+        font?: string;
+        canvas?: {
+            width: number;
+            height: number;
+        };
+    }, parent?: number) => void;
+    light: (part: Omit<Extract<LightPart, {
+        kind: "point";
+    }>, "shape" | "kind" | "parent" | "decay" | "flicker"> & {
+        flicker?: boolean;
+        decay?: number;
+    }) => void;
+    spot: (part: Omit<Extract<LightPart, {
+        kind: "spot";
+    }>, "shape" | "kind" | "parent">) => void;
+    place: (kind: PlacementPart["kind"], id: string, x: number, z: number, o?: {
+        y?: number;
+        ry?: number;
+        scale?: number;
+        color?: number;
+        seed?: number | string;
+        parent?: number;
+    }) => void;
+    item: (x: number, y: number, z: number, width: number, height: number, depth: number, color: number, ry?: number, rx?: number, rz?: number) => void;
+    fence: (x0: number, z0: number, x1: number, z1: number, height: number, color?: number) => void;
+    add: (silhouette: Silhouette) => void;
+    scene: () => UrbanScene;
+};
+type UrbanBuilder = ReturnType<typeof createUrbanBuilder>;
+
+/** The pole that carries the lamp: a tapered cylinder. */
+type MastSpec = {
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    color: number;
+    segments?: number;
+    style?: PartStyle;
+};
+/** A bar or a box of the pole, placed by its base `y`. `reach` is how far from the mast its centre sits. */
+type BarSpec = {
+    reach: number;
+    y: number;
+    width: number;
+    height: number;
+    depth: number;
+    color: number;
+};
+/** The box of a lamp head: its colour is the lens, lit or unlit. */
+type LampSpec = {
+    reach: number;
+    y: number;
+    width: number;
+    height: number;
+    depth: number;
+};
+/** Colour of the lamp lens when the lamp is on (it glows) and when it is off. */
+type LensSpec = {
+    lit: number;
+    unlit: number;
+};
+/** The real light a lamp that is on may get from the budget. `reach` moves it along the arm. */
+type LampLightSpec = {
+    color: number;
+    intensity: number;
+    distance: number;
+    y: number;
+    reach?: number;
+    z?: number;
+};
+/** Double arm with two LED heads (the avenue pole of the downtown pattern). */
+type DoubleArmSpec = {
+    mast: MastSpec;
+    arm: BarSpec;
+    lamp: LampSpec;
+    lens: LensSpec;
+    light: LampLightSpec;
+};
+/** Concrete pole with one arm and a sodium lamp, with an optional transformer drum. */
+type SingleArmSpec = {
+    mast: MastSpec;
+    arm: BarSpec;
+    lamp: LampSpec;
+    lens: LensSpec;
+    light: LampLightSpec;
+    transformer: {
+        offset: number;
+        y: number;
+        radius: number;
+        height: number;
+        color: number;
+        segments: number;
+    };
+};
+/** Short iron post with a lantern box and a pointed cap. */
+type LanternSpec = {
+    mast: MastSpec;
+    lamp: LampSpec;
+    cap: {
+        y: number;
+        radius: number;
+        height: number;
+        color: number;
+        segments: number;
+    };
+    lens: LensSpec;
+    light: LampLightSpec;
+};
+/** Wooden pole with a crossarm and a hanging lamp. */
+type CrossarmSpec = {
+    mast: MastSpec;
+    arm: BarSpec;
+    lamp: LampSpec;
+    lens: LensSpec;
+    light: LampLightSpec;
+};
+/** Four-legged tower with a deck and a row of floodlights. */
+type FloodTowerSpec = {
+    legs: {
+        offset: number;
+        height: number;
+        size: number;
+        color: number;
+    };
+    deck: BarSpec;
+    heads: {
+        count: number;
+        start: number;
+        spacing: number;
+        y: number;
+        z: number;
+        width: number;
+        height: number;
+        depth: number;
+    };
+    lens: LensSpec;
+    light: LampLightSpec;
+};
+/** What a game says when it places a pole. */
+type PoleOptions = {
+    x: number;
+    z: number;
+    /** Lit lamp (glowing lens and, while the budget lasts, a real light). Default true. */
+    on?: boolean;
+    /** Turns the whole pole (the double arm only; the others are placed by their arm direction). */
+    ry?: number;
+    /** The real light flickers (a failing lamp). */
+    flicker?: boolean;
+    /** Which way the arm points, 1 or -1 (single arm). Default 1. */
+    dir?: number;
+    /** Adds the transformer drum (single arm). */
+    transformer?: boolean;
+};
+type PoleShapeBuilder = (b: UrbanBuilder, spec: any, o: PoleOptions) => void;
+type PoleDef = {
+    id: string;
+    /** Key of the shape builder that reads `spec`. */
+    shape: string;
+    spec: object;
+};
+/** The shape builders the five default poles use; a game adds its own through `createUrban({ shapes })`. */
+declare const POLE_SHAPES: Readonly<Record<string, PoleShapeBuilder>>;
+/**
+ * The five poles of the neighbourhood patterns, with the numbers of the Galeria (heights, arms, lens colours, the colour,
+ * strength and reach of the real light). A game patches a number by id or adds a pole with its own shape.
+ */
+declare const DEFAULT_POLES: readonly PoleDef[];
+
+/** Look of the road surface and its centre line; the defaults are the Galeria's. */
+type RoadStyle = {
+    color: number;
+    /** Painted dashes along the centre line. */
+    dash: {
+        color: number;
+        every: number;
+        first: number;
+        length: number;
+        width: number;
+        height: number;
+        y: number;
+    };
+};
+type WalkStyle = {
+    color: number;
+    height: number;
+    castShadow: boolean;
+};
+declare const DEFAULT_ROAD_STYLE: RoadStyle;
+declare const DEFAULT_WALK_STYLE: WalkStyle;
+type StreetOptions = {
+    road?: Partial<RoadStyle> & {
+        dash?: Partial<RoadStyle['dash']>;
+    };
+    walk?: Partial<WalkStyle>;
+};
+/** Road centred on (x, z), `w` wide and `l` long along `x` or `z`, with a dash every 5 m starting 2 m from its start. */
+declare function drawRoad(b: UrbanBuilder, x: number, z: number, w: number, l: number, along: 'x' | 'z', options?: StreetOptions): void;
+/** Sidewalk slab centred on (x, z). */
+declare function drawWalk(b: UrbanBuilder, x: number, z: number, w: number, d: number, options?: StreetOptions): void;
+/** The big plane under the scene. */
+declare function drawGround(b: UrbanBuilder, color?: number, size?: number): void;
+/**
+ * A grid of `2n + 1` roads each way, `block` apart and `width` wide, with a sidewalk slab on every one of the `2n x 2n` blocks.
+ * Roads first (z then x for each line), then the walks, as the page.
+ */
+declare function drawStreetGrid(b: UrbanBuilder, block: number, count: number, width: number, options?: StreetOptions): void;
+
+/**
+ * One kind of tower the city can put on a tall lot: the numbers of a typology of `game-floorplan-commercial` (office) or `game-floorplan-residential`
+ * (residential), which the tests keep equal to theirs. The city only draws the outside; the plan of the inside is the typology's.
+ */
+type TowerPreset = {
+    id: string;
+    /** Chance weight among the presets (the one the random picks). */
+    weight: number;
+    /** Floor to floor in metres: the clear height of the typology plus its slab. */
+    storeyHeight: number;
+    /** A plant floor (darker band, no windows) every this many storeys; `false` none. */
+    mechanicalEvery: number | false;
+    /** A glass curtain wall (a ribbon of tall windows on a tinted skin) or a punched facade (a window in each bay of the masonry). */
+    glass: boolean;
+    /** Fewest and most storeys this preset's towers have (the lot height is raised or cut to it); omitted: no minimum, and `TowerOptions.maxStoreys` for the top. */
+    minStoreys?: number;
+    maxStoreys?: number;
+    /** Colour of the skin; omitted: the facade colour the block drew for the lot (glass: a blue tint of it). */
+    color?: number;
+};
+/** The two typologies: the office tower (4.0 m storeys: 3.6 clear and 0.4 slab, a plant floor every 20, glass) and the residential tower (3.1 m, every 25, masonry). */
+declare const DEFAULT_TOWER_PRESETS: readonly TowerPreset[];
+/**
+ * A preset from the layout of a typology (`officeTowerLayout(opts)`, `residentialTowerLayout(opts)`), so the city draws the tower the game configured:
+ * the storey pitch and the facade come from the layout, the storey range from its `range` when given.
+ */
+declare const towerPresetOf: (id: string, weight: number, layout: {
+    pitch: number;
+    facade: "curtain" | "punched";
+}, extra?: Partial<Omit<TowerPreset, "id" | "weight" | "storeyHeight" | "glass">>) => TowerPreset;
+/** What a game asks a tower provider to put on the ground: the lot, the height, the preset the random chose and the facade colour. */
+type TowerRequest = {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    height: number;
+    color: number;
+    preset: TowerPreset;
+    lit: number;
+    use?: string;
+    storeys?: number;
+};
+/** Draws a tower in place of the default one (the game's own model, or the plan of the typology rendered by `game-floorplan-three`). */
+type TowerProvider = (request: TowerRequest, b: UrbanBuilder) => void;
+type TowerOptions = {
+    /** A building at least this tall (metres) is drawn as a tower. Default 60. */
+    minHeight?: number;
+    /** Kinds of tower and their weights. Default `DEFAULT_TOWER_PRESETS`. */
+    presets?: readonly TowerPreset[];
+    /** Replaces the default drawing. */
+    provider?: TowerProvider;
+    /** The crown: height of the mast over the roof as a share of the tower (default 0.06, at most 25 m), 0 for none. */
+    mast?: number;
+    /** Most storeys a tower may have (default 60, the structural limit of the kit): a taller lot is drawn at this many storeys of its preset. */
+    maxStoreys?: number;
+    /** Chance that a window is lit when the block did not say (default 0.12). */
+    lit?: number;
+};
+declare const TOWER_DEFAULTS: {
+    readonly minHeight: 60;
+    readonly maxStoreys: 60;
+    readonly mast: 0.06;
+    readonly lit: 0.12;
+};
+/** The preset the random picks by weight; draws once. */
+declare function pickTowerPreset(b: UrbanBuilder, presets: readonly TowerPreset[]): TowerPreset;
+/** Storeys of a tower of this height, the podium (a taller ground storey) included. */
+declare const towerStoreys: (height: number, preset: TowerPreset) => number;
+/**
+ * A tower: a podium with a taller ground storey, the shaft with a row of windows on every storey of its four faces, darker bands where the plant
+ * floors are (no windows), the top plant floor set back, the parapet and the mast. Draws one random per window (lit or not), after the preset's.
+ */
+declare function drawTower(b: UrbanBuilder, request: TowerRequest, options?: Pick<TowerOptions, 'mast'>): BlockBuilding;
+/** The drawer a kit uses for a building of the block or the avenue: a tower from the minimum height up, the plain city building under it. */
+declare function createTowerDrawer(towers: TowerOptions, plain: (b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, o?: BuildingOptions) => BlockBuilding): (b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, o?: BuildingOptions) => BlockBuilding;
+
+/** Facade colours of the city buildings (the Galeria's `FAC`). */
+declare const DEFAULT_FACADES: readonly number[];
+type FillBlockOptions = {
+    /** The block is split into `k x k` lots. Default 2. */
+    k?: number;
+    /** Chance that a lot stays empty. Default 0.08. */
+    gap?: number;
+    /** Chance that a window is lit. */
+    lit?: number;
+    /** Chance of a ground-floor shop on a building. */
+    shop?: number;
+    /** Facade colours. Default `DEFAULT_FACADES`. */
+    palette?: readonly number[];
+    /**
+     * Storeys of each building, a number or `[min, max]` (the same name and shape as a city block's `building.floors`). Given, the height is storeys times the
+     * storey height of the use's preset instead of `minHeight..maxHeight`; the random draws are the same.
+     */
+    floors?: number | readonly [number, number];
+    /** Share of the buildings by use (`commercial`, `residential`, ...); each building picks one (one more random draw). Needs no `floors`. */
+    uses?: Readonly<Record<string, number>>;
+    /** Which tower preset gives the storey height of a use. Default `{ commercial: 'office', residential: 'residential' }`. */
+    storeyPresets?: Readonly<Record<string, string>>;
+    /** The presets whose storey heights are used (default `DEFAULT_TOWER_PRESETS`; the kit passes its `towers.presets`). */
+    presets?: readonly TowerPreset[];
+    /** Storey height when no preset applies, metres. Default the residential preset's. */
+    storeyHeight?: number;
+    /** Draws each building (default `drawBuilding`): the kit passes its own to put towers on the tall lots. */
+    draw?: (b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, options: BuildingOptions) => BlockBuilding;
+};
+/** A building a block ended up with, for the game's own bookkeeping (collisions, minimap). */
+type BlockBuilding = {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    height: number;
+    color: number;
+};
+type BuildingOptions = {
+    lit?: number;
+    shop?: number;
+    /** Use of the building (`commercial`, `residential`...), when the block gave `uses`. */
+    use?: string;
+    /** Storeys of the building, when the block gave `floors`; the height is already storeys times the storey height. */
+    storeys?: number;
+    /** Id of the tower preset the use maps to; a tower drawer with that preset uses it instead of picking at random. */
+    preset?: string;
+};
+declare const DEFAULT_STOREY_PRESETS: Readonly<Record<string, string>>;
+/** One city building: block, roof slab, maybe a vent on the roof, maybe a shop front on both long faces, windows on the four faces. Draws from the builder's random. */
+declare function drawBuilding(b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, options?: BuildingOptions): BlockBuilding;
+/**
+ * Fills a square block with city buildings: a `k x k` split of the block less 2 m of street, each lot maybe empty, each building a
+ * little smaller than its lot and as tall as `lerp(min, max, random^1.6)` (more low buildings than tall ones). Draws from the
+ * builder's random in the page's order: gap, width, depth, height, facade, then the building's own.
+ */
+declare function fillBlock(b: UrbanBuilder, cx: number, cz: number, size: number, minHeight: number, maxHeight: number, options?: FillBlockOptions): BlockBuilding[];
+
+/** Colours of the props; a game replaces the ones it wants. */
+type PropColors = {
+    tent: number;
+    trunk: number;
+    pines: readonly number[];
+    crowns: readonly number[];
+    sandbags: number;
+    fence: number;
+    wire: number;
+    label: {
+        background: string;
+        foreground: string;
+    };
+    watchtower: {
+        leg: number;
+        cabin: number;
+        deck: number;
+    };
+};
+declare const DEFAULT_PROP_COLORS: PropColors;
+/** Fence along a line: posts every 3 m and three wires. */
+declare function drawFence(b: UrbanBuilder, x0: number, z0: number, x1: number, z1: number, height: number, color?: number): void;
+/** Tent: a triangular prism `w` wide, 0.7 w high and `d` long, turned by `ry`. */
+declare function drawTent(b: UrbanBuilder, x: number, z: number, ry: number, w: number, d: number, color?: number, c?: Partial<PropColors>): void;
+/** Pine: a trunk and two cones of one of the greens (one draw from the random). */
+declare function drawPine(b: UrbanBuilder, x: number, z: number, scale?: number, y?: number, c?: Partial<PropColors>): void;
+/** Tree: a trunk and a rough ball of leaves of one of the greens (one draw from the random). */
+declare function drawTree(b: UrbanBuilder, x: number, z: number, scale?: number, c?: Partial<PropColors>): void;
+/** Shipping container (2.44 x 2.6 x 6.06 m) with five ribs on one end. */
+declare function drawContainer(b: UrbanBuilder, x: number, y: number, z: number, ry: number, color: number): void;
+/** Watch tower: four legs, a cabin, a roof deck and two posts; with a searchlight whose beam circles the ground. */
+declare function drawWatchtower(b: UrbanBuilder, x: number, z: number, searchlight?: boolean, c?: Partial<PropColors>): void;
+/** Rows of sandbags along `x` or `z`, each row shifted half a bag. Instances, no parts. */
+declare function drawSandbags(b: UrbanBuilder, x: number, z: number, length: number, along: 'x' | 'z', rows?: number, c?: Partial<PropColors>): void;
+/** A big strip of text on the ground level (name of a street, caption of a cell): two lines on a 22 x 4.4 m board at 2.4 m. */
+declare function drawStripLabel(b: UrbanBuilder, x: number, z: number, title: string, subtitle: string, c?: Partial<PropColors>): void;
+/** Wires between poles: a polyline at one height. */
+declare function drawWires(b: UrbanBuilder, points: readonly (readonly [number, number])[], y: number, color?: number, c?: Partial<PropColors>): void;
+
+/** What a game asks a house provider to put on the ground. Fields a typology does not use are ignored. */
+type HouseRequest = {
+    x: number;
+    z: number;
+    /** Turn of the whole house; the default provider turns the group. */
+    ry?: number;
+    width?: number;
+    depth?: number;
+    floors?: number;
+    color?: number;
+    roofColor?: number;
+    hasDoor?: boolean;
+    isBoarded?: boolean;
+};
+/** Draws a house of the given typology into the builder (and may add vehicles, plants or anything else around it). */
+type HouseProvider = (typology: string, request: HouseRequest, b: UrbanBuilder) => void;
+/** Draws a vehicle where the pattern parks one. A pattern parks none unless a provider is given. */
+type VehicleRequest = {
+    x: number;
+    z: number;
+    ry: number;
+    color: number;
+};
+type VehicleProvider = (request: VehicleRequest, b: UrbanBuilder) => void;
+/** Draws a tree where the pattern plants one. The default is the cone pine and the ball tree of the street props. */
+type PlantRequest = {
+    kind: 'pine' | 'tree';
+    x: number;
+    z: number;
+    scale: number;
+};
+type PlantProvider = (request: PlantRequest, b: UrbanBuilder) => void;
+type Providers = {
+    house?: HouseProvider;
+    vehicle?: VehicleProvider;
+    plant?: PlantProvider;
+};
+/** The cell of the sample sheet and what was put there, as data. */
+type UrbanPlan = {
+    id: string;
+    origin: {
+        x: number;
+        z: number;
+    };
+    houses: {
+        typology: string;
+        x: number;
+        z: number;
+        ry: number;
+    }[];
+    buildings: BlockBuilding[];
+    poles: {
+        pole: string;
+        x: number;
+        z: number;
+        on: boolean;
+    }[];
+    vehicles: VehicleRequest[];
+    plants: PlantRequest[];
+};
+type Locale = 'pt-BR' | 'en';
+type PatternText = {
+    label: string;
+    title: string;
+    caption: string;
+    detail: string;
+};
+/**
+ * A neighbourhood pattern: numbers a game can change and a key into the registry of composers, which draw the street.
+ * `params` are the numbers of that composer (counts, pitch, palettes, positions of the poles).
+ */
+type NeighbourhoodPattern<TParams = Record<string, unknown>> = {
+    id: string;
+    /** Width of the main paved strip (a road, a cobbled street, a yard or a boardwalk). */
+    streetWidth: number;
+    /** Width of the sidewalks; 0 when the pattern has none. */
+    walkWidth: number;
+    /** House and building typologies the pattern places (ids of the house provider). */
+    typologies: readonly string[];
+    /** Id of the kind of pole the pattern uses; empty when it has no public lighting. */
+    pole: string;
+    /** Colour of the light the lamps give. */
+    lightColor: number;
+    /** Metres between poles (0 when it has none). */
+    spacing: number;
+    /** Share of the lamps that are on; the rest are burnt out. 1 means all, without drawing from the random. */
+    lit: number;
+    /** Key into the composers. */
+    compose: string;
+    /** Where a map marker stands over the sample: its height and its shift in z from the origin. */
+    marker: {
+        height: number;
+        dz?: number;
+    };
+    /** Title, caption under the sample and marker text, by locale. */
+    text: Record<Locale, PatternText>;
+    params: TParams;
+};
+/** The parts of the kit a composer draws with: poles, streets, blocks and props. */
+interface UrbanKitCore {
+    poles: {
+        get(id: string): {
+            build(b: UrbanBuilder, options: PoleOptions): void;
+        };
+    };
+    streets: {
+        road(b: UrbanBuilder, x: number, z: number, w: number, l: number, along: 'x' | 'z'): void;
+        walk(b: UrbanBuilder, x: number, z: number, w: number, d: number): void;
+        ground(b: UrbanBuilder, color?: number, size?: number): void;
+        grid(b: UrbanBuilder, g: {
+            block: number;
+            count: number;
+            width: number;
+        }): void;
+    };
+    block: {
+        facades: readonly number[];
+        building(b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, o?: BuildingOptions): BlockBuilding;
+        fill(b: UrbanBuilder, g: {
+            cx: number;
+            cz: number;
+            size: number;
+            minHeight: number;
+            maxHeight: number;
+        } & FillBlockOptions): BlockBuilding[];
+    };
+    props: {
+        fence(b: UrbanBuilder, x0: number, z0: number, x1: number, z1: number, height: number, color?: number): void;
+        tent(b: UrbanBuilder, x: number, z: number, ry: number, w: number, d: number, color?: number): void;
+        pine(b: UrbanBuilder, x: number, z: number, scale?: number, y?: number): void;
+        tree(b: UrbanBuilder, x: number, z: number, scale?: number): void;
+        container(b: UrbanBuilder, x: number, y: number, z: number, ry: number, color: number): void;
+        watchtower(b: UrbanBuilder, x: number, z: number, searchlight?: boolean): void;
+        sandbags(b: UrbanBuilder, x: number, z: number, length: number, along: 'x' | 'z', rows?: number): void;
+        label(b: UrbanBuilder, x: number, z: number, title: string, subtitle: string): void;
+        wires(b: UrbanBuilder, points: readonly (readonly [number, number])[], y: number, color?: number): void;
+    };
+}
+type ComposeContext<TParams = Record<string, unknown>> = {
+    kit: UrbanKitCore;
+    b: UrbanBuilder;
+    pattern: NeighbourhoodPattern<TParams>;
+    params: TParams;
+    x0: number;
+    z0: number;
+    plan: UrbanPlan;
+    /** True with the probability `share`; draws from the random unless the share is 1. */
+    isLit(share: number): boolean;
+    pole(options: PoleOptions & {
+        id?: string;
+    }): void;
+    house(typology: string, request: HouseRequest): void;
+    vehicle(request: VehicleRequest): void;
+    plant(request: PlantRequest): void;
+    building(x: number, z: number, width: number, depth: number, height: number, color: number, options?: {
+        lit?: number;
+        shop?: number;
+    }): void;
+};
+type Composer<TParams = any> = (context: ComposeContext<TParams>) => void;
+type ComposeOptions = {
+    locale?: Locale;
+    providers?: Providers;
+};
+type SilhouetteFactory = (request: HouseRequest, random: () => number) => Silhouette;
+
+type DistrictKindText = {
+    name: string;
+    description: string;
+};
+/**
+ * A kind of district: what a patch of the city is. Numbers a game can change; the ids of `zone` and `pattern` point into other catalogues.
+ */
+type DistrictKindDef = {
+    id: string;
+    /** Colour on the map (css hex). */
+    color: string;
+    /** Id of a zone of `game-floorplan-residential` / `game-floorplan-commercial` (`zt`, `zc`, `zr1`, ...); null for ground that is not built. */
+    zone: string | null;
+    /** Id of a neighbourhood pattern of `urban.neighbourhoods` (or `financial_district` of `TOWER_PATTERNS`); null for ground that is not built. */
+    pattern: string | null;
+    /** Storeys of the buildings, `[min, max]`. */
+    floors: readonly [number, number];
+    /** Share of the buildings by use (`commercial`, `residential`, `industrial`, `institutional`, `agricultural`, ...). */
+    uses: Readonly<Record<string, number>>;
+    /** Size of a block in metres; 0 means the kind has no blocks. */
+    block: number;
+    text: Record<Locale, DistrictKindText>;
+};
+type PlanRect = readonly [x0: number, z0: number, x1: number, z1: number];
+type PlanPoint = readonly [x: number, z: number];
+type PlanDistrict = {
+    id: string;
+    /** Id of a `DistrictKindDef`. */
+    kind: string;
+    rect: PlanRect;
+    /** Replaces the name of the kind; a string or one string by locale. */
+    name?: string | Partial<Record<Locale, string>>;
+    /** Replaces the storeys of the kind. */
+    floors?: readonly [number, number];
+    /** Replaces the shares of use of the kind. */
+    uses?: Readonly<Record<string, number>>;
+};
+type PlanLine = {
+    id: string;
+    /** `avenue`, `street`, `highway`, `rail`, `river` or any string a drawer knows. */
+    kind: string;
+    width: number;
+    points: readonly PlanPoint[];
+};
+type PlanLandmark = {
+    kind: string;
+    at: PlanPoint;
+    name?: string | Partial<Record<Locale, string>>;
+};
+type CityScale = 'metropolis' | 'city' | 'town' | 'village' | (string & {});
+/**
+ * A city plan: districts painted on a map of metres (centre 0,0; x east, z south), roads, rails and rivers, and landmarks.
+ * Districts are listed from the outer to the inner one: the LAST district that contains a point wins.
+ */
+type CityPlanDef = {
+    id: string;
+    scale: CityScale;
+    /** Width and depth of the map in metres. */
+    size: readonly [w: number, d: number];
+    text: Record<Locale, {
+        name: string;
+        description: string;
+    }>;
+    /** Id of another plan to start from: its districts, lines and landmarks come first; a district or line of the same id replaces, a new one appends. */
+    extends?: string;
+    districts: readonly PlanDistrict[];
+    lines: readonly PlanLine[];
+    landmarks: readonly PlanLandmark[];
+};
+/** A plan as a game writes it: with `extends`, everything but the id is optional and comes from the parent. */
+type CityPlanInput = {
+    id: string;
+    extends?: string;
+} & Partial<Omit<CityPlanDef, 'id' | 'extends'>>;
+type BlockUse = {
+    floors: readonly [number, number];
+    uses: Readonly<Record<string, number>>;
+    zone: string | null;
+    pattern: string | null;
+};
+type ResolvedDistrict = {
+    id: string;
+    kind: string;
+    rect: PlanRect;
+    name: string;
+    description: string;
+    color: string;
+    zone: string | null;
+    pattern: string | null;
+    /** Storeys after the district's override, clamped to `[0, maxFloors]`. */
+    floors: readonly [number, number];
+    uses: Readonly<Record<string, number>>;
+    block: number;
+};
+/** A block of a district: its centre, its dimensions less the street, and the config a building generator takes. */
+type Block = {
+    x: number;
+    z: number;
+    size: readonly [w: number, d: number];
+    district: string;
+    building: BlockUse;
+};
+type CityLayout = {
+    id: string;
+    scale: string;
+    size: readonly [number, number];
+    name: string;
+    description: string;
+    districts: ResolvedDistrict[];
+    lines: PlanLine[];
+    landmarks: (Omit<PlanLandmark, 'name'> & {
+        name?: string;
+    })[];
+    /** The district at a point; the last one in the list that contains it. */
+    districtAt(x: number, z: number): ResolvedDistrict | undefined;
+    /** The grid of blocks of a district (by the kind's block size), less the cells another district was painted over. */
+    blocks(districtId: string, options?: {
+        street?: number;
+    }): Block[];
+};
+type LayoutOptions = {
+    maxFloors?: number;
+    locale?: Locale;
+};
+type KindStats = {
+    kind: string;
+    area: number;
+    share: number;
+    districts: number;
+};
+type FillBlockCityOptions = Omit<FillBlockOptions, 'shop'> & {
+    /** Chance of a ground-floor shop; default the commercial share of the block. */
+    shop?: number;
+    /** Which tower preset gives the storey height of a use: default `{ commercial: 'office', residential: 'residential' }`. */
+    storeyPresets?: Readonly<Record<string, string>>;
+    /** Storey height when no preset applies, metres. Default the residential preset's. */
+    storeyHeight?: number;
+};
+
+/** Highest storey count a district may have unless the game raises it. */
+declare const DEFAULT_MAX_FLOORS = 60;
+declare const DEFAULT_STREET = 10;
+type CitiesOptions = {
+    /** Most storeys any district may have, applied on top of the kinds and the districts' own numbers. Default 60. */
+    maxFloors?: number;
+    packs?: {
+        kinds?: readonly DistrictKindDef[];
+        plans?: readonly CityPlanInput[];
+    };
+    patch?: {
+        kinds?: Record<string, DeepPartial<DistrictKindDef>>;
+        plans?: Record<string, DeepPartial<CityPlanInput>>;
+    };
+    remove?: {
+        kinds?: readonly string[];
+        plans?: readonly string[];
+    };
+    /** Tower presets of the kit (storey heights by use). */
+    presets: readonly TowerPreset[];
+    fill(b: UrbanBuilder, g: {
+        cx: number;
+        cz: number;
+        size: number;
+        minHeight: number;
+        maxHeight: number;
+    } & FillBlockOptions): BlockBuilding[];
+};
+/** City plans as data: district kinds and plans are registries; a plan resolves to a layout with the district at a point and the grid of blocks of a district. */
+declare function createCities(o: CitiesOptions): {
+    maxFloors: number;
+    kinds: {
+        ids: () => string[];
+        list: () => DistrictKindDef[];
+        has: (id: string) => boolean;
+        get(id: string): DistrictKindDef;
+    };
+    plans: {
+        /** The plan with everything inherited from the plans it extends. */
+        resolve: (id: string) => CityPlanDef;
+        ids: () => string[];
+        list: () => CityPlanInput[];
+        has: (id: string) => boolean;
+        get(id: string): CityPlanInput;
+    };
+    layout: (planOrId: string | CityPlanInput, options?: LayoutOptions) => CityLayout;
+    stats: (l: CityLayout) => KindStats[];
+    fillBlock: (b: UrbanBuilder, block: Block, options?: FillBlockCityOptions) => BlockBuilding[];
+};
+type Cities = ReturnType<typeof createCities>;
+
+/** The district kinds of the city plans: colour on the map, zone of the floorplan packages, neighbourhood pattern, storeys, share of buildings by use and block size. */
+declare const DEFAULT_DISTRICT_KINDS: readonly DistrictKindDef[];
+
+/** The six city plans (metropolis, regional city, port city, rail town, country town, mountain village). Districts are listed from the outer to the inner one. */
+declare const DEFAULT_CITY_PLANS: readonly CityPlanDef[];
+
+type Origin = {
+    x: number;
+    z: number;
+};
+/** Draws one pattern at `origin`: its composer, then the board with the title and the caption. */
+declare function composePattern(kit: UrbanKitCore, pattern: NeighbourhoodPattern<any>, composer: Composer, b: UrbanBuilder, origin: Origin, options?: ComposeOptions): UrbanPlan;
+/** The marker (map pin) of a pattern at an origin: where it stands, how high, and what it says. */
+declare function patternMarker(pattern: NeighbourhoodPattern<any>, origin: Origin, locale?: Locale): {
+    x: number;
+    y: number;
+    z: number;
+    label: string;
+    detail: string;
+};
+type SampleSheetOptions = ComposeOptions & {
+    /** Ids to draw, in this order. Default all of the kit's patterns in the page's order. */
+    ids?: readonly string[];
+    /** Where each pattern stands. Default the Galeria's grid. */
+    cells?: Readonly<Record<string, Origin>>;
+    /** Colour and size of the ground under the sheet; false for none. */
+    ground?: {
+        color: number;
+        size: number;
+    } | false;
+};
+
+declare const clamp: (v: number, a: number, b: number) => number;
+declare const lerp: (a: number, b: number, t: number) => number;
+/** Smoothstep between `a` and `b`; with `a > b` it falls instead of rising. */
+declare const smoothstep: (a: number, b: number, x: number) => number;
+/** The team's cheap hash of two numbers into [0, 1). */
+declare const hash2: (a: number, b: number) => number;
+/** Distance from a point to the nearest segment of a polyline. */
+declare function distanceToPolyline(px: number, py: number, points: readonly Point[]): number;
+/** Inside the rectangle grown by `margin` on every side. */
+declare const insideRect: (px: number, py: number, r: Rect, margin: number) => boolean;
+/** Inside an ellipse given by its centre and radii. */
+declare const insideEllipse: (px: number, py: number, center: Point, radius: Point) => boolean;
+
+/**
+ * A ground made of layers, as the team's Vale: a rolling base, masked relief (mountains, hills), cities levelled flat, rivers and lakes carved in,
+ * a forest density, and a colour for every point. It answers questions about a point of the map and hands a drawer the grid of a square mesh.
+ */
+declare function createTerrain(options: TerrainOptions): {
+    options: TerrainOptions;
+    toWorld: (px: number, py: number) => [number, number];
+    fromWorld: (x: number, z: number) => [number, number];
+    heightAt: (px: number, py: number) => number;
+    forestAt: (px: number, py: number) => number;
+    nearRiver: (px: number, py: number, margin: number) => boolean;
+    colorAt: (px: number, py: number, h?: number) => number;
+    grid: (segments?: number) => TerrainGrid;
+};
+type Terrain = ReturnType<typeof createTerrain>;
+/** Puts the ground and its water under it into a builder: the terrain mesh first, then the water plane, as the page's `buildWorld`. */
+declare function drawTerrain(b: UrbanBuilder, terrain: Terrain, segments?: number): void;
+
+/** Lights a scene may spend: the Galeria spends 16 real point lights. */
+declare const DEFAULT_LIGHT_BUDGET = 16;
+/** Seed of the Galeria's generator. */
+declare const DEFAULT_URBAN_SEED = 7;
+type UrbanOptions = {
+    /** Entries added to the catalogues (an entry with an existing id replaces it). */
+    packs?: {
+        poles?: readonly PoleDef[];
+        neighbourhoods?: readonly NeighbourhoodPattern<any>[];
+        districtKinds?: readonly DistrictKindDef[];
+        cityPlans?: readonly CityPlanInput[];
+    };
+    /** Numbers changed on shipped entries, by id (objects merge, arrays replace). */
+    patch?: {
+        poles?: Record<string, DeepPartial<PoleDef>>;
+        neighbourhoods?: Record<string, DeepPartial<NeighbourhoodPattern<any>>>;
+        districtKinds?: Record<string, DeepPartial<DistrictKindDef>>;
+        cityPlans?: Record<string, DeepPartial<CityPlanInput>>;
+    };
+    /** Ids taken out of the catalogues. */
+    remove?: {
+        poles?: readonly string[];
+        neighbourhoods?: readonly string[];
+        districtKinds?: readonly string[];
+        cityPlans?: readonly string[];
+    };
+    /** Shape builders for the poles a pack adds; the five of the Galeria are always there. */
+    shapes?: Readonly<Record<string, PoleShapeBuilder>>;
+    /** Composers for the patterns a pack adds; the ten of the Galeria are always there. */
+    composers?: Readonly<Record<string, Composer>>;
+    /** City plans (zoning): district kinds and plans are catalogues (`packs`, `patch` and `remove` above, under `districtKinds` and `cityPlans`). */
+    cities?: {
+        maxFloors?: number;
+    };
+    lights?: {
+        budget?: number;
+    };
+    streets?: StreetOptions;
+    /** Facade colours of the city buildings. */
+    facades?: readonly number[];
+    props?: Partial<PropColors>;
+    /**
+     * Towers on the tall lots, off by default. `true` or an object turns them on: a building of the block or of an avenue at least `minHeight` (60 m) tall is drawn as
+     * a tower of one of the `presets` (the office and residential typologies), not as a box; a `provider` replaces the drawing. See `TowerOptions`.
+     */
+    towers?: boolean | TowerOptions;
+};
+type Pole = {
+    readonly def: PoleDef;
+    build(b: UrbanBuilder, options: PoleOptions): void;
+};
+type BuilderOptions = {
+    /** Seed of the generator when no `random` is given. Default 7. */
+    seed?: number;
+    random?: RandomSource;
+    /** Lights this scene may spend; default the kit's budget. */
+    budget?: number;
+};
+type UrbanKit = ReturnType<typeof createUrban>;
+/** The urban pattern as data: poles, streets, blocks and props that add parts to a builder. Knows nothing about three.js, a game or a place. */
+declare function createUrban(options?: UrbanOptions): {
+    poles: {
+        ids: () => string[];
+        list: () => PoleDef[];
+        get(id: string): Pole;
+    };
+    cities: {
+        maxFloors: number;
+        kinds: {
+            ids: () => string[];
+            list: () => DistrictKindDef[];
+            has: (id: string) => boolean;
+            get(id: string): DistrictKindDef;
+        };
+        plans: {
+            resolve: (id: string) => CityPlanDef;
+            ids: () => string[];
+            list: () => CityPlanInput[];
+            has: (id: string) => boolean;
+            get(id: string): CityPlanInput;
+        };
+        layout: (planOrId: string | CityPlanInput, options?: LayoutOptions) => CityLayout;
+        stats: (l: CityLayout) => KindStats[];
+        fillBlock: (b: UrbanBuilder, block: Block, options?: FillBlockCityOptions) => BlockBuilding[];
+    };
+    builder: (o?: BuilderOptions) => UrbanBuilder;
+    neighbourhoods: {
+        ids: () => string[];
+        get(id: string): {
+            pattern: NeighbourhoodPattern<any>;
+            /** Draws the pattern at `origin` and gives back what it put there. */
+            compose: (b: UrbanBuilder, origin: Origin, o?: ComposeOptions) => UrbanPlan;
+            marker: (origin: Origin, locale?: Locale) => {
+                x: number;
+                y: number;
+                z: number;
+                label: string;
+                detail: string;
+            };
+        };
+        /** The Galeria's sample sheet: the ground, then each pattern in its cell, in the order the page builds them. */
+        composeSampleSheet(b: UrbanBuilder, o?: SampleSheetOptions): {
+            plans: UrbanPlan[];
+            markers: {
+                x: number;
+                y: number;
+                z: number;
+                label: string;
+                detail: string;
+            }[];
+        };
+    };
+    terrain: (o: TerrainOptions) => Terrain;
+    drawTerrain: typeof drawTerrain;
+    towers: {
+        enabled: boolean;
+        options: TowerOptions | null;
+    };
+    streets: {
+        road(b: UrbanBuilder, x: number, z: number, w: number, l: number, along: "x" | "z"): void;
+        walk(b: UrbanBuilder, x: number, z: number, w: number, d: number): void;
+        ground(b: UrbanBuilder, color?: number, size?: number): void;
+        grid(b: UrbanBuilder, g: {
+            block: number;
+            count: number;
+            width: number;
+        }): void;
+    };
+    block: {
+        facades: readonly number[];
+        building(b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, o?: BuildingOptions): BlockBuilding;
+        fill(b: UrbanBuilder, g: {
+            cx: number;
+            cz: number;
+            size: number;
+            minHeight: number;
+            maxHeight: number;
+        } & FillBlockOptions): BlockBuilding[];
+    };
+    props: {
+        fence(b: UrbanBuilder, x0: number, z0: number, x1: number, z1: number, height: number, color?: number): void;
+        tent(b: UrbanBuilder, x: number, z: number, ry: number, w: number, d: number, color?: number): void;
+        pine(b: UrbanBuilder, x: number, z: number, scale?: number, y?: number): void;
+        tree(b: UrbanBuilder, x: number, z: number, scale?: number): void;
+        container(b: UrbanBuilder, x: number, y: number, z: number, ry: number, color: number): void;
+        watchtower(b: UrbanBuilder, x: number, z: number, searchlight?: boolean): void;
+        sandbags(b: UrbanBuilder, x: number, z: number, length: number, along: "x" | "z", rows?: number): void;
+        label(b: UrbanBuilder, x: number, z: number, title: string, subtitle: string): void;
+        wires(b: UrbanBuilder, points: readonly (readonly [number, number])[], y: number, color?: number): void;
+    };
+};
+
+/** Every composer reads its numbers from `pattern.params`; the defaults are in `patterns.ts`. */
+type DowntownParams = {
+    roadLength: number;
+    roadColor: number;
+    median: {
+        width: number;
+        height: number;
+        color: number;
+    };
+    poles: {
+        from: number;
+        to: number;
+    };
+    buildings: {
+        perRow: number;
+        first: number;
+        pitch: number;
+        rowOffset: number;
+        size: number;
+        north: {
+            minHeight: number;
+            range: number;
+            lit: number;
+        };
+        south: {
+            minHeight: number;
+            range: number;
+            lit: number;
+        };
+    };
+    walks: {
+        offset: number;
+        length: number;
+    };
+    car: {
+        dx: number;
+        dz: number;
+        ry: number;
+        color: number;
+    };
+};
+type SuburbParams = {
+    roadLength: number;
+    walkOffset: number;
+    houses: {
+        count: number;
+        first: number;
+        pitch: number;
+        north: {
+            z: number;
+            typologies: readonly [string, string];
+            colors: readonly number[];
+        };
+        south: {
+            z: number;
+            colors: readonly number[];
+        };
+        roofColor: number;
+        width: number;
+        depth: number;
+    };
+    walls: {
+        color: number;
+        height: number;
+        thickness: number;
+        offset: number;
+        gateColor: number;
+        gateWidth: number;
+        gateHeight: number;
+        gateOffset: number;
+        gateInset: number;
+        length: number;
+    };
+    poles: {
+        at: readonly number[];
+        z: number;
+        transformerFrom: number;
+    };
+    wires: {
+        half: number;
+        height: number;
+    };
+};
+type WorkingClassParams = {
+    houses: {
+        count: number;
+        first: number;
+        pitch: number;
+        width: number;
+        depth: number;
+        north: {
+            z: number;
+            colors: readonly number[];
+        };
+        south: {
+            z: number;
+            colors: readonly number[];
+        };
+        maxFloors: number;
+    };
+    poles: {
+        from: number;
+        to: number;
+        z: number;
+        jitter: number;
+    };
+    wires: {
+        count: number;
+        from: number;
+        to: number;
+        z: number;
+        step: number;
+        height: number;
+        heightStep: number;
+        sag: number;
+        color: number;
+    };
+};
+type HistoricParams = {
+    cobbles: {
+        y: number;
+        length: number;
+        color: number;
+        from: number;
+        to: number;
+        step: number;
+        spread: number;
+        sizes: readonly [number, number, number];
+        colors: readonly number[];
+    };
+    rows: {
+        from: number;
+        to: number;
+        minWidth: number;
+        widthSteps: number;
+        north: {
+            z: number;
+            colors: readonly number[];
+        };
+        south: {
+            z: number;
+            colors: readonly number[];
+        };
+    };
+    poles: {
+        from: number;
+        to: number;
+        step: number;
+        z: number;
+        sideOffset: number;
+    };
+};
+type IndustrialParams = {
+    yard: {
+        length: number;
+        color: number;
+    };
+    hangar: {
+        x: number;
+        z: number;
+        width: number;
+        height: number;
+        depth: number;
+        color: number;
+        roofColor: number;
+        roofRadius: number;
+        roofY: number;
+        doorColor: number;
+        doorWidth: number;
+        doorHeight: number;
+        stripeColor: number;
+    };
+    towers: readonly {
+        dx: number;
+        dz: number;
+        on: boolean;
+    }[];
+    container: {
+        dx: number;
+        dz: number;
+        ry: number;
+        color: number;
+    };
+};
+type RailwayParams = {
+    houses: {
+        count: number;
+        first: number;
+        pitch: number;
+        north: {
+            z: number;
+            colors: readonly number[];
+        };
+        south: {
+            z: number;
+            color: number;
+        };
+    };
+    poles: {
+        at: readonly number[];
+        z: number;
+        transformerFrom: number;
+    };
+    wires: {
+        half: number;
+        height: number;
+    };
+};
+type MountainParams = {
+    road: {
+        y: number;
+        length: number;
+        color: number;
+    };
+    chalets: {
+        count: number;
+        first: number;
+        pitch: number;
+        northZ: number;
+        southZ: number;
+        southShift: number;
+        northColors: readonly number[];
+        southColors: readonly number[];
+    };
+    poles: {
+        from: number;
+        to: number;
+        step: number;
+        z: number;
+        sideOffset: number;
+    };
+    pines: {
+        count: number;
+        first: number;
+        span: number;
+        rowZ: number;
+        minScale: number;
+        scaleRange: number;
+    };
+};
+type StiltParams = {
+    water: {
+        y: number;
+        z: number;
+        length: number;
+        depth: number;
+        color: number;
+        roughness: number;
+        metalness: number;
+    };
+    bank: {
+        z: number;
+        length: number;
+        depth: number;
+        color: number;
+    };
+    boardwalk: {
+        y: number;
+        length: number;
+        width: number;
+        color: number;
+        pilesFrom: number;
+        pilesTo: number;
+        pilesStep: number;
+    };
+    houses: {
+        count: number;
+        first: number;
+        pitch: number;
+        z: number;
+        colors: readonly number[];
+        lantern: {
+            dx: number;
+            y: number;
+            dz: number;
+            lit: number;
+            unlit: number;
+        };
+    };
+    lamp: {
+        dx: number;
+        y: number;
+        dz: number;
+        color: number;
+        intensity: number;
+        distance: number;
+    };
+    boat: {
+        dx: number;
+        dz: number;
+        color: number;
+    };
+};
+type MilitaryParams = {
+    yard: {
+        length: number;
+        color: number;
+    };
+    fence: {
+        from: number;
+        to: number;
+        step: number;
+        z: number;
+        height: number;
+        color: number;
+        wireColor: number;
+    };
+    towers: {
+        dx: readonly number[];
+        dz: number;
+    };
+    alarm: {
+        dz: number;
+        color: number;
+        intensity: number;
+        distance: number;
+        y: number;
+        lampDz: number;
+        lampY: number;
+    };
+    sandbags: {
+        dz: number;
+        length: number;
+        rows: number;
+    };
+    tents: {
+        count: number;
+        first: number;
+        pitch: number;
+        dz: number;
+        width: number;
+        depth: number;
+    };
+};
+type RuralParams = {
+    road: {
+        length: number;
+        color: number;
+    };
+    field: {
+        y: number;
+        dz: number;
+        length: number;
+        depth: number;
+        color: number;
+    };
+    farmhouse: {
+        dx: number;
+        dz: number;
+    };
+    pole: {
+        dx: number;
+        dz: number;
+    };
+    fence: {
+        dz: number;
+        half: number;
+        height: number;
+        color: number;
+    };
+    trees: {
+        count: number;
+        first: number;
+        span: number;
+        dz: number;
+        spread: number;
+        minScale: number;
+        scaleRange: number;
+    };
+    crops: {
+        rows: number;
+        perRow: number;
+        first: number;
+        pitch: number;
+        dz: number;
+        rowPitch: number;
+        width: number;
+        minHeight: number;
+        heightRange: number;
+        color: number;
+    };
+};
+/** The composers the ten default patterns use; a game adds its own through `createUrban({ composers })`. */
+declare const COMPOSERS: Readonly<Record<string, Composer>>;
+
+/** The far-away silhouettes of game-floorplan as the typologies of the default house provider. */
+declare const SILHOUETTE_TYPOLOGIES: Readonly<Record<string, SilhouetteFactory>>;
+/** The default provider: the silhouette of game-floorplan for the typology, added to the builder with its shared random. */
+declare function createSilhouetteHouses(typologies?: Readonly<Record<string, SilhouetteFactory>>): HouseProvider;
+
+/** The vehicles of the fleet that park on a street: cars, SUVs, pickups and vans. */
+declare const PARKED_VEHICLE_IDS: readonly string[];
+type VehicleProviderOptions = {
+    /** Ids of the fleet to choose from. Default `PARKED_VEHICLE_IDS`. */
+    ids?: readonly string[];
+    /** Replaces the choice: the id for a request. The default picks by the spot, so the same pattern parks the same cars every time. */
+    pick?: (request: VehicleRequest, ids: readonly string[]) => string;
+    /** Paint of the car. Default the colour the pattern asks for. */
+    paint?: (request: VehicleRequest) => number | undefined;
+};
+/**
+ * A vehicle provider that asks the drawer for a vehicle of the fleet where the pattern parks one. It chooses by the spot and not
+ * by the scene's random, so the scene's draw order (and the golden of the Galeria, which parks nothing) does not move.
+ */
+declare function createVehicleProvider(options?: VehicleProviderOptions): VehicleProvider;
+type PlantProviderOptions = {
+    /** Planting table of a region. Default Brazil's. */
+    region?: Region;
+    /** Context of the table for each kind the patterns plant. */
+    contexts?: Partial<Record<PlantRequest['kind'], string>>;
+    /** Seed of the choice; the spot is added so each place gets its own species. */
+    seed?: number | string;
+    /** Replaces the choice: the species id for a request. */
+    pick?: (request: PlantRequest, context: string, seed: string) => string;
+};
+declare const DEFAULT_PLANT_CONTEXTS: Readonly<Record<PlantRequest['kind'], string>>;
+/** A plant provider that asks the drawer for a species of the pack, drawn from the region's table for the kind (a tree on the sidewalk, a pine in the square). */
+declare function createPlantProvider(options?: PlantProviderOptions): PlantProvider;
+
+/** The ten patterns of the Galeria's sample sheet, in the order the page builds them. */
+declare const DEFAULT_PATTERNS: readonly NeighbourhoodPattern<any>[];
+/** Where the sample sheet puts each pattern: a 3 x 3 grid 80 by 56 m apart, and the military cell off to the east. */
+declare const SAMPLE_CELLS: Readonly<Record<string, {
+    x: number;
+    z: number;
+}>>;
+
+/** The patterns of the tower pack. */
+declare const TOWER_PATTERNS: readonly NeighbourhoodPattern<any>[];
+/** Where the sample sheet puts them (pass it as `cells`). */
+declare const TOWER_SAMPLE_CELLS: Readonly<Record<string, {
+    x: number;
+    z: number;
+}>>;
+
+export { type BarSpec, type Block, type BlockBuilding, type BlockUse, type BuilderOptions, type BuildingOptions, COMPOSERS, type Cities, type CitiesOptions, type CityLayout, type CityPlanDef, type CityPlanInput, type CityScale, type ColorRule, type ComposeContext, type ComposeOptions, type Composer, type ConePart, type CrossarmSpec, type CrownPart, DEFAULT_CITY_PLANS, DEFAULT_DISTRICT_KINDS, DEFAULT_FACADES, DEFAULT_LIGHT_BUDGET, DEFAULT_MAX_FLOORS, DEFAULT_PATTERNS, DEFAULT_PLANT_CONTEXTS, DEFAULT_POLES, DEFAULT_PROP_COLORS, DEFAULT_ROAD_STYLE, DEFAULT_STOREY_PRESETS, DEFAULT_STREET, DEFAULT_TOWER_PRESETS, DEFAULT_URBAN_SEED, DEFAULT_WALK_STYLE, type DistrictKindDef, type DistrictKindText, type DoubleArmSpec, type DowntownParams, type FillBlockCityOptions, type FillBlockOptions, type Flatten, type FloodTowerSpec, type ForestOptions, type HistoricParams, type HouseProvider, type HouseRequest, type IndustrialParams, type ItemBox, type KindStats, type LabelPart, type Lake, type LampLightSpec, type LampSpec, type LanternSpec, type LayoutOptions, type LensSpec, type LightBudget, type LightPart, type Locale, type MastSpec, type MilitaryParams, type MountainParams, type NeighbourhoodPattern, type Origin, PARKED_VEHICLE_IDS, POLE_SHAPES, type PartStyle, type PatternText, type PlacementPart, type PlanDistrict, type PlanLandmark, type PlanLine, type PlanPoint, type PlanRect, type PlanePart, type PlantProvider, type PlantProviderOptions, type PlantRequest, type Point, type Pole, type PoleDef, type PoleOptions, type PoleShapeBuilder, type PropColors, type Providers, type RailwayParams, type Ramp, type Rect, type ResolvedDistrict, type River, type RiverBed, type RoadStyle, type RuralParams, SAMPLE_CELLS, SILHOUETTE_TYPOLOGIES, type SampleSheetOptions, type SilhouetteFactory, type SingleArmSpec, type StiltParams, type StreetOptions, type SuburbParams, TOWER_DEFAULTS, TOWER_PATTERNS, TOWER_SAMPLE_CELLS, type Terrain, type TerrainGrid, type TerrainLayer, type TerrainOptions, type TerrainPart, type TowerOptions, type TowerPreset, type TowerProvider, type TowerRequest, type Trig, type UrbanBuilder, type UrbanBuilderOptions, type UrbanKit, type UrbanKitCore, type UrbanOptions, type UrbanPart, type UrbanPlan, type UrbanScene, type VaultPart, type VehicleProvider, type VehicleProviderOptions, type VehicleRequest, type WalkStyle, type Wave, type WorkingClassParams, type WorldFrame, clamp, composePattern, createCities, createLightBudget, createPlantProvider, createSilhouetteHouses, createTerrain, createTowerDrawer, createUrban, createUrbanBuilder, createVehicleProvider, distanceToPolyline, drawBuilding, drawContainer, drawFence, drawGround, drawPine, drawRoad, drawSandbags, drawStreetGrid, drawStripLabel, drawTent, drawTerrain, drawTower, drawTree, drawWalk, drawWatchtower, drawWires, fillBlock, hash2, insideEllipse, insideRect, lerp, patternMarker, pickTowerPreset, smoothstep, towerPresetOf, towerStoreys };