@jarenjs/emit 0.34.0

package/ARCHITECTURE.md

@@ -0,0 +1,97 @@
+# @jarenjs/emit — architecture
+
+Two stages, one published contract between them.
+
+```mermaid
+flowchart LR
+    A["schema"] --> B["model.js"]
+    B --> C["TYPE MODEL"]
+    C --> D["typescript.js<br/>markdown.js"]
+    D --> E["artifact"]
+    N1["stage 1: the flattening<br/>no template can do"]
+    N2["a published format,<br/>not private state"]
+    N3["stage 2: one stylesheet<br/>per target language"]
+    B -.- N1
+    C -.- N2
+    D -.- N3
+    class N1,N2,N3 note
+```
+
+## Stage 1 — `model.js`
+
+A single recursive descent over the schema, producing a flat declaration list.
+The decisions that live here, and nowhere else:
+
+- **Naming.** `$defs` keys and `$ref` pointer tokens are the names a reader
+  already uses, so they win. Anything else is derived from the path that
+  reached it (`UserAddressStreet`), PascalCased and de-collided by suffix.
+- **Cycles.** A node reached while it is still being built is hoisted to a
+  declaration and referenced by name. That is what turns a cyclic graph into
+  an acyclic list; the frame already building it finishes the declaration.
+- **Composition.** `allOf` → intersection, `anyOf`/`oneOf` → union, `const`/
+  `enum` → literals. Degenerate unions collapse, `never` drops out, and a
+  union containing `unknown` becomes `unknown`. A `$ref`'s 2019-09+ siblings
+  intersect with the target; the reference itself resolves through the
+  helpers `@jarenjs/validate/normalize` exports (`#`, `#/pointer`, plain
+  `#anchor`, embedded-`$id` scope boundary), so a ref means here exactly what
+  it means to the runtime normalizer.
+- **Honest widening.** Every keyword in `DROPPED_CONSTRAINTS` is recorded on
+  the node it came from and flattened into `doc` lines — including
+  integer-ness, `not`, active conditionals, dependent/unevaluated keywords
+  and `patternProperties` key restrictions. Nothing is discarded. The
+  directional half of the rule: the type may be wider than the schema (and
+  says where), never narrower. That is why applicators imply no container
+  (`properties` without `type` unions the object arm with every other JSON
+  kind), why tuples take their required count from `minItems` and stay open
+  unless the schema closes them, and why a closed empty object emits
+  `Record<string, never>` rather than TypeScript's primitive-swallowing
+  empty interface.
+- **The plain universe.** When variants are derived, `anyOf`/`oneOf`
+  branches compile in a context with normalization inert, because
+  `compileNormalizer` does not descend union branches. A referenced type
+  that differs under normalization gets a `Plain`-suffixed declaration for
+  its as-declared reading, shared by both passes; everything else shares the
+  main declaration. `normalizationChangesType` walks exactly the keywords
+  `compileNormalizer` walks — the twin analysis answering differently from
+  the runtime is the defect class this package exists to rule out.
+- **Determinism.** Declaration order is discovery order, member order is
+  schema order, and names never depend on a traversal counter. Boolean
+  schemas memoize by value — every `true` is the same schema — except that
+  the `$defs` loop forces one declaration per def name, so every importable
+  name exists. The `reserved` option seeds the taken-name list, which is how
+  the CLI's `--bundle` keeps independently compiled models in one name space.
+
+Absent information is **omitted**, not set to `null` — a missing `rest`,
+`index` or `default` is simply not there. Stage 2 relies on that: a path that
+yields the empty sequence dispatches nothing, which is how a template says
+"only when present" without a conditional.
+
+## Stage 2 — the stylesheets
+
+Each emitter is a JTLT document plus a thin `render` function. Three things
+about them are worth knowing before editing one:
+
+1. **Rules match by SCHEMA, not by path.** `$apply` on the current node
+   dispatches *location-less*, so a path match like `$..[?@.kind == 'union']`
+   silently never fires for a re-dispatched node. `isKind()` builds the schema
+   match instead, which is location-independent — and shape is what the rules
+   mean anyway. This is the single easiest way to break these files.
+2. **`$if` is an expression segment.** It interpolates a value; it cannot
+   contain a segment list. Conditional *rendering* is done by dispatching a
+   path that may be empty, never by `$if`.
+3. **Separators without a position variable.** JTLT has no `position()`, so a
+   separated list dispatches `$.options[0]` bare and `$.options[1:]` through a
+   mode that prints its own separator first. Ordinary RFC 9535 selectors, no
+   help needed from the model.
+
+`markdown.js` exists to keep stage 1 honest: it is as unlike TypeScript as a
+target gets, and it required no model change. If a future target does require
+one, that is the signal the model is shaped around a language rather than
+around schemas.
+
+## Verification
+
+`test/emit/agreement.test.js` is the reason to trust any of this — the cyclic
+check against `@jarenjs/validate` described in the
+[README](./README.md#the-cyclic-verification). It is itself checked by
+breaking the generator on purpose and confirming the suite fails.

package/README.md

@@ -0,0 +1,300 @@
+# @jarenjs/emit
+
+Build-time artifacts from JSON documents. Point it at your JSON Schemas, get
+TypeScript declarations — or Markdown reference docs, or whatever a stylesheet
+emits next.
+
+```bash
+npx jaren-emit --schema ./schemas --out ./src/types
+```
+
+```javascript
+import { emitTypeScript } from '@jarenjs/emit';
+
+emitTypeScript({
+  type: 'object',
+  description: 'A user',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    role: { enum: ['admin', 'user'] },
+  },
+  required: ['id'],
+}, { name: 'User' });
+```
+
+```typescript
+/**
+ * A user
+ */
+export interface User {
+  /**
+   * Schema constraints this type cannot express: format="uuid"
+   */
+  id: string;
+  role?: "admin" | "user";
+}
+```
+
+## Why this exists
+
+A schema-first codebase has a gap where a Zod codebase has `z.infer`: the
+schema knows the shape, and TypeScript does not. The usual answers are to
+assert the type by hand — which can silently certify something the schema
+never said — or to reach for a type-level library.
+
+The observation this package is built on is smaller than either: **a JSON
+Schema is JSON, TypeScript is text, and [JTLT](../json/docs/JTLT-FORMAT.md) is
+JSON-to-text.** Generating a declaration file is a stylesheet, not a new
+engine. That is also why it is called `emit` and not `infer` — swap the
+stylesheet and the same machinery emits documentation, DDL, or anything else
+a target language needs.
+
+## The cyclic verification
+
+This is the part that matters, and the part a standalone
+schema-to-TypeScript tool structurally cannot do.
+
+One schema goes two ways, and the two answers have to correspond:
+
+```mermaid
+flowchart TD
+    S["JSON Schema"]
+    T["TypeScript type"]
+    V["compiled validator"]
+    C["the SAME instances —<br/>and the two answers must correspond"]
+    S -->|"@jarenjs/emit"| T
+    S -->|"@jarenjs/validate"| V
+    T --> C
+    V --> C
+    N["owning both sides is what<br/>makes this testable"]
+    C -.- N
+    classDef answer fill:#dcfce7,stroke:#16a34a
+    class C answer
+    class N note
+```
+
+A generator that is merely *plausible* is worthless. It will emit a type that
+says one thing while the validator enforces another, and you find out in
+production — data that passed validation and violates its own declared type,
+or a type so wide it certifies anything.
+
+Because Jaren owns **both sides**, that can be tested rather than trusted.
+The suite in `test/emit/agreement.test.js` takes a corpus of schemas plus
+instances, generates the declarations, writes a probe file that assigns every
+instance to its generated type, and runs `tsc` over it. Then it runs the
+compiled validator over the same instances and requires three relationships to
+hold:
+
+| Instance | Validator | Generated type | What a failure would mean |
+| --- | --- | --- | --- |
+| valid | accepts | **must** type-check | the type is **narrower** than the schema — it rejects data your service accepts |
+| structurally invalid | rejects | **must not** type-check | the type is **wider** than the schema — it certifies data your service rejects |
+| constraint-invalid | rejects | **does** type-check | the documented widening — see below |
+
+The third row is the honest one. TypeScript cannot express `minLength`,
+`pattern` or `format`, so a value can be type-correct and schema-invalid.
+Rather than hide that, the corpus asserts it, and the generator writes the
+dropped constraint into the generated file:
+
+```typescript
+  /**
+   * Schema constraints this type cannot express: minLength=3
+   */
+  id: string;
+```
+
+The type says `string`. The comment says the schema also demands a minimum
+length that the type does not enforce. A reader learns both. **Widening
+silently would be a lie of omission**, and it is the single most common way a
+generated type misleads the person reading it.
+
+The rig is checked against itself, too: deliberately breaking the generator so
+it emits `unknown` everywhere makes the "not wider than the schema" assertion
+fail. A verification suite that passes on a broken generator proves nothing.
+
+## Accepted and normalized types
+
+`@jarenjs/validate/normalize` makes a contract's input and output shapes
+differ — a defaulted member is optional for the caller and present afterwards,
+and a coerced member arrives in its transport form. Pass the same options to
+the generator and it names both sides:
+
+```bash
+jaren-emit --schema ./schemas --out ./types --defaults --coerce
+```
+
+```typescript
+export interface Config {
+  host: string;      // present after normalizing
+  port: number;
+  name: string;
+}
+
+/**
+ * Accepted input for Config: the shape before normalization, where defaulted
+ * members may be absent and coercible values may still be in their transport form.
+ */
+export interface ConfigInput {
+  host?: string | number | boolean;   // optional, and widened to what
+  port?: number | string;             // the normalizer will convert FROM
+  name: string | number | boolean;
+}
+```
+
+That pair is exactly what a `Contract<Input, Output>` boundary wants: the
+handler signature takes `ConfigInput`, the rest of the program handles
+`Config`, and the normalizer is the transition between them.
+
+**A twin appears only where the type actually differs.** The generator works
+that out bottom-up, so a schema with one defaulted field does not double every
+declaration; everything unaffected keeps a single shared name on both sides.
+
+**Only two normalizations produce a difference.** `useDefaults` moves a member
+across the optional boundary and `coerceTypes` widens what the input accepts.
+`trimStrings` is string-to-string, and `removeAdditional` removes members no
+type ever declared — neither earns a second declaration.
+
+The switch resolution, including per-field predicates, is **imported from the
+normalizer rather than reimplemented**. Two copies of that rule would drift,
+and a variant that disagrees with the normalizer is worse than no variant: it
+is a type certifying an input the normalizer will not take. The agreement
+suite checks the pair the same way it checks everything else — a raw input
+must satisfy `ConfigInput` and not `Config`, and normalizing it at runtime
+must produce something the `Config` side describes.
+
+**The variants stop where the normalizer stops.** `compileNormalizer` does
+not descend `anyOf`/`oneOf` — which branch applies is only known after
+validating — so inside a union branch no default materializes and no coercion
+runs, and the generated pair says the same: branch members keep their
+declared optionality and their declared scalar types on *both* sides. When a
+branch references a type that does differ elsewhere, the branch points at a
+`Plain`-suffixed declaration carrying the schema's as-declared reading.
+Literals get the same treatment in the other direction: an integer `enum`
+under `--coerce` accepts its transport string on the input side (`1 | 2 |
+string`), because the normalizer coerces `"2"` to `2` before the enum check
+runs.
+
+## Two stages, and why
+
+```
+schema ──▶ compileEmitModel ──▶ TYPE MODEL ──▶ stylesheet ──▶ artifact
+```
+
+The templating is the easy half. The hard half is that a schema graph is not
+shaped like a declaration file: `$ref`s point sideways and in cycles,
+subschemas nest anonymously, `allOf` means intersection while `anyOf` means
+union, and half the vocabulary has no type-level meaning. **Stage one** does
+that flattening once — resolving refs, breaking cycles by name, deriving
+identifiers, widening honestly — into a flat list of named declarations.
+
+**Stage two** is a JTLT stylesheet per target. TypeScript and Markdown ship;
+both read the same model, and neither has privileged access to it.
+
+The [type model](./docs/EMIT-FORMAT.md) is a **published format** with its own
+[JSON Schema](./schemas/jaren-emit-model.schema.json) — and the test suite
+validates every model the package produces against it, so "published format"
+stays true rather than becoming decoration. A third-party emitter targeting
+the model is exactly as capable as the bundled ones.
+
+Markdown exists mainly as evidence for that claim: it is as unlike TypeScript
+as a target gets, and adding it required **no change to stage one**. If the
+model had secretly been the TypeScript printer's private state, writing it
+would have forced one.
+
+## CLI
+
+```bash
+jaren-emit --schema <file|dir> --out <dir> [options]
+
+  --target <name>   typescript (default) or markdown
+  --name <Name>     root declaration name for a single schema
+  --bundle <file>   one output file instead of one per schema
+  --check           write nothing; exit 1 if any output is out of date
+```
+
+`--check` is the CI guard: it fails the build when a schema changed and the
+generated types did not, which is the failure mode that makes generated code
+untrustworthy in the first place.
+
+`--bundle` compiles every schema into **one name space**: a `$defs.Id` that
+two schemas both declare comes out as `Id` and `Id2`, deterministically in
+sorted-file order, instead of two colliding declarations. The programmatic
+equivalent is the `reserved` option of `compileEmitModel`.
+
+## What it maps
+
+| JSON Schema | TypeScript |
+| --- | --- |
+| `type: 'string' \| 'number' \| 'integer' \| 'boolean' \| 'null'` | the primitive (`integer` → `number`) |
+| `const` / `enum` | a literal / a union of literals |
+| `properties` + `required` | interface members, optional when not required |
+| `additionalProperties` / `patternProperties` | an index signature, widened to cover the declared members |
+| *omitted* `additionalProperties` | `[key: string]: unknown` — the object is **open**, see below |
+| `additionalProperties: false` | a closed interface, with no index signature; with no members at all, `Record<string, never>` (an empty interface would let a primitive through) |
+| `items` | `Array<T>` |
+| `prefixItems`, array-form `items` | a tuple: the first `minItems` positions required, the rest optional, and an **open** rest (`...Array<unknown>`) unless `items: false`/`additionalItems: false` closes it — JSON Schema accepts shorter and longer arrays, so the type does too |
+| `$ref` (same document, including cycles) | a reference to the named declaration — `#/pointer` and plain `#anchor` forms, resolving exactly as `compileNormalizer` resolves them; a root `$ref` aliases its target, and 2019-09+ siblings intersect with it |
+| `allOf` | an intersection |
+| `anyOf`, `oneOf` | a union |
+| `properties`/`items` with **no `type`** | the container shape as one union arm, plus the other JSON kinds — applicators do not imply a container, and the validator accepts a primitive without reading them |
+| `description` | a doc comment |
+| `default` (with `--defaults`) | optional on the accepted side — even when `required` lists it, since the normalizer materializes it before validation — and present on the normalized side |
+
+### Objects are open unless the schema closes them
+
+A JSON Schema object accepts members it never declared. That is the default,
+and it is easy to forget when reading a schema that lists four properties and
+looks like a struct. So an interface generated from one carries an index
+signature, and only `additionalProperties: false` removes it.
+
+This costs something real: with an index signature TypeScript stops flagging a
+misspelled property, because the misspelling is a legal member. The trade is
+deliberate. A type that is **narrower** than its schema rejects a document your
+service accepts — the caller is told their payload is wrong by the very
+artifact that promised to describe it, and no amount of local convenience is
+worth a generated type that lies in that direction. If you want the tighter
+type, say so in the schema with `additionalProperties: false` and get it
+honestly, or pass `openObjects: 'closed'` and own the divergence.
+
+Both directions are pinned by the agreement corpus: an open schema's extra
+member must type-check, and a closed schema's must not.
+
+**Widened, with the constraint recorded**: `minLength`, `maxLength`,
+`pattern`, `format`, `minimum`, `maximum`, `exclusiveMinimum`,
+`exclusiveMaximum`, `multipleOf`, `minItems`, `maxItems`, `uniqueItems`,
+`contains`, `minProperties`, `maxProperties`, `propertyNames`,
+`dependentRequired`, `dependentSchemas`/`dependencies`, `not`,
+`if`/`then`/`else`, constraining `unevaluatedProperties`/`unevaluatedItems`,
+integer-ness (`type: "integer"` emits as `number`), the key restrictions of
+`patternProperties`, and the Jaren extension keywords. Nothing on this list
+narrows a type, and nothing on it disappears silently: each is written into
+the generated file's doc comment.
+
+**Not mapped**: `if`/`then`/`else` and `not` contribute nothing to the type —
+they have no sound type-level equivalent, so they are recorded (see above)
+rather than guessed at. Cross-document `$ref`s are not followed — a model
+compiles the document it was handed — and an unresolvable reference
+contributes nothing, leaving the node honestly wider.
+
+## Honest comparison
+
+[`json-schema-to-ts`](https://github.com/ThomasAribart/json-schema-to-ts)
+computes types *in the type system* from schema literals. This generates
+*source*. Different mechanism, different trade:
+
+- **Theirs** needs no build step and stays exact as you edit a literal.
+- **Ours** works on schemas that live in `.json` files, produces declarations
+  a human can read and review in a diff, emits non-TypeScript targets, and can
+  be checked against the validator that will actually run.
+
+If your schemas are TypeScript literals and you want zero build steps, use
+theirs. If your schemas are documents — published, shared with other
+languages, or fed to an LLM's structured-output mode — this is the one that
+fits.
+
+## Development
+
+Tests live in `test/emit/` at the repository root (`npm run test:emit`).
+`agreement.test.js` is the cyclic verification and needs the workspace's
+TypeScript. The internals are described in [ARCHITECTURE.md](./ARCHITECTURE.md);
+the model contract is in [EMIT-FORMAT.md](./docs/EMIT-FORMAT.md).

package/dist/types/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { compileEmitModel, EMIT_MODEL_VERSION } from './model.js';
+export { emitTypeScript, renderTypeScript, TYPESCRIPT_STYLESHEET } from './typescript.js';
+export { emitMarkdown, renderMarkdown, MARKDOWN_STYLESHEET } from './markdown.js';

package/dist/types/markdown.d.ts

@@ -0,0 +1,102 @@
+/** Reference documentation for a type model. */
+export declare const MARKDOWN_STYLESHEET: {
+    $jtlt: string;
+    output: string;
+    rules: ({
+        match: string;
+        body: {
+            $apply: string[];
+        }[][];
+        priority?: undefined;
+        mode?: undefined;
+    } | {
+        match: {
+            schema: {
+                type: string;
+                properties: {
+                    kind: {
+                        const: any;
+                    };
+                };
+                required: string[];
+            };
+        };
+        mode: string;
+        body: (string | {
+            $apply: string[];
+        }[] | {
+            $raw: string;
+        })[];
+        priority?: undefined;
+    } | {
+        match: {
+            schema: {
+                type: string;
+                properties: {
+                    kind: {
+                        const: any;
+                    };
+                };
+                required: string[];
+            };
+        };
+        mode: string;
+        priority: number;
+        body: (string | {
+            $apply: string[];
+        }[])[];
+    } | {
+        mode: string;
+        priority: number;
+        body: (string | {
+            $apply: string[];
+        }[])[];
+        match?: undefined;
+    } | {
+        priority?: undefined;
+        mode: string;
+        body: (string | {
+            $apply: string[];
+        }[] | {
+            $raw: string;
+        })[];
+        match?: undefined;
+    } | {
+        priority?: undefined;
+        mode: string;
+        body: {
+            $if: string[];
+        }[];
+        match?: undefined;
+    } | {
+        priority?: undefined;
+        match: {
+            schema: {
+                type: string;
+                properties: {
+                    kind: {
+                        const: any;
+                    };
+                };
+                required: string[];
+            };
+        };
+        mode: string;
+        body: {
+            $json: string;
+        }[];
+    })[];
+};
+/**
+ * Render a type model as Markdown reference documentation.
+ * @param {import('./model.js').EmitModel} model - A type model from {@link compileEmitModel}
+ * @returns {string} Markdown
+ */
+export declare function renderMarkdown(model: import('./model.js').EmitModel): string;
+/**
+ * Compile a JSON Schema straight to Markdown reference documentation.
+ * @param {object|boolean} schema - The schema to document
+ * @param {import('./model.js').EmitModelOptions} [options] - Model options
+ * @returns {string} Markdown
+ */
+export declare function emitMarkdown(schema: object | boolean, options?: import('./model.js').EmitModelOptions): string;

package/dist/types/model.d.ts

@@ -0,0 +1,170 @@
+/** The model format version this module produces and consumes. */
+export declare const EMIT_MODEL_VERSION = "0.1";
+export type NormalizeOptions = import('@jarenjs/validate/normalize').NormalizeOptions;
+export type EmitConstraint = {
+    /**
+     * - The schema keyword
+     */
+    keyword: string;
+    /**
+     * - The keyword's value in the source schema
+     */
+    value?: any;
+};
+export type EmitTypeRef = {
+    kind: 'unknown' | 'never' | 'primitive' | 'literal' | 'ref' | 'array' | 'tuple' | 'optional' | 'record' | 'union' | 'intersection' | 'object';
+    /**
+     * - For `primitive`
+     */
+    primitive?: 'string' | 'number' | 'boolean' | 'null';
+    /**
+     * - The JSON value of a `literal`, or the value type of a `record`
+     */
+    value?: any;
+    /**
+     * - For `ref`: the referenced declaration name
+     */
+    ref?: string;
+    /**
+     * - `array` item type, or `tuple` positional items
+     */
+    items?: EmitTypeRef | EmitTypeRef[];
+    /**
+     * - For `tuple`: the rest type, when the tuple is open
+     */
+    rest?: EmitTypeRef;
+    /**
+     * - For `optional`: the wrapped tuple element
+     */
+    item?: EmitTypeRef;
+    /**
+     * - For `union` (at least two)
+     */
+    options?: EmitTypeRef[];
+    /**
+     * - For `intersection` (at least two)
+     */
+    parts?: EmitTypeRef[];
+    /**
+     * - For `object`
+     */
+    members?: EmitMember[];
+    /**
+     * - For `object`: the index-signature value type
+     */
+    index?: EmitTypeRef;
+};
+export type EmitMember = {
+    kind: 'member';
+    /**
+     * - The property name, verbatim
+     */
+    name: string;
+    type: EmitTypeRef;
+    required: boolean;
+    /**
+     * - The schema default, when it declares one
+     */
+    default?: any;
+    constraints: EmitConstraint[];
+    doc: string[];
+};
+export type EmitDeclaration = {
+    kind: 'declaration';
+    /**
+     * - Unique, identifier-safe
+     */
+    name: string;
+    type: EmitTypeRef;
+    constraints: EmitConstraint[];
+    doc: string[];
+    /**
+     * - Which side of normalization this declaration describes
+     */
+    variant?: 'accepted' | 'normalized';
+    /**
+     * - For an accepted variant, its normalized counterpart
+     */
+    variantOf?: string;
+};
+export type EmitModel = {
+    /**
+     * - The model format version
+     */
+    $emit: string;
+    /**
+     * - Where the model came from
+     */
+    source: string | null;
+    /**
+     * - The declaration name of the schema's root
+     */
+    root: string | null;
+    /**
+     * - Present when accepted/normalized pairs were derived
+     */
+    variants?: true;
+    declarations: EmitDeclaration[];
+};
+export type EmitModelOptions = {
+    /**
+     * - The name for the root declaration
+     */
+    name?: string;
+    /**
+     * - A source identifier recorded in the model
+     */
+    source?: string;
+    /**
+     * - How to treat an object
+     * whose `additionalProperties` is omitted. JSON Schema says such an object
+     * is open, so the default emits an index signature; `'closed'` opts into the
+     * tighter type, which regains excess-property checking at the cost of
+     * rejecting documents the schema accepts.
+     */
+    openObjects?: 'open' | 'closed';
+    /**
+     * - When set, derive
+     * accepted/normalized variant pairs with exactly these `compileNormalizer`
+     * options
+     */
+    normalize?: NormalizeOptions | null;
+    /**
+     * - The suffix for accepted-variant
+     * declaration names
+     */
+    variantSuffix?: string;
+    /**
+     * - Declaration names already taken outside
+     * this model. Bundling concatenates models into one file, so each model
+     * must be able to avoid the names its predecessors used.
+     */
+    reserved?: string[];
+    /**
+     * - Extension keyword names (typically
+     * `x-*`) to PRESERVE: when a property schema carries one of these, the
+     * member node gains `extensions: { '<keyword>': value }` with the value
+     * copied verbatim. The compiler itself never interprets them — a
+     * downstream consumer of the model does. Keywords are read from the
+     * property node itself (a vocabulary declares them inline, not through
+     * `$ref`). Absent by default, so existing models are byte-identical.
+     */
+    extensions?: string[];
+};
+/**
+ * Compile one or more JSON Schemas into a type model.
+ *
+ * The model is a plain JSON document. It is the contract every emitter reads,
+ * and it is published as a schema so a third-party emitter can target it too.
+ * @param {object|boolean} schema - The root schema
+ * @param {EmitModelOptions} [options] - Compile options
+ * @returns {EmitModel} The type model document
+ * @example
+ * const model = compileEmitModel({
+ *   $defs: { Id: { type: 'string' } },
+ *   type: 'object',
+ *   properties: { id: { $ref: '#/$defs/Id' } },
+ *   required: ['id'],
+ * }, { name: 'User' });
+ */
+export declare function compileEmitModel(schema: object | boolean, options?: EmitModelOptions): EmitModel;