@haddowg/json-api-codegen 1.0.0

package/dist/index-C0becRSc.d.mts

@@ -0,0 +1,471 @@
+import { ApiDescriptor, AtomicDescriptor } from "@haddowg/json-api-client";
+
+//#region src/openapi.d.ts
+/**
+ * A minimal structural model of the slice of OpenAPI 3.1 the codegen consumes
+ * (`components.schemas` + `paths`). Deliberately not a full OpenAPI type — we only
+ * model what the descriptor builder reads, and treat schemas as a loose recursive
+ * shape since JSON Schema is open-ended.
+ */
+/** A JSON Schema node (or a `$ref` to one), loosely typed for the bits we walk. */
+interface SchemaObject {
+  $ref?: string;
+  type?: string | readonly string[];
+  const?: unknown;
+  format?: string;
+  description?: string;
+  enum?: readonly unknown[];
+  properties?: Record<string, SchemaOrBool>;
+  items?: SchemaObject;
+  required?: readonly string[];
+  allOf?: readonly SchemaObject[];
+  anyOf?: readonly SchemaObject[];
+  oneOf?: readonly SchemaObject[];
+  'x-enum-varnames'?: readonly string[];
+  'x-enum-descriptions'?: readonly string[];
+  [key: string]: unknown;
+}
+/** A property entry: either a schema, or the literal `false` (a forbidden member). */
+type SchemaOrBool = SchemaObject | boolean;
+interface MediaTypeObject {
+  schema?: SchemaObject;
+}
+interface RequestBodyObject {
+  content?: Record<string, MediaTypeObject>;
+  required?: boolean;
+}
+interface ResponseObject {
+  content?: Record<string, MediaTypeObject>;
+}
+interface ParameterObject {
+  name?: string;
+  in?: string;
+  $ref?: string;
+  schema?: SchemaObject;
+  /** The negotiation profile a client must opt into to use this parameter (e.g. `withCount`). */
+  'x-profile'?: string;
+}
+interface OperationObject {
+  parameters?: readonly ParameterObject[];
+  requestBody?: RequestBodyObject;
+  responses?: Record<string, ResponseObject>;
+}
+type HttpMethod = 'get' | 'post' | 'patch' | 'put' | 'delete';
+type PathItemObject = Partial<Record<HttpMethod, OperationObject>>;
+interface InfoObject {
+  title?: string;
+  version?: string;
+}
+interface OpenApiDocument {
+  openapi?: string;
+  info?: InfoObject;
+  servers?: readonly {
+    url?: string;
+  }[];
+  paths?: Record<string, PathItemObject>;
+  components?: {
+    schemas?: Record<string, SchemaObject>;
+  };
+}
+//#endregion
+//#region src/build-descriptor.d.ts
+declare class DescriptorBuilder {
+  private readonly doc;
+  private readonly schemas;
+  private readonly paths;
+  /** Lazily-built wire-type -> collection-level paginator kind (for per-relation divergence, D6a). */
+  private typePaginators?;
+  constructor(doc: OpenApiDocument);
+  /**
+   * The collection-level paginator kind for a WIRE type (`tracks`), memoised. Resolves each
+   * resource schema's wire type (its `type.const`) to the paginator of its collection GET — the
+   * baseline a per-relation related-endpoint paginator is compared against (D6a).
+   */
+  private typePaginator;
+  build(): ApiDescriptor;
+  /**
+   * The server-level Atomic Operations capability: the path whose `POST` requestBody
+   * declares the atomic ext media type ({@link ATOMIC_EXT}). `null` when no such endpoint
+   * exists. Server-level, so it rides {@link buildAtomic}, not the per-type descriptor.
+   */
+  buildAtomic(): AtomicDescriptor | null;
+  /**
+   * A resource schema is one whose name ends in `Resource` (but not
+   * `ResourceIdentifier`) and carries `properties.type.const` (a string) — that const
+   * is the descriptor key (the wire type). Never inferred from the schema name.
+   */
+  private resourceType;
+  /** Follow a `$ref` to its identifier/resource schema and read `properties.type.const`. */
+  private resolveConst;
+  private attributes;
+  private relations;
+  /**
+   * The per-relation mutation capability, derived from the HTTP methods the relationship
+   * endpoint (`{collection}/{id}/relationships/{rel}`) advertises. For a to-many:
+   * `add` <- POST, `remove` <- DELETE, `replace` <- PATCH. For a to-one: `set` <- PATCH.
+   * Only `true` verbs are emitted (a missing verb is simply absent). Returns `undefined`
+   * when the relation exposes no relationship endpoint at all.
+   */
+  private relationMutations;
+  /**
+   * Attach the per-relation endpoint-exposure signal to a relation descriptor (D24). The bundle
+   * can suppress a relation's related or relationship endpoint (`withoutRelatedEndpoint()` /
+   * `withoutRelationshipEndpoint()`, ADR 0027), which the OpenAPI reflects by simply omitting that
+   * relation's path — but codegen synthesizes generic `{rel}` templates, erasing the per-relation
+   * distinction. So mark `related: false` / `relationship: false` when this relation's specific
+   * path is absent, and ALWAYS emit an explicit `mutations` object (the verb flags when the
+   * relationship endpoint exists, else `{}`) so the client gates a suppressed relation OFF rather
+   * than failing open (offering `.get()`/`.related()`/mutations that 404).
+   */
+  private withRelationExposure;
+  /**
+   * Collect the custom actions for a type from its `{collection}/-actions/{name}` and
+   * `{collection}/{id}/-actions/{name}` paths. The action name is the last segment; scope
+   * is `resource` when the path carries `/{id}/`, else `collection`. `input` is `document`
+   * (a JSON:API requestBody), `none` (no requestBody) or `raw` (a non-JSON:API body);
+   * `output` is `document` (a 2xx returns a JSON:API document) or `none` (only `204`).
+   */
+  private actions;
+  /**
+   * The wire type (and cardinality) of a document component's primary `data` — a `$ref` to a
+   * resource, an inline object carrying `properties.type.const` (a create-request body), or an
+   * array of resource/identifier refs (a collection). `undefined` when the type can't be resolved.
+   */
+  private documentPrimary;
+  /** The wire type of a single `data` schema — a `$ref` to a resource, or an inline `type.const`. */
+  private dataConst;
+  /** The `$ref` of the first 2xx JSON:API response body on an operation (the output document). */
+  private firstOkJsonApiRef;
+  /** Resolve a relationship component's `data` into a {@link RelationDescriptor}. */
+  private relationFromComponent;
+  /**
+   * Extract the pivot field-shape from a pivot `allOf` — the entry carrying
+   * `properties.meta.properties.pivot.properties` (a `belongsToMany` member's `meta.pivot`), as a
+   * field-name → wire-format-hint map (D33). Returns `undefined` when the allOf carries no pivot
+   * property block.
+   */
+  private pivotFieldsFromAllOf;
+  /** Pull the related type from the `$ref` entry of an `allOf` (the pivot shape). */
+  private constFromAllOf;
+  /** Resolve every `$ref` entry in a list to its wire type. */
+  private constsFromRefs;
+  private clientId;
+  /**
+   * Find the collection path for a type, then derive each per-operation path that
+   * actually exists. The collection path P is the one whose POST requestBody refs
+   * `<Base>CreateRequest`, else the GET whose 200 response refs `<Base>Collection`.
+   */
+  private operationPaths;
+  private collectionPath;
+  /** Any `P/{id}/<rel>` related path (excludes relationships/ and custom `-actions`). */
+  private hasRelatedPath;
+  private hasRelationshipPath;
+  /** Detect the paginator kind from the fetchMany operation's query parameter names. */
+  private paginator;
+  /**
+   * Detect the paginator kind an operation advertises from its `page[...]` query parameter names.
+   * `page[number]`+`page[size]` = `page`; `page[offset]`+`page[limit]` = `offset`; either cursor
+   * bound (`page[after]`/`page[before]`) = `cursor` (link-driven, D44); anything else = `none`.
+   * `label` (a path, for the drift warning) names the endpoint when page params match no known kind.
+   */
+  private paginatorKindOf;
+  /**
+   * The `withCount` capability (Countable profile) for a type's COLLECTION read (`list`): the
+   * count tokens (`schema.items.enum`) + the negotiation profile (`x-profile`) carried by the
+   * collection GET's `withCount` query parameter. Returns `undefined` when the collection
+   * doesn't exist or advertises no `withCount`. The profile URI is never hardcoded — it is read
+   * from the parameter's `x-profile`.
+   *
+   * Deliberately scoped to the collection GET only. The per-endpoint token sets differ
+   * (a collection counts e.g. `tracks`; a related/relationship endpoint counts `_self_` and its
+   * own relations), so a single per-type `countable` can only honestly describe one endpoint.
+   * The fluent surface exposes `withCount` on `list` (the collection), so `countable` mirrors
+   * that endpoint — a related-GET fallback would advertise tokens `list` cannot legally send.
+   */
+  private countable;
+  /**
+   * The relation paths the read endpoints accept in `include` — the `include` query
+   * parameter's `schema.items.enum` (already including nested dotted paths) on the collection
+   * GET. Returns `undefined` when the collection advertises no `include` (nothing includable).
+   *
+   * Read from the collection GET to mirror {@see sortable}/{@see filterable}: the whole builder
+   * is collection-centric (a type with no collection path gets no `paths` at all), and the bundle
+   * advertises the same `include` enum on the collection and single-resource GETs.
+   */
+  private includable;
+  /**
+   * The sort tokens the COLLECTION read accepts — the `sort` query parameter's
+   * `schema.items.enum` (signed field names) on the collection GET. Returns `undefined` when
+   * the collection advertises no `sort` parameter (sorting unsupported).
+   */
+  private sortable;
+  /**
+   * The filter keys the COLLECTION read accepts in `filter[...]` (the `filter[<key>]` parameter
+   * names, `<key>` extracted), sorted for deterministic output. Returns `undefined` when the
+   * collection advertises no `filter[...]` parameters (filtering unsupported). Value shapes are
+   * deliberately not captured — `filter` values stay `unknown` (out of scope for v0.1).
+   */
+  private filterable;
+  private queryParamNames;
+  private operation;
+  private requestBodyRef;
+  private okResponseRef;
+}
+/** Build the {@link ApiDescriptor} from a parsed OpenAPI document. */
+declare function buildDescriptor(doc: OpenApiDocument): ApiDescriptor;
+/** Detect the server-level Atomic Operations capability (`null` when none). */
+declare function buildAtomic(doc: OpenApiDocument): AtomicDescriptor | null;
+//#endregion
+//#region src/emit.d.ts
+/** A relation name that will later collide with a fluent-surface verb. */
+interface VerbCollision {
+  type: string;
+  relation: string;
+}
+/**
+ * Find relations whose name shadows a reserved fluent-surface member (a handle accessor or a
+ * future write verb). Such relations are routed via `.rel(name)`; the codegen warns at build time.
+ */
+declare function detectVerbCollisions(descriptor: ApiDescriptor): VerbCollision[];
+declare class Emitter {
+  private readonly doc;
+  private readonly descriptor;
+  private readonly atomic;
+  private readonly schemas;
+  /** Wire type -> the schema `Base` (the `<Base>Resource` name minus `Resource`). */
+  private readonly baseByType;
+  /** Enum component names referenced by an attribute, in first-seen order. */
+  private readonly usedEnums;
+  /**
+   * Component-schema names whose dedicated interface is emitted (e.g. `AlbumsAttributes`,
+   * `AlbumsCreateAttributes`). A `$ref` to one of these resolves to the interface name
+   * rather than being re-expanded structurally — so an action envelope nests the precise,
+   * already-named attribute type. Populated as interfaces are emitted.
+   */
+  private readonly emittedInterfaces;
+  /** Component names mid-expansion in {@link tsType} — a cycle guard for self/mutually-referential `$ref`s. */
+  private readonly expanding;
+  /**
+   * The per-action alias names actually emitted, keyed `type -> actionName -> { input?; output? }`.
+   * Populated by {@link actionTypeAliases}; consumed by {@link actionTypesMap} so the action
+   * type-map only references aliases that exist (a `none` input/output contributes neither).
+   */
+  private readonly actionAliasNames;
+  /** Provenance of the source document, stamped into the generated header for drift tracking. */
+  private readonly provenance;
+  constructor(doc: OpenApiDocument, descriptor: ApiDescriptor, atomic: AtomicDescriptor | null);
+  /** Map each declared wire type back to the `Base` of its resource schema. */
+  private indexBases;
+  emit(): string;
+  private header;
+  private imports;
+  /** Per-type attribute interface, e.g. `export interface AlbumsAttributes { ... }`. */
+  private attributeInterface;
+  /**
+   * The per-type WRITE attribute interfaces — `<Pascal>CreateAttributes` and
+   * `<Pascal>UpdateAttributes` — from the `<Base>CreateAttributes`/`<Base>UpdateAttributes`
+   * components (readOnly fields are already excluded vs the read attributes by the bundle).
+   * Create marks a field required iff it sits in the component's `required`; Update makes
+   * every field optional. A read-only type (no create/update component) contributes nothing.
+   */
+  private writeAttributeInterfaces;
+  /**
+   * Per-action input/output type aliases for every type that declares custom actions. An
+   * action whose `input`/`output` resolves to a component schema gets a named alias
+   * (`<Pascal><Action>Input` / `<Pascal><Action>Output`) expanding that component via the
+   * shared {@link tsType} machinery — a `none` input/output (no body / a `204`) contributes
+   * no alias. Deterministic order: types, then action names (the descriptor is sorted).
+   */
+  private actionTypeAliases;
+  /**
+   * Emit the `ActionTypes` interface wiring the emitted per-action aliases onto the typed
+   * action surface — `type -> actionName -> { input?; output? }`, the client's fourth type
+   * argument. So `client.albums.id(id).actions.reissue(body)` takes `AlbumsReissueInput` and
+   * resolves `AlbumsReissueOutput` rather than a loose `Record<string,unknown>` / `unknown`.
+   * Only actions whose alias was emitted appear (a `none`-input/output action contributes the
+   * absent side, which the runtime types fall back to loosely). Emits `{}` when none exist.
+   */
+  private actionTypesMap;
+  /**
+   * The TS type alias (if any) for an action's request body.
+   *
+   * An action's RESULT and its FLAT input are derived at the type level from the descriptor
+   * (`outputType`/`outputCardinality` → the materialised resource view; `inputType` → the
+   * `CreateInput` of that type), so no `output` alias is emitted and a `document` input whose
+   * resource type resolves emits no `input` alias either. Only a bespoke command document (a
+   * `document` input with no resolvable `inputType`) keeps a raw-envelope alias as its typed body,
+   * expanded via {@link tsType} (falling back to a loose JSON:API document shape).
+   */
+  private actionBodyType;
+  /** Emit the server-level atomic capability constant (`{ path }` or `null`). */
+  private atomicConst;
+  /**
+   * Render an attribute interface from a property map, a field order, and a `required`
+   * predicate (true => no `?`). Shared by the read and write attribute interfaces so the
+   * tsType/JSDoc logic stays in one place.
+   */
+  private renderInterface;
+  /** Map a JSON Schema attribute node to a precise TypeScript type. */
+  private tsType;
+  /** The non-nullable TS type for the declared JSON type(s). */
+  private baseTsType;
+  private scalarOrComposite;
+  /** A nested object type from its `properties` (falls back to an index signature). */
+  private objectType;
+  private arrayType;
+  /** Union aliases for every enum component an attribute referenced, sorted by name. */
+  private enumAliases;
+  /**
+   * Documentation for an enum alias: a per-value list built from `x-enum-descriptions`
+   * (the richest hover DX, since a union alias can't carry per-member JSDoc), falling
+   * back to the component's own `description`.
+   */
+  private enumDoc;
+  /**
+   * Emit the `Attributes` interface mapping each wire type to its per-type attribute
+   * interface. The runtime descriptor only carries coarse format hints; this is how the
+   * precise per-type attribute types reach the bound client (passed as the second type
+   * argument to the runtime factory).
+   */
+  private attributesMap;
+  /**
+   * Emit the `WriteAttributes` interface mapping each writable wire type to its
+   * `{ create; update }` attribute pair. A read-only type (no create/update component)
+   * contributes no entry, so the bound client only exposes writes where the API allows
+   * them. Passed as the third type argument to the runtime factory.
+   */
+  private writeAttributesMap;
+  /** Emit the descriptor as a literal `as const satisfies ApiDescriptor`. */
+  private resourceMap;
+  /** Render a JSON-serialisable descriptor value as deterministic TS object-literal source. */
+  private literal;
+  private boundFactory;
+}
+/**
+ * Generate the full source of the client module for a document + its built descriptor.
+ * The server-level atomic capability is derived from the document (override via `atomic`).
+ */
+declare function emit(doc: OpenApiDocument, descriptor: ApiDescriptor, atomic?: AtomicDescriptor | null): string;
+//#endregion
+//#region src/reader.d.ts
+/** A self-contained JSON Schema document, keyed by JSON:API type, as served at `GET /schemas.json`. */
+type SchemaBundle = Record<string, SchemaObject>;
+/**
+ * Read an OpenAPI document from an http(s) URL or a local file path. Supports both JSON
+ * and YAML (decided by extension, falling back to a content sniff).
+ */
+declare function readDocument(input: string): Promise<OpenApiDocument>;
+/**
+ * Read the bundle's JSON Schema bundle (`GET /schemas.json`) from an http(s) URL or a
+ * local file path — a map keyed by JSON:API type, each value a self-contained JSON Schema
+ * 2020-12 resource-object document. Supports both JSON and YAML, like {@link readDocument}.
+ */
+declare function readSchemas(input: string): Promise<SchemaBundle>;
+//#endregion
+//#region src/emit-schemas.d.ts
+/**
+ * Emit the per-type JSON Schema map as a standalone generated artifact:
+ *
+ * ```ts
+ * export const schemas = { <type>: { …json schema… }, … } as const
+ * ```
+ *
+ * The values are the raw, self-contained resource-object JSON Schema documents the bundle
+ * serves at `GET /schemas.json` — suitable to hand straight to a validation engine via the
+ * opt-in `validate?` seam (ADR 0004). This is a separate file from the client so the main
+ * descriptor/client output is unaffected when `--schemas` is absent.
+ *
+ * The schemas are emitted as JSON (deterministic, key order preserved) so the artifact is
+ * stable to diff; `as const` keeps the literal shapes narrow.
+ */
+declare function emitSchemas(bundle: SchemaBundle): string;
+//#endregion
+//#region src/provenance.d.ts
+/**
+ * A deterministic provenance record identifying the spec a client was generated from.
+ * Stamped into every generated artifact's header so a reader (and the `--check` drift
+ * gate) can tell which spec produced the committed output. Deliberately timestamp-free
+ * — the same spec must always produce byte-identical output so `--check` can compare.
+ */
+interface Provenance {
+  /** `<title> <version>` from the document's `info` (falls back to `unknown` parts). */
+  readonly source: string;
+  /** The first declared server URL, or `undefined` when none is declared. */
+  readonly server: string | undefined;
+  /** A SHA-256 (first 16 hex chars) of the canonicalised source document. */
+  readonly hash: string;
+}
+/** A SHA-256 over an arbitrary JSON value (canonicalised), truncated to 16 hex chars (64 bits). */
+declare function hashJson(value: unknown): string;
+/**
+ * Derive the provenance record for a source OpenAPI document. The `source` identifier is
+ * `<info.title> <info.version>` (each part `unknown` when absent); the `hash` is a stable
+ * content hash of the whole document.
+ */
+declare function deriveProvenance(doc: OpenApiDocument): Provenance;
+/**
+ * Render the provenance record as the JSDoc header lines stamped into a generated artifact
+ * (each already prefixed with ` * `). Deterministic: no timestamp, so re-generating from the
+ * same spec yields byte-identical output.
+ */
+declare function provenanceLines(provenance: Provenance): string[];
+//#endregion
+//#region src/index.d.ts
+interface CodegenConfig {
+  /** OpenAPI document source: an http(s) URL or a local file path. */
+  input: string;
+  /** Output file (or directory) for the generated client. */
+  output: string;
+  /** Server name to target (the spec is per-server). Defaults to the default server. */
+  server?: string;
+  /** JSON Schema source for the validation seam (URL or path). Off when omitted. */
+  schemas?: string;
+  /**
+   * Drift-check mode: regenerate in-memory and compare against the committed `output`
+   * (and its schema artifact when `schemas` is set) instead of writing. Nothing is
+   * written; {@link check} reports whether the committed artifacts are up to date.
+   */
+  check?: boolean;
+}
+/** One artifact's drift status: the file it stands for, and whether it is up to date. */
+interface ArtifactDrift {
+  /** The committed artifact path (the client output, or its schema sibling). */
+  path: string;
+  /** True when the committed file matches the freshly generated content. */
+  upToDate: boolean;
+}
+/** The outcome of a {@link check} run: `ok` iff every checked artifact is up to date. */
+interface CheckResult {
+  ok: boolean;
+  artifacts: ArtifactDrift[];
+}
+/**
+ * The schema-artifact path beside a client output path: `client.gen.ts` -> `client.schemas.gen.ts`
+ * (any `.gen.ts`/`.ts` suffix is preserved; a suffix-less path just gains `.schemas`).
+ */
+declare function schemasOutputPath(output: string): string;
+/**
+ * Read the OpenAPI document, build the runtime descriptor, emit the generated client
+ * module and write it to `config.output` (creating parent directories as needed).
+ *
+ * When `config.schemas` is set, also read the bundle's JSON Schema bundle and write a
+ * separate per-type schema artifact (`<output>.schemas.gen.ts`) beside the client, wiring
+ * the opt-in validation seam (ADR 0004). The main client output is unchanged either way.
+ *
+ * `config.server` is metadata-only for now: the served document is already per-server,
+ * so the caller selects the server by pointing `input` at the right document.
+ *
+ * Returns the generated client source. When `config.check` is set nothing is written;
+ * call {@link check} instead for the drift-gate result.
+ */
+declare function generate(config: CodegenConfig): Promise<string>;
+/**
+ * Drift gate: regenerate every artifact in memory and compare it byte-for-byte against the
+ * committed file on disk, WITHOUT writing anything. A missing committed file counts as drift
+ * (not up to date). Returns per-artifact status plus an aggregate `ok` (true iff all match) —
+ * the CI drift check reads `ok` and exits non-zero when it is false.
+ */
+declare function check(config: CodegenConfig): Promise<CheckResult>;
+//#endregion
+export { ResponseObject as A, InfoObject as C, ParameterObject as D, OperationObject as E, SchemaOrBool as M, PathItemObject as O, HttpMethod as S, OpenApiDocument as T, detectVerbCollisions as _, generate as a, buildAtomic as b, deriveProvenance as c, emitSchemas as d, SchemaBundle as f, VerbCollision as g, Emitter as h, check as i, SchemaObject as j, RequestBodyObject as k, hashJson as l, readSchemas as m, CheckResult as n, schemasOutputPath as o, readDocument as p, CodegenConfig as r, Provenance as s, ArtifactDrift as t, provenanceLines as u, emit as v, MediaTypeObject as w, buildDescriptor as x, DescriptorBuilder as y };
+//# sourceMappingURL=index-C0becRSc.d.mts.map

