@rljson/edge 0.0.0 → 0.0.1

package/dist/README.md

@@ -8,4 +8,168 @@ found in the LICENSE file in the root of this package.
 
 # @rljson/edge - The Rljson Example Data Generator
 
-## Users
+Edge generates example data for Rljson applications: a car world with
+manufacturers, their catalogs of cars, and for every car a price, a brand,
+a workshop, a bill of materials and a CAD scene. One generated world uses
+every Rljson data type, from a hundred rows for a unit test to 25 million
+rows for a load test.
+
+## Goals
+
+- Give the Uikit, `db`, the `io` backends and the validators realistic test
+  data in every Rljson data type
+- Generate the same rows and hashes on every run and every machine, without
+  random numbers
+- Scale from a unit test fixture to a load test with 20 million objects
+- Run in Node.js, in the browser and in Web Workers, without file system or
+  database dependencies
+- Keep the data vivid: real brands and models, plausible parts, workshops
+  with addresses and owners
+
+## State
+
+[![Tests](https://github.com/rljson/edge/actions/workflows/quick_check.yaml/badge.svg)](https://github.com/rljson/edge/actions/workflows/quick_check.yaml)
+
+## Installation
+
+```bash
+pnpm add @rljson/edge @rljson/rljson
+```
+
+## Documentation
+
+- [Example data generator](https://github.com/rljson/rljson-pm/blob/main/doc/2026-Q4/concepts/topics/example-data-generator.md):
+  design, sizes and ideas, in the project management repo
+- [Decisions edge-001 to edge-004](https://github.com/rljson/rljson-pm/blob/main/doc/2026-Q4/concepts/decisions/000-index.md):
+  no buffets, no randomness, callback sinks, derived model years
+- The section »Generate Rljson« on [rljson.github.io](https://rljson.github.io):
+  step-by-step tutorials
+- [Guides](doc/guides): how to develop, test and review in this repo
+
+## Code Examples
+
+[src/example.ts](src/example.ts) runs these examples in the tests.
+
+Generate a world in memory:
+
+```ts
+import { Edge } from '@rljson/edge';
+
+// The tiny preset: one manufacturer with one catalog of five cars
+const { world, stats } = await Edge.preset('tiny').generate();
+
+console.log(`${stats.cars} cars, ${stats.rowsTotal} rows`);
+console.log(world.manufacturers._data[0].name);
+```
+
+Configure a world and estimate its size first:
+
+```ts
+import { Edge } from '@rljson/edge';
+
+const edge = new Edge({
+  manufacturers: { count: 2, catalogsPerManufacturer: 2 },
+  catalogs: { carsPerCatalog: 20, revisions: { count: 1 } },
+  layers: {
+    prices: { currencies: ['EUR', 'CHF'], range: { min: 20000, max: 80000 } },
+    brands: { modelsPerManufacturer: 3, popularity: 'zipf' },
+    workshops: { perCatalog: 4 },
+    parts: { depth: 3, fanOut: 2 },
+    cad: { depth: 2, fanOut: 3 },
+  },
+});
+
+console.log(`estimated rows: ${edge.estimate().rowsTotal}`);
+const { stats } = await edge.generate();
+console.log(`generated rows: ${stats.rowsTotal}`);
+```
+
+Stream the rows of a large world through a callback instead of keeping
+them:
+
+```ts
+import { Edge } from '@rljson/edge';
+
+const rowsPerTable: Record<string, number> = {};
+await Edge.preset('small').run({
+  onRow: (table) => {
+    rowsPerTable[table] = (rowsPerTable[table] ?? 0) + 1;
+  },
+});
+console.log(`prices: ${rowsPerTable.prices}, parts: ${rowsPerTable.parts}`);
+```
+
+## How It Works
+
+### The world
+
+```text
+Manufacturers              components  manufacturers   (the entry point)
+└─ Manufacturer
+   ├─ Headquarters         components  addresses
+   └─ Catalogs             jsonArray   manufacturers.catalogsRef
+      └─ Catalog           cakes       catalogs        (slices are cars)
+         ├─ Slice ids      sliceIds    carIds
+         ├─ Prices         layers      carPrices    →  components  prices
+         ├─ Brands         layers      carBrands    →  components  brands
+         ├─ Workshops      layers      carWorkshops →  components  workshops
+         │                                              ├─ addressRef → addresses
+         │                                              └─ ownerRef   → persons
+         ├─ Parts          layers      carParts     →  components  parts
+         │                                              └─ subPartRefs → parts
+         ├─ CAD            layers      carCad       →  trees       cadScenes
+         │                                              └─ meta.partRef → parts
+         └─ Revisions      revisions   revisions    (link the model years)
+```
+
+- Every model year of a catalog is a cake of its own. Its slice ids and
+  layers build on the year before with `base`, `add` and `remove`, and a
+  revision links the two cakes.
+- A bill of materials reaches up to four levels below the car. Levels 1 to
+  3 belong to a variant, level 4 is a pool of standard parts every bill
+  shares. A CAD scene is a tree of groups and meshes, and a mesh refers to
+  a part.
+- Lists are arrays of hashes in a `jsonArray` column that the table
+  configuration declares as a reference. Every table has a `TableCfg`, so
+  `BaseValidator` of `@rljson/rljson` checks types and references.
+
+### No randomness
+
+Every value derives from an index into the dictionaries: 166
+manufacturers, 917 models, nine assemblies with 36 parts each, 40
+standard parts, 126 cities, 100 streets, 185 first names and 180 last
+names. A share like `discountShare` selects every k-th car. The same
+configuration yields the same hashes.
+
+### Row by row
+
+Rows refer to rows by hash, so Edge emits a row after the rows it refers
+to. It hashes every row, drops a row whose hash it emitted before, and
+hands the rest to a sink, one at a time and awaited. `generate()` collects
+them in an `EMemorySink`; `run(sink)` hands them to `onRow` and keeps
+nothing, after `onTable` announced each table with its configuration.
+
+Bills of materials and scenes are shared per car, per model or per
+catalog. `estimate()` counts the rows of every table from the
+configuration alone, and `scale.targetRows` uses it to pick the cars per
+catalog.
+
+### Public API
+
+| Export                                   | Purpose                                                                                                                                                                                                    |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Edge`                                   | `new Edge(config)`, `preset()`, `estimate()`, `generate()`, `run()`                                                                                                                                        |
+| `mergeConfigs`                           | Merges two configurations section by section                                                                                                                                                               |
+| `edgeDefaults`, `resolveEdgeConfig`      | The defaults, and a configuration with defaults and checks                                                                                                                                                 |
+| `edgePresets`, `edgePresetNames`         | The presets `tiny`, `small`, `medium`, `large` and `xl`                                                                                                                                                    |
+| `ESink`, `EMemorySink`                   | The callback interface of `run()` and the sink of `generate()`                                                                                                                                             |
+| `carWorldTableKeys`, `carWorldTableCfgs` | The table keys and their table configurations                                                                                                                                                              |
+| `ECarWorld` and its row types            | `EManufacturer`, `EAddress`, `EPerson`, `EWorkshop`, `EPrice`, `EBrand`, `EPart`, `ECadMeta`                                                                                                               |
+| `EConfig` and its sections               | `ELayersConfig`, `EPricesConfig`, `EBrandsConfig`, `EWorkshopsConfig`, `EPartsConfig`, `ECadConfig`, `ERevisionsConfig`, `EResolvedConfig`                                                                 |
+| `EStats`, `EEstimate`, `EProgress`       | The results and the progress of a run                                                                                                                                                                      |
+| Dictionaries                             | `manufacturers`, `vehicles`, `modelsOf`, `assemblies`, `standardParts`, `materialsOf`, `cadSystems`, `cadDetails`, `cadMaterials`, `cities`, `citiesIn`, `cityNamed`, `streets`, `firstNames`, `lastNames` |
+
+## Contributing
+
+Work ticket by ticket with `gg`, as the [Develop Guide](doc/guides/develop-guide.md)
+describes. Reviews follow the [Review Guide](doc/guides/for-ai/ai-review-guide.md).

package/dist/car-world/bom-builder.d.ts

@@ -0,0 +1,57 @@
+import { EPartsConfig } from '../config/config.ts';
+import { EEmitter } from '../core/emitter.ts';
+import { EVariant } from './plan.ts';
+/** A generated bill of materials */
+export interface EBom {
+    /** The hash of the bill of materials: the part of level 0 */
+    rootRef: string;
+    /**
+     * The hashes of the parts in the order they were emitted, the root first.
+     * A standard part appears once for every part that contains it.
+     */
+    partRefs: string[];
+}
+/** What a bill of materials builder needs */
+export interface EBomBuilderOptions {
+    /** Receives the rows */
+    emitter: EEmitter;
+    /** The parts layer configuration */
+    config: Required<EPartsConfig>;
+    /** The part number prefix of the manufacturer, e.g. "AUD" */
+    prefix: string;
+    /** Who the bill of materials belongs to */
+    variant: EVariant;
+}
+/** The level of the standard parts, a pool every bill of materials shares */
+export declare const standardPartsLevel = 4;
+/**
+ * Emits a bill of materials from the leaves up.
+ *
+ * Part numbers are handed out from the top down, so a part's number is
+ * lower than the numbers of its sub parts. Levels 1 to 3 carry the variant
+ * in their part numbers, so two variants never share them. Level 4, the
+ * standard parts, comes from a pool every bill shares. Build once per
+ * instance.
+ */
+export declare class EBomBuilder {
+    private readonly options;
+    /**
+     * Constructor
+     * @param options - The emitter, the parts layer and the variant
+     */
+    constructor(options: EBomBuilderOptions);
+    /** Emits the bill of materials and returns its hashes */
+    build(): Promise<EBom>;
+    private sequence;
+    private readonly partRefs;
+    private get code();
+    private nextPartNumber;
+    private emit;
+    private root;
+    private assembly;
+    private subAssemblies;
+    private subAssembly;
+    private parts;
+    private part;
+    private standardParts;
+}

package/dist/car-world/brands.d.ts

@@ -0,0 +1,17 @@
+import { EBodyType, EVehicleModel } from '../dictionaries/vehicles.ts';
+import { EBrand } from './car-world.ts';
+/** The body types from the cheapest to the most expensive */
+export declare const bodyTypeRanks: readonly EBodyType[];
+/**
+ * Returns the power of a model in kW: the typical power of its body type,
+ * plus a bit for every model the manufacturer lists before it.
+ * @param model - The model
+ * @param modelIndex - The index of the model within the manufacturer
+ */
+export declare const powerKwOf: (model: EVehicleModel, modelIndex: number) => number;
+/**
+ * Returns the brand row of a model.
+ * @param model - The model
+ * @param modelIndex - The index of the model within the manufacturer
+ */
+export declare const brandRow: (model: EVehicleModel, modelIndex: number) => EBrand;

package/dist/car-world/car-world.d.ts

@@ -0,0 +1,135 @@
+import { Json } from '@rljson/json';
+import { CakesTable, ComponentsTable, LayersTable, Ref, RevisionsTable, Rljson, Row, SliceIdsTable, TablesCfgTable, TreesTable } from '@rljson/rljson';
+import { EBodyType, EFuel } from '../dictionaries/vehicles.ts';
+/** A manufacturer: the entry point of the world */
+export interface EManufacturer extends Row {
+    /** The brand in kebab case, e.g. "mercedes-benz" */
+    id: string;
+    /** The name of the company */
+    name: string;
+    /** The brand the cars carry */
+    brand: string;
+    /** The ISO 3166 country code of the headquarters */
+    country: string;
+    /** The year the brand was founded */
+    founded: number;
+    /** The website, a made up address */
+    website: string;
+    /** The address of the headquarters */
+    headquartersRef: Ref;
+    /** The catalogs of the manufacturer, every model year, oldest first */
+    catalogsRef: Ref[];
+}
+/** A postal address with coordinates */
+export interface EAddress extends Row {
+    street: string;
+    houseNumber: string;
+    zip: string;
+    city: string;
+    country: string;
+    lat: number;
+    lng: number;
+}
+/** A person, e.g. the owner of a workshop */
+export interface EPerson extends Row {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone: string;
+    birthYear: number;
+}
+/** A workshop that services cars */
+export interface EWorkshop extends Row {
+    name: string;
+    /** The address of the workshop */
+    addressRef: Ref;
+    /** The person who owns the workshop */
+    ownerRef: Ref;
+    phone: string;
+    email: string;
+    /** The services the workshop offers */
+    services: string[];
+    /** The rating from 3 to 5 */
+    rating: number;
+}
+/** The price of a car */
+export interface EPrice extends Row {
+    amount: number;
+    currency: string;
+    /** The first day of the model year, as ISO date */
+    validFrom: string;
+    /** The discount in percent, 0 for none */
+    discountPercent: number;
+    taxIncluded: boolean;
+}
+/** The brand and model of a car */
+export interface EBrand extends Row {
+    brand: string;
+    model: string;
+    bodyType: EBodyType;
+    fuel: EFuel;
+    powerKw: number;
+}
+/** A part of a bill of materials. Level 0 is the bill itself. */
+export interface EPart extends Row {
+    name: string;
+    /** A part number, unique per manufacturer */
+    partNumber: string;
+    /** The category, e.g. "engine", or "bom" for the bill of materials */
+    category: string;
+    /** 0 for the bill of materials, up to 4 for a standard part */
+    level: number;
+    /** How many of the part the parent contains */
+    quantity: number;
+    /** The weight of one part in kilograms */
+    weightKg: number;
+    /** The material, or null for an assembly */
+    material: string | null;
+    /** The sub parts, empty for a leaf */
+    subPartRefs: Ref[];
+}
+/** The meta data of a node of a CAD scene */
+export interface ECadMeta extends Json {
+    /** A group has children, a mesh has geometry */
+    type: 'group' | 'mesh';
+    /** What the scene shows, e.g. the model or the car it belongs to */
+    variant: string;
+    /** The position, rotation and scale relative to the parent */
+    transform: {
+        position: number[];
+        rotation: number[];
+        scale: number[];
+    };
+    /** The material of a mesh, null for a group */
+    material: string | null;
+    /** The number of vertices of a mesh, null for a group */
+    vertices: number | null;
+    /** Width, height and depth in meters */
+    boundsM: number[];
+    /** The part the mesh shows, or null */
+    partRef: Ref | null;
+}
+/** The generated world: an Rljson object with typed tables */
+export interface ECarWorld extends Rljson {
+    manufacturers: ComponentsTable<EManufacturer>;
+    addresses: ComponentsTable<EAddress>;
+    persons: ComponentsTable<EPerson>;
+    workshops: ComponentsTable<EWorkshop>;
+    prices: ComponentsTable<EPrice>;
+    brands: ComponentsTable<EBrand>;
+    parts: ComponentsTable<EPart>;
+    cadScenes: TreesTable;
+    carIds: SliceIdsTable;
+    carPrices: LayersTable;
+    carBrands: LayersTable;
+    carWorkshops: LayersTable;
+    carParts: LayersTable;
+    carCad: LayersTable;
+    catalogs: CakesTable;
+    revisions: RevisionsTable;
+    tableCfgs: TablesCfgTable;
+}
+/** The keys of the tables of a car world, in the order they are announced */
+export declare const carWorldTableKeys: readonly ["tableCfgs", "addresses", "persons", "workshops", "prices", "brands", "parts", "cadScenes", "carIds", "carPrices", "carBrands", "carWorkshops", "carParts", "carCad", "catalogs", "revisions", "manufacturers"];
+/** The key of a table of a car world */
+export type ECarWorldTableKey = (typeof carWorldTableKeys)[number];

package/dist/car-world/catalog-generator.d.ts

@@ -0,0 +1,99 @@
+import { EResolvedConfig } from '../config/config.ts';
+import { EEmitter } from '../core/emitter.ts';
+import { EVehicleModel } from '../dictionaries/vehicles.ts';
+import { EBom } from './bom-builder.ts';
+/** What a catalog needs to know about its manufacturer */
+export interface ECatalogManufacturer {
+    /** The index of the manufacturer within the world */
+    index: number;
+    /** The id of the manufacturer, e.g. "audi" */
+    id: string;
+    /** The part number prefix, e.g. "AUD" */
+    prefix: string;
+    /** The ISO 3166 country code */
+    country: string;
+    /** The models the manufacturer offers */
+    models: readonly EVehicleModel[];
+}
+/** Bills of materials and scenes shared by the catalogs of a manufacturer */
+export interface ECatalogCaches {
+    boms: Map<string, EBom>;
+    scenes: Map<string, string>;
+}
+/** What generating a catalog yields */
+export interface ECatalogResult {
+    /** The hashes of the cakes, one per model year, oldest first */
+    cakeRefs: string[];
+    /** How many different cars the catalog lists over all years */
+    cars: number;
+}
+/** What a catalog generator needs */
+export interface ECatalogGeneratorOptions {
+    /** Receives the rows */
+    emitter: EEmitter;
+    /** The resolved configuration */
+    config: EResolvedConfig;
+    /** The manufacturer of the catalog */
+    manufacturer: ECatalogManufacturer;
+    /** The index of the catalog within the manufacturer */
+    catalogIndex: number;
+    /** Bills of materials and scenes shared within the manufacturer */
+    caches: ECatalogCaches;
+}
+/**
+ * Emits one catalog with all its model years: components, slice ids, layers,
+ * cakes and revisions.
+ *
+ * Every model year is a cake of its own. Its slice ids and layers build on
+ * the year before, and a revision links the two cakes. Generate once per
+ * instance.
+ */
+export declare class ECatalogGenerator {
+    private readonly options;
+    /**
+     * Constructor
+     * @param options - The emitter, the configuration and the catalog
+     */
+    constructor(options: ECatalogGeneratorOptions);
+    /** Emits the catalog and returns the hashes of its cakes */
+    generate(): Promise<ECatalogResult>;
+    private readonly catalogGlobal;
+    private readonly baseId;
+    private readonly segment;
+    private readonly plan;
+    private readonly modelCount;
+    private readonly currency;
+    private readonly aspects;
+    private workshopRefs;
+    private previousSliceRef;
+    private readonly cakeRefs;
+    private readonly previousLayer;
+    private readonly raises;
+    private readonly versionBoms;
+    private readonly current;
+    private get emitter();
+    private get layers();
+    private isFirst;
+    private newCarsOf;
+    private generateWorkshops;
+    private generateVersion;
+    private modelIndexOf;
+    private assignBrands;
+    private assignPrices;
+    private priceInputOf;
+    private assignWorkshops;
+    private assignParts;
+    private assignScenes;
+    private variantOf;
+    private shared;
+    private bomOf;
+    private sceneOf;
+    private partRefsOf;
+    private emitSliceIds;
+    private emitLayers;
+    private layerOf;
+    private addedCars;
+    private forget;
+    private emitCake;
+    private emitRevision;
+}

package/dist/car-world/generate-car-world.d.ts

@@ -0,0 +1,16 @@
+import { EResolvedConfig } from '../config/config.ts';
+import { EEmitter } from '../core/emitter.ts';
+/**
+ * Returns the part number prefix of a brand: its first three letters.
+ * @param brand - The brand, e.g. "Mercedes-Benz"
+ */
+export declare const prefixOf: (brand: string) => string;
+/**
+ * Emits a whole car world: the table configurations, then manufacturer by
+ * manufacturer their catalogs, and returns how many cars it holds.
+ * @param config - The resolved configuration
+ * @param emitter - Receives the rows
+ */
+export declare const generateCarWorld: (config: EResolvedConfig, emitter: EEmitter) => Promise<{
+    cars: number;
+}>;

package/dist/car-world/plan.d.ts

@@ -0,0 +1,130 @@
+import { EResolvedConfig, ERevisionsConfig, ESharing } from '../config/config.ts';
+import { EVehicleModel } from '../dictionaries/vehicles.ts';
+/** The segments a manufacturer's catalogs are named after */
+export declare const segments: readonly ["cars", "vans", "suvs", "fleet", "classics", "sports", "trucks", "compact", "premium", "electric"];
+/** The digits of the car number in a slice id */
+export declare const carNoDigits = 6;
+/** The models a manufacturer uses when the brands layer is off */
+export declare const modelsWithoutBrands = 5;
+/**
+ * Returns the segment of a catalog, unique within a manufacturer.
+ * @param catalogIndex - The index of the catalog within the manufacturer
+ */
+export declare const segmentOf: (catalogIndex: number) => string;
+/**
+ * Returns the id of a catalog without its year, e.g. "audi-cars".
+ * @param manufacturerId - The id of the manufacturer
+ * @param catalogIndex - The index of the catalog within the manufacturer
+ */
+export declare const catalogBaseId: (manufacturerId: string, catalogIndex: number) => string;
+/**
+ * Returns the slice id of a car, e.g. "audi-cars-000017".
+ * @param baseId - The id of the catalog without its year
+ * @param carNo - The number of the car, starting at 1
+ */
+export declare const carSliceId: (baseId: string, carNo: number) => string;
+/**
+ * Returns the number of a car from its slice id.
+ * @param sliceId - The slice id of the car
+ */
+export declare const carNoOf: (sliceId: string) => number;
+/** One model year of a catalog */
+export interface EVersionPlan {
+    /** The model year */
+    year: number;
+    /** The slice ids of all cars of the year */
+    carIds: string[];
+    /** The cars the year adds; all cars in the first year */
+    added: string[];
+    /** The cars the year removes */
+    removed: string[];
+    /** The cars whose price the year changes */
+    changed: string[];
+}
+/** What the model years of a catalog depend on */
+export interface EPlanOptions {
+    /** The id of the catalog without its year */
+    baseId: string;
+    /** The number of cars in the first year */
+    cars: number;
+    /** The first model year */
+    startYear: number;
+    /** How many years follow, and their shares */
+    revisions: Required<ERevisionsConfig>;
+}
+/**
+ * Plans the model years of a catalog: which cars each year adds, removes and
+ * changes. Everything derives from the shares, nothing is random.
+ * @param options - The catalog, its first year and its revisions
+ */
+export declare const planVersions: (options: EPlanOptions) => EVersionPlan[];
+/** The counts of a catalog across its model years, for the estimate */
+export interface EVersionCounts {
+    /** How many different cars the catalog lists over all years */
+    distinctCars: number;
+    /** How many price rows the years need at most, all years together */
+    priceRows: number;
+    /** How many price rows each year needs at most: new cars and changed prices */
+    priceRowsPerVersion: number[];
+    /** How many assignments the layers of all years hold together */
+    assignments: number;
+}
+/**
+ * Counts what planVersions would plan, without building a single id.
+ * @param cars - The number of cars in the first year
+ * @param revisions - How many years follow, and their shares
+ */
+export declare const countVersions: (cars: number, revisions: Required<ERevisionsConfig>) => EVersionCounts;
+/**
+ * Returns how many models the cars of a manufacturer use: the configured
+ * number, capped by the models the dictionary knows.
+ * @param config - The resolved configuration
+ * @param models - The models of the manufacturer
+ */
+export declare const modelCountOf: (config: EResolvedConfig, models: readonly EVehicleModel[]) => number;
+/** What the model of a car depends on */
+export interface EModelOptions {
+    /** The number of the car, starting at 1 */
+    carNo: number;
+    /** The number of cars in the first year */
+    initialCars: number;
+    /** The number of models the manufacturer offers */
+    models: number;
+    /** uniform spreads the cars evenly, zipf favours the first models */
+    popularity: 'uniform' | 'zipf';
+}
+/**
+ * Returns the index of the model of a car. A car keeps its model over the
+ * years, so the index derives from the car number alone.
+ * @param options - The car, the catalog size and the models
+ */
+export declare const modelIndexOf: (options: EModelOptions) => number;
+/** Who shares a bill of materials or a scene: a code for ids and a name */
+export interface EVariant {
+    /** A short code for part numbers and cache keys, e.g. "a4" */
+    code: string;
+    /** A readable name, e.g. "Audi A4" */
+    name: string;
+    /** A number that varies the assemblies and systems the variant uses */
+    offset: number;
+}
+/** What the variant of a car depends on */
+export interface EVariantOptions {
+    /** perCar, perModel or perCatalog */
+    sharing: ESharing;
+    /** The slice id of the car */
+    sliceId: string;
+    /** The model of the car */
+    model: EVehicleModel;
+    /** The index of the model within the manufacturer */
+    modelIndex: number;
+    /** The segment of the catalog */
+    segment: string;
+    /** The index of the catalog within the manufacturer */
+    catalogIndex: number;
+}
+/**
+ * Returns the variant a car's bill of materials or scene belongs to.
+ * @param options - The sharing, the car, its model and its catalog
+ */
+export declare const variantOf: (options: EVariantOptions) => EVariant;

package/dist/car-world/prices.d.ts

@@ -0,0 +1,32 @@
+import { EPricesConfig } from '../config/config.ts';
+import { EVehicleModel } from '../dictionaries/vehicles.ts';
+import { EPrice } from './car-world.ts';
+/** A model has at most this many different prices per model year */
+export declare const pricesPerModel = 100;
+/** The discounts are this many steps of discountStepPercent: 5, 10 and 15 */
+export declare const discountSteps = 3;
+/** What a price depends on */
+export interface EPriceInput {
+    /** The model of the car: its body type decides the price class */
+    model: EVehicleModel;
+    /** The index of the model within the manufacturer */
+    modelIndex: number;
+    /** The number of the car, starting at 1 */
+    carNo: number;
+    /** The model year the price is valid from */
+    year: number;
+    /** The currency of the catalog */
+    currency: string;
+    /** How many model years raised the price: 0 for the first price of a car */
+    raises: number;
+}
+/**
+ * Returns the price row of a car.
+ *
+ * Expensive body types land high in the range, cheap ones low. The model and
+ * the car number spread the prices a little: a model has at most a hundred
+ * different prices per year. Every raise adds three percent.
+ * @param config - The prices layer configuration
+ * @param input - What the price depends on
+ */
+export declare const priceRow: (config: Required<EPricesConfig>, input: EPriceInput) => EPrice;