package/dist/index-C0becRSc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C0becRSc.d.mts","names":[],"sources":["../src/openapi.ts","../src/build-descriptor.ts","../src/emit.ts","../src/reader.ts","../src/emit-schemas.ts","../src/provenance.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { A as ResponseObject, C as InfoObject, D as ParameterObject, E as OperationObject, M as SchemaOrBool, O as PathItemObject, S as HttpMethod, T as OpenApiDocument, _ as detectVerbCollisions, a as generate, b as buildAtomic, c as deriveProvenance, d as emitSchemas, f as SchemaBundle, g as VerbCollision, h as Emitter, i as check, j as SchemaObject, k as RequestBodyObject, l as hashJson, m as readSchemas, n as CheckResult, o as schemasOutputPath, p as readDocument, r as CodegenConfig, s as Provenance, t as ArtifactDrift, u as provenanceLines, v as emit, w as MediaTypeObject, x as buildDescriptor, y as DescriptorBuilder } from "./index-C0becRSc.mjs";
+export { ArtifactDrift, CheckResult, CodegenConfig, DescriptorBuilder, Emitter, type HttpMethod, type InfoObject, type MediaTypeObject, type OpenApiDocument, type OperationObject, type ParameterObject, type PathItemObject, type Provenance, type RequestBodyObject, type ResponseObject, type SchemaBundle, type SchemaObject, type SchemaOrBool, type VerbCollision, buildAtomic, buildDescriptor, check, deriveProvenance, detectVerbCollisions, emit, emitSchemas, generate, hashJson, provenanceLines, readDocument, readSchemas, schemasOutputPath };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { a as readSchemas, c as detectVerbCollisions, d as hashJson, f as provenanceLines, h as buildDescriptor, i as readDocument, l as emit, m as buildAtomic, n as generate, o as emitSchemas, p as DescriptorBuilder, r as schemasOutputPath, s as Emitter, t as check, u as deriveProvenance } from "./src-B24cYyjM.mjs";
+export { DescriptorBuilder, Emitter, buildAtomic, buildDescriptor, check, deriveProvenance, detectVerbCollisions, emit, emitSchemas, generate, hashJson, provenanceLines, readDocument, readSchemas, schemasOutputPath };