diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,1372 @@
+# Hydra changelog
+
+All notable changes to the Hydra project are documented in this file.
+
+This changelog tracks changes across all Hydra implementations
+(Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Emacs Lisp, Scheme)
+and supporting infrastructure.
+
+The format is inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and [Apache TinkerPop](https://github.com/apache/tinkerpop/blob/master/CHANGELOG.asciidoc).
+
+Pre-1.0 versions are listed below.
+Untagged versions correspond to in-repository version bumps that were not pushed as Git tags or Hackage releases;
+they are documented here for completeness.
+
+---
+
+## [0.17.0] - 2026-07-01
+
+Major themes: first-class support for effects and I/O in the kernel, TypeScript and
+Scala reaching publishable parity with the other hosts, and continued maturation of
+the published-host build model.
+
+### Highlights
+
+- **Effects and I/O** ([#286](https://github.com/CategoricalData/hydra/issues/286),
+  [#288](https://github.com/CategoricalData/hydra/issues/288),
+  [#494](https://github.com/CategoricalData/hydra/issues/494)): a new `effect` variant
+  on `hydra.core.Type` for representing effectful computations; new kernel modules
+  `hydra.file` (`FilePath`, `FileType`, `FileStatus`, `FileExtension`), `hydra.time`
+  (`Timespec`), and `hydra.error.file`; new primitive libraries `hydra.lib.effects`,
+  `hydra.lib.files`, and `hydra.lib.text` with byte-level I/O; and a new
+  `EffectfulTestCase` mechanism so the common test suite can exercise effectful
+  primitives across hosts.
+- **TypeScript is a complete implementation**
+  ([#462](https://github.com/CategoricalData/hydra/issues/462)): self-hosts and passes
+  the common test suite, with a per-package npm publish pipeline
+  ([#492](https://github.com/CategoricalData/hydra/issues/492)).
+- **Scala publishing**: per-package Maven Central publish infrastructure
+  ([#491](https://github.com/CategoricalData/hydra/issues/491)).
+- **Published-host build model**: published mode now compiles the kernel from the
+  co-generated `dist/haskell` rather than Hackage, removing the need for a
+  `haskell=local` shim ([#500](https://github.com/CategoricalData/hydra/issues/500));
+  the oil-and-water principle and cold-build workflow for `dist/haskell` are documented
+  ([#376](https://github.com/CategoricalData/hydra/issues/376)).
+- **Kernel hygiene**: `uniqueLabel` (apostrophe suffixes) replaced by `chooseUniqueLabel`
+  (numeric suffixes) in `hydra.names`
+  ([#436](https://github.com/CategoricalData/hydra/issues/436)).
+
+### Implementations
+
+Eight hosts self-host and pass the common test suite across five families: Haskell,
+Java, Python, Scala, and the four Lisp dialects (Clojure, Common Lisp, Scheme, Emacs
+Lisp), with TypeScript now joining as a complete host/target. Go remains a "head bud"
+(the coder still has emission bugs and the head's runtime is largely placeholder; it
+does not yet host the test suite).
+
+### New Features
+
+- Translingual cross-reference convention for `doc` strings: doc-escape tags render to
+  each host's native doc syntax (Javadoc, Haddock, Sphinx, TSDoc)
+  ([#433](https://github.com/CategoricalData/hydra/issues/433)).
+- Neo4j JSON-artifact validation demo, exercised across Java, Python, Haskell, and
+  TypeScript ([#510](https://github.com/CategoricalData/hydra/issues/510)).
+
+### Improvements
+
+- The Java/Maven publish set now covers every official Hydra target language, one coder
+  package per implementation family
+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).
+- JVM Maven artifact groups are bifurcated to `net.fortytwo.hydra.java` and
+  `net.fortytwo.hydra.scala`, so the Java and Scala (and future Clojure) publish sets
+  never collide on coordinates
+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).
+- Host-specific third-party integrations (the former `bindings/` tree) are folded into
+  `overlay/`, unifying hand-written host-native source under one tree
+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).
+- The coder de-parameterizes context and error types, simplifying generated coder
+  signatures ([#518](https://github.com/CategoricalData/hydra/issues/518)).
+- TypeScript-to-Java generation now emits the `hydra.lib.*` aggregate namespace
+  interfaces (`Maps`, `Strings`, etc.)
+  ([#499](https://github.com/CategoricalData/hydra/issues/499)).
+
+---
+
+## [0.16.1] - 2026-06-16
+
+Major themes: the first release built by bootstrapping from previously published
+packages, the first full 9 × 9 cross-implementation bootstrapping sweep, and
+published-package self-containment fixes for the artifacts that bootstrap rests on.
+
+### Highlights
+
+- **Bootstrap from published packages**: the build links the published 0.16.0 hosts
+  (Hackage / Maven Central / PyPI) and uses them to build the next version of Hydra,
+  resting on 0.16.0's forward-compatibility guarantees — the published-host consume
+  model with a `--local-host` shim, used for the first time in a release
+  ([#370](https://github.com/CategoricalData/hydra/issues/370)). 0.16.1 still builds
+  against **local** Haskell and Python hosts (`hostOverrides`), because the published
+  0.16.0 artifacts it would otherwise consume are the very ones being repaired below.
+- **First full 9 × 9 bootstrapping sweep** — every implementation generating every
+  other; dozens of cross-host issues surfaced and fixed
+  ([#409](https://github.com/CategoricalData/hydra/issues/409), ongoing).
+- **Published-package self-containment**: relocate each host's hand-written runtime
+  into `overlay/<lang>/hydra-kernel/` so it ships inside the published `hydra-kernel`
+  artifact — Python `hydra.python.util` into the wheel
+  ([#461](https://github.com/CategoricalData/hydra/issues/461),
+  [#472](https://github.com/CategoricalData/hydra/issues/472)) and the Haskell
+  authoring DSL + `Libraries`/`Terms` into the sdist
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)). Generalized to a
+  uniform `overlay/ = transform(packages) + copy(overlay)` model across all hosts
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- **Kernel self-containment via generated `hydra.lib.*` registries**: primitive
+  names are derived from generated `PrimitiveDefinition` def-modules rather than
+  hand-written name strings, in every host
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).
+- **In-memory encode/decode synthesis**: derived `hydra.{encode,decode}.*` modules
+  are synthesized at build time and excluded from `dist/`, with the synthesizer (not
+  inference) as the authority for their annotations
+  ([#448](https://github.com/CategoricalData/hydra/issues/448),
+  [#476](https://github.com/CategoricalData/hydra/issues/476)).
+- **Release hardening**: Apache source-release compliance (signed source archive,
+  LICENSE/NOTICE bundling, KEYS) ([#441](https://github.com/CategoricalData/hydra/issues/441)),
+  per-package publish orchestrators ([#449](https://github.com/CategoricalData/hydra/issues/449)),
+  and packaging-boundary verification gated in CI and at publish time
+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).
+
+### New features
+
+- Published-host consume model wired through `bin/sync.sh` for all three hosts
+  (`--published-host` default, `--local-host` shim), with the version basis keyed
+  off `hydra.json` and the `VERSION` file retired
+  ([#370](https://github.com/CategoricalData/hydra/issues/370),
+  [#347](https://github.com/CategoricalData/hydra/issues/347)).
+- Java and Python coder DSL sources made the sole source of truth; the legacy
+  Haskell DSL copies were deleted and cross-package references resolve by name
+  ([#346](https://github.com/CategoricalData/hydra/issues/346)).
+- Per-host `verify-distribution.sh` self-containment gates (Haskell stages the
+  per-package trio and `stack build`s it; Python installs the wheels into an
+  isolated venv and imports the kernel modules; Java resolves the published jars
+  from an offline consumer), run in CI and as a hard gate in `bin/prepare-release.sh`
+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).
+- Apache-compliant canonical source archive: signed + checksummed `git archive`
+  tarball as the release of record, root `NOTICE`, `KEYS`, and a release-verify CI
+  workflow ([#441](https://github.com/CategoricalData/hydra/issues/441)).
+- Per-package publish orchestrators `publish-maven.sh` / `publish-pypi.sh` with
+  dependency-closure and leaves-first ordering checks
+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).
+- `hydra-typescript` published as a target Java/Maven + PyPI artifact
+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).
+- Java coder emits a fluent builder for every generated record type
+  ([#465](https://github.com/CategoricalData/hydra/issues/465)); Python coder emits
+  per-field `with_<field>` copy-update methods and a fluent builder
+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).
+
+### Improvements
+
+- Drop the vestigial `InferenceContext` parameter from the `Primitive.implementation`
+  carrier across all hosts; add a graph-free `funT` coder and six `lists` default
+  implementations ([#446](https://github.com/CategoricalData/hydra/issues/446)).
+- Derive package routing from declared modules; split derived generation into broad
+  `mainDslModules` and scoped `mainEncodingModules`
+  ([#474](https://github.com/CategoricalData/hydra/issues/474),
+  [#475](https://github.com/CategoricalData/hydra/issues/475)).
+- Hash JSON content into the per-package input digest; add `digest-check
+  refresh-input` and a CI guard that force-regenerates and diffs
+  `dist/haskell/hydra-{java,python}` ([#469](https://github.com/CategoricalData/hydra/issues/469)).
+- Per-package inference seeds downstream packages from each package's full universe
+  while inferring only write targets, fixing `hydra-scala` inference within the CI
+  heap budget; declare the `hydra-java` dependency in `hydra-scala` for cold
+  ordering ([#470](https://github.com/CategoricalData/hydra/issues/470)).
+- Remove the vestigial `Lib/Defaults` registry and empty `defaultLibModules`
+  manifest field from all hosts ([#437](https://github.com/CategoricalData/hydra/issues/437)).
+- Bundle LICENSE + NOTICE into Java jars (`META-INF`) and Python wheels
+  (`dist-info`); declare Apache-2.0 in the Scala build
+  ([#441](https://github.com/CategoricalData/hydra/issues/441)).
+- Mark lazy parameters on the Scala and Common Lisp primitive registries so eager
+  coders thunk correctly ([#453](https://github.com/CategoricalData/hydra/issues/453),
+  [#477](https://github.com/CategoricalData/hydra/issues/477),
+  [#425](https://github.com/CategoricalData/hydra/issues/425)).
+- Staging-loop WIP-commit gate to keep `WIP:` commits off `origin/main`
+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).
+
+### Bug fixes
+
+- **Python wheel self-containment**: the `hydra-kernel` wheel now ships
+  `hydra.python.util`; gated by a packaging-boundary smoke test in CI and
+  `publish-pypi.sh` ([#472](https://github.com/CategoricalData/hydra/issues/472),
+  [#461](https://github.com/CategoricalData/hydra/issues/461)).
+- **Haskell sdist self-containment**: track the generated `Hydra/Dsl/Terms.hs`
+  (was gitignored) so the committed dist exports `ToPrimName`, fixing the cold
+  build of the published `hydra-kernel`
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).
+- Decode synthesizer threads the fully-applied result type into wrap/record/union
+  decoder bodies, so derived decoders emit `DataRow<v>` rather than raw `DataRow`,
+  fixing Java and Scala generic decode compilation
+  ([#476](https://github.com/CategoricalData/hydra/issues/476)).
+- Scala coder emits explicit type arguments for polymorphic non-primitive
+  references under a type application (e.g. `requireField`), fixing `Any`-inference
+  of curried decoder lambda parameters in `decode/typed`
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- Common Lisp and Emacs Lisp: move the hand-written runtime to a dialect-tier path
+  so it no longer collides with the generated `hydra.lib.*` def-modules
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- Python coder uses the binding `TypeScheme` as the authoritative source for
+  parameter and return types ([#488](https://github.com/CategoricalData/hydra/issues/488));
+  fixes a duplicate `self` parameter in builders
+  ([#478](https://github.com/CategoricalData/hydra/issues/478)).
+- Sort term definitions by name in source-file generation so non-Haskell hosts emit
+  deterministic alphabetical Haskell output (host-independent of `Maps.elems`
+  iteration order) ([#489](https://github.com/CategoricalData/hydra/issues/489)).
+- Java coder serializes the `static` method modifier (previously a non-exhaustive
+  case) ([#465](https://github.com/CategoricalData/hydra/issues/465)); JavaDoc
+  `@link`/`@param` sanitization for strict doclint
+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).
+- Scala host writer appends a trailing newline when missing, fixing a Lisp-target
+  byte mismatch ([#463](https://github.com/CategoricalData/hydra/issues/463)).
+- Clojure host: silent wrapping `bigint_to_int{8,16,32,64}` casts per the kernel
+  contract ([#483](https://github.com/CategoricalData/hydra/issues/483)); load-order
+  and `--kernel-only` filter fixes after kernel renames
+  ([#425](https://github.com/CategoricalData/hydra/issues/425)); load the
+  `hydra-haskell` baseline for Clojure→Haskell rebuilds
+  ([#487](https://github.com/CategoricalData/hydra/issues/487),
+  [#460](https://github.com/CategoricalData/hydra/issues/460)).
+- Lisp-dialect bootstrap fixes: emit JSON object entries as 2-element `Pair` lists
+  rather than dotted cons ([#452](https://github.com/CategoricalData/hydra/issues/452),
+  also fixing [#16](https://github.com/CategoricalData/hydra/issues/16)); read
+  module names via the correct struct accessor
+  ([#471](https://github.com/CategoricalData/hydra/issues/471)); drop stale
+  surplus flag arguments from `generate-source-files` calls
+  ([#457](https://github.com/CategoricalData/hydra/issues/457),
+  [#458](https://github.com/CategoricalData/hydra/issues/458),
+  [#464](https://github.com/CategoricalData/hydra/issues/464)); rename eta-wrapped
+  projection/unwrap parameters to avoid kernel shadowing
+  ([#428](https://github.com/CategoricalData/hydra/issues/428)); propagate a
+  non-zero exit from the Scheme test runner on failures and fix Scheme float
+  scientific-notation formatting for `|x| >= 1e7`
+  ([#447](https://github.com/CategoricalData/hydra/issues/447)).
+- Cross-host target dispatch: Common Lisp and Clojure hosts dispatch Scala and
+  TypeScript targets ([#482](https://github.com/CategoricalData/hydra/issues/482),
+  [#483](https://github.com/CategoricalData/hydra/issues/483)); Scala/Java host
+  target-dispatch completions ([#5](https://github.com/CategoricalData/hydra/issues/5),
+  [#7](https://github.com/CategoricalData/hydra/issues/7),
+  [#17](https://github.com/CategoricalData/hydra/issues/17)).
+- TypeScript test runtime reads the kernel JSON field names `body`/`signature`
+  (not legacy `term`/`typeScheme`); `lists.nub` dedups by canonical JSON
+  ([#485](https://github.com/CategoricalData/hydra/issues/485)).
+- Sync robustness: always reassemble `dist/python` under `HYDRA_IN_SYNC` to heal
+  partial-dist state ([#480](https://github.com/CategoricalData/hydra/issues/480));
+  persist the run dir on bootstrap prep-phase failures
+  ([#481](https://github.com/CategoricalData/hydra/issues/481)); complete per-host
+  static deps so the bootstrap demo finds fresh dist
+  ([#445](https://github.com/CategoricalData/hydra/issues/445)).
+- Pin the Python target test interpreter to Python ≥ 3.12
+  ([#486](https://github.com/CategoricalData/hydra/issues/486)); Emacs Lisp / Scheme
+  target test-runner re-copy robustness
+  ([#456](https://github.com/CategoricalData/hydra/issues/456)).
+- JavaDoc Pages publish rewritten to build a combined site from the CI-generated
+  `dist/java/` artifact, fixing the failure mode where `pages.yml` ran against a
+  bare checkout with no `dist/java/` present
+  ([#450](https://github.com/CategoricalData/hydra/issues/450)).
+
+### Documentation
+
+- Document the `overlay/` self-containment model, the published-host consume model
+  for all three hosts, the `hydra.json` version / host-version basis, and a
+  migration-shims recipe ([#434](https://github.com/CategoricalData/hydra/issues/434),
+  [#370](https://github.com/CategoricalData/hydra/issues/370),
+  [#347](https://github.com/CategoricalData/hydra/issues/347)).
+- Document the kernel self-containment / `hydra.lib.*` def-module model and the
+  derived-module no-inference invariant
+  ([#473](https://github.com/CategoricalData/hydra/issues/473),
+  [#466](https://github.com/CategoricalData/hydra/issues/466)); generated Java and
+  Python record builders documented in the DSL guides
+  ([#465](https://github.com/CategoricalData/hydra/issues/465),
+  [#466](https://github.com/CategoricalData/hydra/issues/466)).
+- Use absolute GitHub URLs in package READMEs so links resolve when published
+  standalone ([#454](https://github.com/CategoricalData/hydra/issues/454)); bundle a
+  README into each Python package dir for sdist metadata
+  ([#418](https://github.com/CategoricalData/hydra/issues/418)).
+
+---
+
+## [0.16.0] - 2026-06-09
+
+Major themes: primitive-metadata reification, self-hosting coder DSLs with all
+eight hosts passing the common test suite, finalized `hydra.packaging`, and a
+deep kernel-vocabulary cleanup.
+
+### Highlights
+
+- **`PrimitiveDefinition` and per-namespace registry modules** with host-independent
+  specs for every standard-library primitive ([#156](https://github.com/CategoricalData/hydra/issues/156), [#319](https://github.com/CategoricalData/hydra/issues/319)).
+- **Self-hosting coder DSLs; all eight hosts pass the common test suite**, including
+  the completed TypeScript head ([#344](https://github.com/CategoricalData/hydra/issues/344), [#126](https://github.com/CategoricalData/hydra/issues/126)).
+- **Finalized `hydra.packaging`** and a unified `Module.dependencies` field ([#369](https://github.com/CategoricalData/hydra/issues/369), [#354](https://github.com/CategoricalData/hydra/issues/354)).
+- **Kernel-vocabulary cleanup**: `maybe`→`optional` across kernel and hosts, plus
+  order-preserving JSON objects ([#401](https://github.com/CategoricalData/hydra/issues/401), [#398](https://github.com/CategoricalData/hydra/issues/398)).
+
+### New features
+
+- Reify `PrimitiveDefinition` in `hydra.packaging` with per-namespace `hydra.lib.<sub>` registries ([#156](https://github.com/CategoricalData/hydra/issues/156)).
+- Host-independent `comments` specifications for all standard-library primitives ([#319](https://github.com/CategoricalData/hydra/issues/319)).
+- Kernel-oriented style checks in `hydra.validate.*` ([#321](https://github.com/CategoricalData/hydra/issues/321), [#351](https://github.com/CategoricalData/hydra/issues/351), [#352](https://github.com/CategoricalData/hydra/issues/352)), on a reshaped validation API ([#320](https://github.com/CategoricalData/hydra/issues/320)).
+- Promote the JSON Schema coder to a full DSL coder ([#350](https://github.com/CategoricalData/hydra/issues/350)).
+- Transpose coder sources into host-native DSLs for self-hosting ([#344](https://github.com/CategoricalData/hydra/issues/344), [#358](https://github.com/CategoricalData/hydra/issues/358)).
+- `Term`-typed annotations replacing `Map<Name, Term>` ([#386](https://github.com/CategoricalData/hydra/issues/386)).
+- Language-specific EDSL features on the kernel `Language` ([#233](https://github.com/CategoricalData/hydra/issues/233)).
+- Primitive-metadata-driven laziness in eager coders ([#391](https://github.com/CategoricalData/hydra/issues/391)).
+- `/test` skill and `bin/test.sh` for target-language test validation ([#387](https://github.com/CategoricalData/hydra/issues/387)).
+- Automatic differentiation: a `grad` transform ([#324](https://github.com/CategoricalData/hydra/issues/324)).
+- `hydra.show.error.pg` for `InvalidGraphError` ([#374](https://github.com/CategoricalData/hydra/issues/374)).
+
+### Improvements
+
+- Finalize `hydra.packaging`: `Binding`→`TypeDefinition`, `Module`/`Package` `comments`, `moduleName` cleanup ([#369](https://github.com/CategoricalData/hydra/issues/369), [#396](https://github.com/CategoricalData/hydra/issues/396), [#402](https://github.com/CategoricalData/hydra/issues/402), [#404](https://github.com/CategoricalData/hydra/issues/404)).
+- Merge `Module.termDependencies`/`typeDependencies` into one `dependencies` field ([#354](https://github.com/CategoricalData/hydra/issues/354)).
+- Resolve the `maybe`/`optional` ambiguity across kernel and all hosts ([#401](https://github.com/CategoricalData/hydra/issues/401)).
+- Order-preserving JSON objects; order-sensitive `Value` equality ([#398](https://github.com/CategoricalData/hydra/issues/398)).
+- Rename `Namespace`→`ModuleName` ([#316](https://github.com/CategoricalData/hydra/issues/316)) and the phantom DSL types to `Typed*` ([#397](https://github.com/CategoricalData/hydra/issues/397)).
+- Move from a type-class enum to type-class names ([#275](https://github.com/CategoricalData/hydra/issues/275)).
+- Repackage "eval lib" modules as kernel lib modules; promote remaining sources ([#260](https://github.com/CategoricalData/hydra/issues/260), [#355](https://github.com/CategoricalData/hydra/issues/355), [#356](https://github.com/CategoricalData/hydra/issues/356)).
+- Reshape `hydra.context` into `InferenceContext` ([#368](https://github.com/CategoricalData/hydra/issues/368)).
+- Streamline the Haskell, Java, Python, and Scala syntax models, re-pinning Java to SE 21 and Python to the 3.14 PEG grammar ([#297](https://github.com/CategoricalData/hydra/issues/297)).
+- Adopt persistent immutable collections across hosts ([#359](https://github.com/CategoricalData/hydra/issues/359), [#360](https://github.com/CategoricalData/hydra/issues/360), [#361](https://github.com/CategoricalData/hydra/issues/361), [#362](https://github.com/CategoricalData/hydra/issues/362)).
+- Migrate underscored kernel definition names to camelCase ([#348](https://github.com/CategoricalData/hydra/issues/348)).
+- Tidy qualified/unqualified imports in the Haskell DSL sources ([#308](https://github.com/CategoricalData/hydra/issues/308)).
+- Eliminate the `Hydra.Module.Compat` shim ([#315](https://github.com/CategoricalData/hydra/issues/315)).
+- Homogenize writer conventions across target languages ([#339](https://github.com/CategoricalData/hydra/issues/339)).
+- Disambiguate format-version field naming across JSON metadata ([#412](https://github.com/CategoricalData/hydra/issues/412)).
+- Per-package DSL→JSON build with per-package incremental inference ([#381](https://github.com/CategoricalData/hydra/issues/381), [#395](https://github.com/CategoricalData/hydra/issues/395)).
+- Prune stale `dist/` outputs; self-heal digests; exclude digests from VCS; reconcile drift; fail loud ([#357](https://github.com/CategoricalData/hydra/issues/357), [#393](https://github.com/CategoricalData/hydra/issues/393), [#405](https://github.com/CategoricalData/hydra/issues/405), [#378](https://github.com/CategoricalData/hydra/issues/378), [#379](https://github.com/CategoricalData/hydra/issues/379), [#392](https://github.com/CategoricalData/hydra/issues/392), [#414](https://github.com/CategoricalData/hydra/issues/414)).
+- Accept all valid (host, target) pairs in the generation drivers ([#421](https://github.com/CategoricalData/hydra/issues/421)).
+- Move Gradle build infrastructure into `heads/java/`; remove top-level `pixi.toml` ([#384](https://github.com/CategoricalData/hydra/issues/384), [#385](https://github.com/CategoricalData/hydra/issues/385)).
+- Eliminate post-generation test patches; fix loader/runner kludges; re-enable test timing ([#307](https://github.com/CategoricalData/hydra/issues/307), [#309](https://github.com/CategoricalData/hydra/issues/309), [#311](https://github.com/CategoricalData/hydra/issues/311)).
+- Performance/benchmarks and usability assessments ([#277](https://github.com/CategoricalData/hydra/issues/277), [#283](https://github.com/CategoricalData/hydra/issues/283)).
+- Split the Hackage distribution into per-package distributions ([#418](https://github.com/CategoricalData/hydra/issues/418)).
+
+### Bug fixes
+
+- Encode `uint32` JSON literals as numbers, not strings ([#431](https://github.com/CategoricalData/hydra/issues/431)).
+- Satisfy or suppress warnings in generated Java ([#349](https://github.com/CategoricalData/hydra/issues/349)).
+- Restore JSON parser test cases (polymorphic case handling, ordering fallback) ([#336](https://github.com/CategoricalData/hydra/issues/336)).
+- Keep annotations through `termAlternatives`/`typeAlternatives` adaptation ([#353](https://github.com/CategoricalData/hydra/issues/353)).
+- Scala host decodes module JSON containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).
+- Java coder: fix exponential `let`-bound `cases` cost ([#372](https://github.com/CategoricalData/hydra/issues/372)) and explicit type args on `PersistentMap.ofEntries` ([#394](https://github.com/CategoricalData/hydra/issues/394)).
+- Python-host codegen: drop extra `pyStringToPyStrings` wrapping ([#367](https://github.com/CategoricalData/hydra/issues/367)).
+- `escape_literal_char` no longer mangles RDF triples ([#363](https://github.com/CategoricalData/hydra/issues/363)).
+- Sync robustness: stale coder JSON, omitted native modules, dead helper, bad source dirs ([#406](https://github.com/CategoricalData/hydra/issues/406), [#400](https://github.com/CategoricalData/hydra/issues/400), [#411](https://github.com/CategoricalData/hydra/issues/411), [#408](https://github.com/CategoricalData/hydra/issues/408)).
+- Cross-host self-hosting fixes (Scala, TypeScript, and the four Lisp dialects) ([#422](https://github.com/CategoricalData/hydra/issues/422), [#423](https://github.com/CategoricalData/hydra/issues/423), [#424](https://github.com/CategoricalData/hydra/issues/424), [#429](https://github.com/CategoricalData/hydra/issues/429), [#444](https://github.com/CategoricalData/hydra/issues/444), [#366](https://github.com/CategoricalData/hydra/issues/366), [#389](https://github.com/CategoricalData/hydra/issues/389), [#407](https://github.com/CategoricalData/hydra/issues/407), [#425](https://github.com/CategoricalData/hydra/issues/425), [#426](https://github.com/CategoricalData/hydra/issues/426), [#427](https://github.com/CategoricalData/hydra/issues/427), [#432](https://github.com/CategoricalData/hydra/issues/432), [#438](https://github.com/CategoricalData/hydra/issues/438), [#439](https://github.com/CategoricalData/hydra/issues/439), [#443](https://github.com/CategoricalData/hydra/issues/443)).
+
+### Removed
+
+- Removed the `bigfloat` literal type from `FloatType` and `FloatValue` ([#330](https://github.com/CategoricalData/hydra/issues/330)).
+  Arbitrary-precision floating-point values were inconsistently supported
+  across host languages (Java/Scala in particular lacked a true IEEE 754
+  arbitrary-precision implementation), and nothing in the codebase relied on
+  them. `FloatType` and `FloatValue` now have only `float32` and `float64`
+  variants. Removed library primitives: `bigfloatToBigint`, `bigfloatToFloat32`,
+  `bigfloatToFloat64`, `bigintToBigfloat`, `float32ToBigfloat`,
+  `float64ToBigfloat`, `readBigfloat`, `showBigfloat`, `roundBigfloat`. New
+  primitives `float32ToFloat64` and `float64ToFloat32` (the latter lossy)
+  replace the removed bigfloat-routed conversions.
+- Removed `heads/haskell/bin/assemble-hackage-sdist.sh` ([#418](https://github.com/CategoricalData/hydra/issues/418)), the 0.15-era
+  bridge that flattened the multi-source-dir Haskell head into one self-contained
+  `hydra` sdist. Superseded by the per-package assembler (see Improvements).
+
+### Documentation
+
+- Comprehensive documentation refresh for 0.16 ([#383](https://github.com/CategoricalData/hydra/issues/383))
+  spanning nine tracks across READMEs, `docs/`, the wiki, CLAUDE.md, and
+  in-source kernel comments.
+- New `docs/json-format.md` reference describing the canonical JSON wire format
+  (tagged-union duality, optional-field rules, IEEE 754 sentinels, integer
+  threshold).
+- New wiki pages: `Design` (rationale behind each major choice) and `Inference`
+  (HM type inference with class constraints).
+- Cross-checked every prose doc against current code; corrected drift in
+  primitive-checking sections of `docs/recipes/maintenance.md`, the `Primitive`
+  shape in `docs/implementation.md` and `docs/recipes/adding-primitives.md`,
+  and the build-system narrative.
+- Wove motivation ("the why") through the existing doc surface rather than
+  collecting it into separately-titled sidebars; landed an inference-overview
+  centerpiece on the wiki ([#377](https://github.com/CategoricalData/hydra/issues/377)).
+- Aligned doc vocabulary with the LambdaGraph paper and the literature review
+  for the design space Hydra inhabits.
+- Net-new READMEs for `packages/hydra-kernel`, `packages/hydra-ext`,
+  `packages/hydra-coq`, and `packages/hydra-wasm`; top-level `README.md`
+  now carries a canonical packages table.
+- Audited and refreshed the Claude surface: CLAUDE.md "Where to look up X"
+  table extended with rows for `docs/getting-started.md`, `docs/json-format.md`,
+  and the `Design` / `Inference` wiki pages; hard-rules block reordered by
+  violation frequency; `claude/pitfalls.md` superseded entries folded into
+  `docs/troubleshooting.md` / recipes.
+- Project-descriptor strings reviewed and aligned across 24 build / packaging
+  files (Hackage synopsis, Maven Central description, PyPI / conda-forge
+  classifiers, Hydra-format `package.json` files).
+- `docs/index.html` (the GitHub Pages landing page) refreshed with audience
+  hops into wiki Concepts / Design, `docs/getting-started.md`, and the GitHub
+  repo, plus the full published-artifact list across Hackage, Maven Central,
+  PyPI, and conda-forge.
+- In-source kernel-code rationale comments added at key Sources sites covering
+  injection / pair / either / unit-void duality, error taxonomy, variant
+  records, inference-context threading, validation profiles, reduction state,
+  lexical filters, name mangling, scoping, variable handling, defaults
+  integration, and Tarjan SCC choice rationale. JSON encode/decode modules
+  cross-reference `docs/json-format.md`.
+- Filed `Primitive.implementation` carrier-simplification follow-up
+  ([#446](https://github.com/CategoricalData/hydra/issues/446))
+  to drop the unused `InferenceContext` and `Graph` parameters once the
+  `Lib/Defaults/` integration ([#437](https://github.com/CategoricalData/hydra/issues/437))
+  lands.
+
+---
+
+## [0.15.0] - 2026-04-29
+
+A structural-cleanup release.
+The repository is reorganized into a three-tree
+`packages/` (DSL sources) / `heads/` (per-host runtime) / `dist/` (generated output)
+layout ([#290](https://github.com/CategoricalData/hydra/issues/290)), the kernel is simplified ([#251](https://github.com/CategoricalData/hydra/issues/251), [#292](https://github.com/CategoricalData/hydra/issues/292), [#332](https://github.com/CategoricalData/hydra/issues/332)), and Java + Python now
+ship as per-package publishable artifacts on Maven Central / PyPI / conda-forge
+([#305](https://github.com/CategoricalData/hydra/issues/305)).
+Incremental, content-hash-based caches accelerate the sync pipeline ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+Three new generation-only targets — Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)), and an
+automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)) — are in progress as Claude collaborations.
+
+### Highlights
+
+- **Three-tree repository layout**: `packages/` (DSL), `heads/` (host runtime),
+  `dist/` (generated) ([#290](https://github.com/CategoricalData/hydra/issues/290)).
+- **Per-package distributions** for Java (4 Maven artifacts) and Python (5 wheels):
+  `hydra-kernel`, `hydra-pg`, `hydra-rdf`, `hydra-{java,python}`, plus `hydra-ext`
+  on PyPI ([#305](https://github.com/CategoricalData/hydra/issues/305)).
+- **Kernel simplifications**: `Function`/`Elimination` removed ([#332](https://github.com/CategoricalData/hydra/issues/332)),
+  `FunctionPrimitive` removed ([#251](https://github.com/CategoricalData/hydra/issues/251)), `Hydra.Ext.*` prefix retired ([#331](https://github.com/CategoricalData/hydra/issues/331)),
+  `Context` error wrapper gone ([#292](https://github.com/CategoricalData/hydra/issues/292)).
+- **Incremental caches** across the sync pipeline; ~70x speedup on no-op resync ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+- **JSON kernel format v1** with formal wire-format spec and four-field rename ([#343](https://github.com/CategoricalData/hydra/issues/343)).
+- **Three new generation-only targets** (in progress): Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)),
+  automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)).
+
+### New features
+
+- Per-package distributions ([#305](https://github.com/CategoricalData/hydra/issues/305)): standalone Maven / PyPI / conda-forge builds,
+  generated `build.gradle` / `pyproject.toml` per package, transitive dep resolution.
+- JSON kernel format v1 ([#343](https://github.com/CategoricalData/hydra/issues/343)): formal spec at `docs/json-format.md`,
+  four-field rename to `typeScheme`, `Module` field reorder, `formatVersion` stamp.
+- `decimal` literal type in the kernel ([#338](https://github.com/CategoricalData/hydra/issues/338)) across all hosts.
+- Type-directed JSON encoder with idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314), [#318](https://github.com/CategoricalData/hydra/issues/318)).
+- Incremental type inference plus content-hash caches ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+- Coq generation target ([#326](https://github.com/CategoricalData/hydra/issues/326), in progress): `hydra-coq` package, 131/131 `.v` files pass `coqc`.
+- WebAssembly target ([#325](https://github.com/CategoricalData/hydra/issues/325), in progress): `hydra-wasm` package, M4 closure mechanism.
+- Automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324), in progress): symbolic source-to-source.
+- `hydra.show.error` module ([#265](https://github.com/CategoricalData/hydra/issues/265)): consolidated error-message builders.
+- `hydra.lib.maybes.toList` primitive ([#257](https://github.com/CategoricalData/hydra/issues/257)).
+- NaN / Inf round-tripping through JSON and per-language serdes ([#312](https://github.com/CategoricalData/hydra/issues/312), [#318](https://github.com/CategoricalData/hydra/issues/318), [#330](https://github.com/CategoricalData/hydra/issues/330)).
+- Typeclass inference test group ([#274](https://github.com/CategoricalData/hydra/issues/274)).
+- Term and type linters ([#232](https://github.com/CategoricalData/hydra/issues/232)).
+- Validation for modules and graphs ([#155](https://github.com/CategoricalData/hydra/issues/155)).
+- User-defined-function (UDF) support and DSL-vs-primitive overrides
+  ([#62](https://github.com/CategoricalData/hydra/issues/62), [#63](https://github.com/CategoricalData/hydra/issues/63), [#102](https://github.com/CategoricalData/hydra/issues/102), [#158](https://github.com/CategoricalData/hydra/issues/158)).
+- Stale-source detection across sync entrypoints ([#228](https://github.com/CategoricalData/hydra/issues/228)).
+
+### Improvements
+
+- Sync infrastructure: matrix tool, per-package orchestrator, per-language wrappers ([#290](https://github.com/CategoricalData/hydra/issues/290)).
+- TestGraph post-generation patches eliminated; DSL emits `TestEnv` refs directly.
+- Minimized standard imports in generated Haskell ([#161](https://github.com/CategoricalData/hydra/issues/161)); improved auto-aliases ([#322](https://github.com/CategoricalData/hydra/issues/322)).
+- Removed kernel term dependencies from the interpreter ([#257](https://github.com/CategoricalData/hydra/issues/257)).
+- Removed `Graph` and `Context` arguments from primitive implementations ([#266](https://github.com/CategoricalData/hydra/issues/266)).
+- Refactored kernel term modules: split rewriting/schemas, renamed show.meta → codegen,
+  moved `Coder` to `coders`, merged `extract.helpers` ([#221](https://github.com/CategoricalData/hydra/issues/221)).
+- Removed Aeson and HsYAML dependencies; YAML coder moved to `hydra-ext` ([#261](https://github.com/CategoricalData/hydra/issues/261)).
+- Lisp recursive let bindings via SCC ([#341](https://github.com/CategoricalData/hydra/issues/341)); parenthesis cleanup ([#84](https://github.com/CategoricalData/hydra/issues/84)).
+- Everything-to-everything bootstrapping demo ([#254](https://github.com/CategoricalData/hydra/issues/254)).
+- Re-enabled skipped Python tests; `disabledForPython` retired ([#263](https://github.com/CategoricalData/hydra/issues/263)).
+- Promoted host-specific code in `packages/` into per-head locations ([#337](https://github.com/CategoricalData/hydra/issues/337)).
+- Migrated `hydra.common` Java module out ([#10](https://github.com/CategoricalData/hydra/issues/10)).
+- Test infrastructure unification under `UniversalTestCase` ([#246](https://github.com/CategoricalData/hydra/issues/246)).
+- Default property graph → RDF mapping ([#296](https://github.com/CategoricalData/hydra/issues/296)).
+- 13 unsafe partial primitives replaced with `Maybe`-returning alternatives ([#201](https://github.com/CategoricalData/hydra/issues/201)).
+- Java generated code uses standard `java.util` collection interfaces ([#313](https://github.com/CategoricalData/hydra/issues/313)).
+- `Term.union` renamed to `Term.inject` ([#334](https://github.com/CategoricalData/hydra/issues/334)).
+- Inconsistencies in domain DSLs cleaned up ([#219](https://github.com/CategoricalData/hydra/issues/219)).
+- Coder packages moved out of hydra-haskell ([#182](https://github.com/CategoricalData/hydra/issues/182)).
+- Java package-naming scheme revised ([#223](https://github.com/CategoricalData/hydra/issues/223)).
+- Decimal used (instead of bigfloat) for JSON numbers ([#340](https://github.com/CategoricalData/hydra/issues/340)).
+- Hydra kernel moved out of hydra-haskell ([#282](https://github.com/CategoricalData/hydra/issues/282)).
+
+### Bug fixes
+
+- `substInTypeScheme` capture-unsafe substitution under nested forall binders.
+- Java `Float64` arithmetic primitives corrected for current `PrimitiveFunction` API.
+- Clojure decimal handling: value-based equality, `BigInteger` return from `decimal_to_bigint`.
+- Scheme runtime R7RS imports for `sets.scm` / `maps.scm` / `eithers.map_set`.
+- Python coder defaults corrected from `Py.Name` to `Py.Expression`.
+- Scala host JSON-decode failure on modules containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).
+- Lisp coder mutually-recursive let bindings for Clojure ([#341](https://github.com/CategoricalData/hydra/issues/341)).
+
+### Documentation
+
+- Documentation refresh for the 0.15 packaging restructure ([#290](https://github.com/CategoricalData/hydra/issues/290), [#331](https://github.com/CategoricalData/hydra/issues/331)); CLAUDE.md,
+  READMEs, recipes, demos, and seven wiki pages updated.
+- Code-generation recipe rewritten for the per-package dist layout ([#282](https://github.com/CategoricalData/hydra/issues/282)).
+- New `maintenance.md` recipe consolidates non-source-file scans, stale generated
+  detection, design-violation checks, and freshness checks.
+- Documentation style guide added at `docs/documentation-style-guide.md`.
+- Cross-worktree messaging protocol documented in CLAUDE.md.
+- Decimal type documented in the lexicon and per-language READMEs ([#338](https://github.com/CategoricalData/hydra/issues/338)).
+- JSON encoding format docs updated for idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314)).
+
+---
+
+## [0.14.1] - 2026-03-30
+
+Patch release.
+Regenerates all implementations after a fix to the group eval primitive ([#281](https://github.com/CategoricalData/hydra/issues/281)),
+and relocates the property-graph and RDF/SHACL "ext" modules into hydra-java and hydra-python.
+
+### Improvements
+
+- Moved PG, RDF, and SHACL ext modules from hydra-ext into hydra-java and hydra-python.
+
+### Bug fixes
+
+- Group eval primitive fix; all targets regenerated ([#281](https://github.com/CategoricalData/hydra/issues/281)).
+- JavaDoc HTML-entity escaping in generated `DestructuringPattern.java`.
+
+---
+
+## [0.14.0] - 2026-03-29
+
+Major release adding four new complete Hydra implementations — Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)),
+Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, and Scheme — bringing the total to seven bootstrapping hosts
+(plus Emacs Lisp, which passes the test suite but does not yet participate in bootstrapping).
+Also includes kernel simplifications, an Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)),
+eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)), new demos, and significant performance work on the Scheme host.
+
+### Highlights
+
+- **Four new complete implementations**: Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)), Hydra-Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)),
+  Hydra-Common Lisp, and Hydra-Scheme pass the common test suite and can serve as
+  bootstrapping hosts.
+  The four Lisp dialects share a single coder and serializer.
+- **Kernel simplifications**: removed `RowType`/`WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)),
+  unified `Graph`/`TypeContext`/`InferenceContext` ([#192](https://github.com/CategoricalData/hydra/issues/192)),
+  replaced `Module.elements` with `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)),
+  consolidated error types ([#268](https://github.com/CategoricalData/hydra/issues/268)), and promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).
+- **Avro bidirectional coder** ([#301](https://github.com/CategoricalData/hydra/issues/301)) with property graph pipeline demo.
+- **Scheme bootstrap performance**: 58 minutes → 5.7 minutes via O(1) vhash data structures
+  and IEEE 754 float precision fixes.
+
+### Breaking changes
+
+- Removed legacy adapter framework; replaced by the staging-promoted variant ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).
+- Replaced legacy Flow monad with Either ([#245](https://github.com/CategoricalData/hydra/issues/245)).
+- Removed `Module.elements`; use `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)).
+- Removed `RowType` and `WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)).
+- Renamed `hydra.accessors` to `hydra.paths` ([#271](https://github.com/CategoricalData/hydra/issues/271)).
+- Renamed `hydra.tarjan` and merged into `hydra.sorting` ([#220](https://github.com/CategoricalData/hydra/issues/220)).
+- Merged `hydra.constraints` into `hydra.query` ([#272](https://github.com/CategoricalData/hydra/issues/272)).
+- Moved `hydra.workflow` to hydra-ext ([#270](https://github.com/CategoricalData/hydra/issues/270)).
+- Consolidated `hydra.compute` into `hydra.util` ([#269](https://github.com/CategoricalData/hydra/issues/269)).
+- Removed `hydra.describe` ([#216](https://github.com/CategoricalData/hydra/issues/216)) and types from `hydra.mantle` ([#217](https://github.com/CategoricalData/hydra/issues/217)).
+- Replaced `OtherError` with task-specific error types ([#268](https://github.com/CategoricalData/hydra/issues/268)).
+- Java: lowered minimum Java version to 11 ([#249](https://github.com/CategoricalData/hydra/issues/249)).
+- Java: `Pair` replaces `Tuple2` ([#252](https://github.com/CategoricalData/hydra/issues/252)); `Comparable` implemented for generated classes ([#131](https://github.com/CategoricalData/hydra/issues/131)).
+
+### New features
+
+- Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)): complete implementation, sbt/Scala 3, 3043 tests.
+- Hydra-Lisp: Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, Emacs Lisp, Scheme — four dialects,
+  one coder. CI workflows for Clojure, Common Lisp, and Scheme.
+- Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)) with demo.
+- Eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)): Logic, Equality, Math, collections, and Groups.
+- Generated DSL modules ([#180](https://github.com/CategoricalData/hydra/issues/180)): `hydra.dsls` generates DSL helpers from type modules.
+- New demos: GraphQL+JSON ([#279](https://github.com/CategoricalData/hydra/issues/279)), PG validation ([#284](https://github.com/CategoricalData/hydra/issues/284)), SHACL ([#294](https://github.com/CategoricalData/hydra/issues/294)), Avro+PG.
+- Packaging module ([#290](https://github.com/CategoricalData/hydra/issues/290)): `hydra.packaging` with `Package` type and validation.
+- New primitives: `lists.foldr` ([#280](https://github.com/CategoricalData/hydra/issues/280)), `maybes.toList`, float rounding ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).
+- Cross-language benchmarking suite ([#234](https://github.com/CategoricalData/hydra/issues/234)).
+- Limited typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)).
+- Standardized validation patterns across modules ([#291](https://github.com/CategoricalData/hydra/issues/291)).
+
+### Improvements
+
+- Promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).
+- Removed legacy adapters, JSON/YAML coders, grammar framework ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).
+- Java: efficient immutable data structures ([#193](https://github.com/CategoricalData/hydra/issues/193)); flattened term naming.
+- Java: hidden specialized collection classes in type-level files ([#313](https://github.com/CategoricalData/hydra/issues/313)).
+- Inference error messages improved ([#231](https://github.com/CategoricalData/hydra/issues/231)).
+- Combined nested let bindings in the Haskell coder ([#248](https://github.com/CategoricalData/hydra/issues/248)).
+- Simplified `hydra.adapt.simple` ([#255](https://github.com/CategoricalData/hydra/issues/255)).
+- Removed Haskell operators dependency from tests ([#288](https://github.com/CategoricalData/hydra/issues/288)).
+- Regression tests for non-Haskell/Java coders ([#85](https://github.com/CategoricalData/hydra/issues/85)).
+- Regex support added ([#293](https://github.com/CategoricalData/hydra/issues/293)).
+- `hydra.annotations.isNativeType` revisited ([#214](https://github.com/CategoricalData/hydra/issues/214)).
+- Migrated grammar-generated models ([#295](https://github.com/CategoricalData/hydra/issues/295)).
+- `<<= -shouldBe-> <<~` operator change ([#276](https://github.com/CategoricalData/hydra/issues/276)).
+- Minimize Generation.hs ([#225](https://github.com/CategoricalData/hydra/issues/225)).
+- Implemented missing Flows primitives ([#183](https://github.com/CategoricalData/hydra/issues/183)).
+- Removed JavaDocs from the repository ([#262](https://github.com/CategoricalData/hydra/issues/262)).
+- Floating-point test portability fixes for Linux CI ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).
+- Moved YAML coder to hydra-ext ([#224](https://github.com/CategoricalData/hydra/issues/224)).
+- Minimized native Python and Java primitives in favor of DSL implementations ([#244](https://github.com/CategoricalData/hydra/issues/244)).
+- Removed the `disabledForPython` test tag ([#250](https://github.com/CategoricalData/hydra/issues/250)).
+
+### Release tooling
+
+- 0.14 release tracking ([#304](https://github.com/CategoricalData/hydra/issues/304)).
+
+### Documentation
+
+- Thorough cleanup of user documentation ([#302](https://github.com/CategoricalData/hydra/issues/302), [#303](https://github.com/CategoricalData/hydra/issues/303)).
+- Coding style guide added to wiki.
+- Updated 'new implementation' recipe with learnings from Clojure head ([#278](https://github.com/CategoricalData/hydra/issues/278)).
+
+---
+
+## [0.13.0] - 2026-02-27
+
+Major release completing Hydra-Python ([#66](https://github.com/CategoricalData/hydra/issues/66)) and Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)) as self-hosting Hydra implementations
+and demonstrating mutual self-hosting across all three languages.
+Significant improvements to type inference, type checking, rewriting, and adaptation.
+New language features include first-class Either types, typeclass inference, binary data support,
+and a native JSON parser/writer.
+Comprehensive tooling for cross-implementation bootstrapping
+and provisional support for Go, Rust, and JavaScript targets.
+
+### Highlights
+
+- **Mutual self-hosting across three implementations**: Hydra is now fully self-hosting
+  in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)), Java, and Python, and can cross-generate between every combination
+  of host and target language (9 paths total).
+- **Hydra-Java is complete** ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass.
+- **Hydra-Python is complete** ([#66](https://github.com/CategoricalData/hydra/issues/66)): 100% test parity with Haskell.
+- **Language coders promoted into the Hydra kernel** ([#176](https://github.com/CategoricalData/hydra/issues/176)): Haskell, Java, and Python
+  coders are now defined as Hydra DSL modules, making them self-hosting.
+- **Either type support** ([#210](https://github.com/CategoricalData/hydra/issues/210)) with full inference, checking, and library support.
+- **Native JSON parser and writer** ([#188](https://github.com/CategoricalData/hydra/issues/188), [#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)): Hydra's own JSON parser and writer
+  replace the Aeson dependency; bootstrap-from-JSON architecture for cross-implementation
+  code generation.
+
+### Breaking changes
+
+- Renamed `Optional` to `Maybe` throughout the codebase ([#204](https://github.com/CategoricalData/hydra/issues/204)):
+  `hydra.lib.optionals` → `hydra.lib.maybes`; all `optional` variants renamed to `maybe`.
+- Removed unlabeled product and sum types; replaced with pair types ([#212](https://github.com/CategoricalData/hydra/issues/212)).
+- Renamed `hydra.core.TypedTerm` to `hydra.core.TypeApplicationTerm`.
+- Renamed `hydra.json` to `hydra.json.model`.
+- Renamed `hydra.lib.maps.remove` to `hydra.lib.maps.delete`.
+- Removed deprecated `hydra.decoding` module.
+- Removed old `hydra.mantle.Either` type (replaced by core `Either`).
+- Removed `hydra.lib.tuples` library.
+- Removed C# coder stub (C# syntax model remains).
+- DSL syntax migration: removed `OverloadedStrings` for term expressions ([#238](https://github.com/CategoricalData/hydra/issues/238)).
+- Removed `Hydra.Dsl.ShorthandTypes` ([#222](https://github.com/CategoricalData/hydra/issues/222)).
+
+### New features
+
+- Self-hosting in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)) and full mutual cross-generation (Haskell ↔ Java ↔ Python).
+- New bootstrapping demo validating all 9 paths across 249 modules.
+- Promoted Haskell, Java, and Python coders from staging code into Hydra DSL sources ([#176](https://github.com/CategoricalData/hydra/issues/176)).
+- JSON-as-source-of-truth bootstrapping architecture ([#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)):
+  new executables and scripts enabling `bootstrap-from-json` for cross-implementation
+  code generation.
+- Generated term encoders and decoders replace legacy hand-coded modules ([#47](https://github.com/CategoricalData/hydra/issues/47)).
+- Hydra-Python completion ([#66](https://github.com/CategoricalData/hydra/issues/66)): restructured project layout with `src/main` and
+  `src/gen-main` ([#191](https://github.com/CategoricalData/hydra/issues/191)); full library implementations including `hydra.lib.flows`;
+  `@lru_cache` optimization for nullary bindings; PyPy compatibility.
+- Hydra-Java completion ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass; deep changes
+  to Java coder; `Lazy` utility class for delayed evaluation; array-type support
+  in Java serde; tail-call optimization in the Java coder; `Tuple` implements `Comparable`.
+- Either type ([#210](https://github.com/CategoricalData/hydra/issues/210)): `EitherType`, `either` term constructor, `hydra.lib.eithers` library
+  with `either`, `map`, `mapList`, `mapMaybe`, `bimap`, `bind`, `fromLeft`, `fromRight`,
+  `isLeft`, `isRight`, `lefts`, `rights`, `partitionEithers`.
+- Pair type as a core construct ([#211](https://github.com/CategoricalData/hydra/issues/211)).
+- Void type ([#237](https://github.com/CategoricalData/hydra/issues/237)): uninhabited `void` type as the dual of `unit`; type-level only.
+- Native JSON parser and writer ([#188](https://github.com/CategoricalData/hydra/issues/188), [#242](https://github.com/CategoricalData/hydra/issues/242)):
+  bidirectional JSON encoder/decoder; replaces the Aeson dependency;
+  cross-checked via a special test runner.
+- Typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)):
+  type schemes with typeclass constraints via `TypeVariableMetadata`;
+  typeclass metadata on primitive definitions; Haskell coder uses typeclass info.
+- Binary/`ByteString` support ([#172](https://github.com/CategoricalData/hydra/issues/172)): binary data via `ByteString` instead of `String`;
+  Haskell coder uses `Data.ByteString`; new `binaryToBytes` primitive.
+- Parser combinators: new `hydra.parsing` module with combinator types and DSL.
+- Higher-order primitive interpreter ([#198](https://github.com/CategoricalData/hydra/issues/198)): all primitives are fully interpretable
+  across all three implementations; legacy `requiresInterp` tag removed.
+- Let hoisting and flattening: hoisting polymorphic let terms;
+  refined hoisting for monomorphic bindings inside polymorphic ones;
+  more efficient `liftLambdaAboveLet` ([#202](https://github.com/CategoricalData/hydra/issues/202));
+  case-statement hoisting ([#241](https://github.com/CategoricalData/hydra/issues/241)); subterm hoisting helpers.
+- Provisional language targets: Go ([#65](https://github.com/CategoricalData/hydra/issues/65)), Rust (with experimental type-level coder),
+  JavaScript (syntax model, serde, DSL, generated sources), and Java/Python syntax DSLs.
+- New adapter framework ([#236](https://github.com/CategoricalData/hydra/issues/236)): all external coders refactored
+  (Haskell, YAML, Scala, JSON Schema, C++, PDL, Protobuf, GraphQL).
+- Compact labeled records and variants ([#122](https://github.com/CategoricalData/hydra/issues/122)).
+- New primitives:
+  `hydra.lib.lists.find`, `hydra.lib.lists.partition`,
+  `hydra.lib.flows.withDefault`, `hydra.lib.flows.foldl`,
+  `hydra.lib.math.{max,min,abs,pred,signum,succ,even,odd}`,
+  `hydra.lib.pairs.bimap`, `hydra.lib.eithers.bind`,
+  `hydra.lib.literals.binaryToBytes`, complete `readXxx`/`showXxx` families,
+  `hydra.lexical.chooseUniqueName`, `neg` renamed to `negate`,
+  full floating-point math primitives in Python ([#208](https://github.com/CategoricalData/hydra/issues/208)).
+- DeepCore DSL: a layer one level deeper than the Meta DSLs,
+  for programs that construct programs that construct terms.
+- `typeOf` implementation ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+- Implement `Comparable` for generated Java classes ([#131](https://github.com/CategoricalData/hydra/issues/131)); update of Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)).
+- Compact labeled records exploration ([#122](https://github.com/CategoricalData/hydra/issues/122)).
+- Comparison primitives without typeclasses ([#187](https://github.com/CategoricalData/hydra/issues/187)).
+- Investigated core support for Either and Flow monads ([#200](https://github.com/CategoricalData/hydra/issues/200)).
+
+### Improvements
+
+- Type system:
+  - Refactored `hydra.inference` to create new module `hydra.checking`.
+  - Inference checks after unification to prevent schema names from being unified
+    with inferred type variables.
+  - Type application terms preserved when preparing application terms for Python.
+  - Sanity-check tuple projection index against arity during inference.
+  - Bind lost type variables in term annotations.
+  - Made `extendTypeContextForLet` tolerant of untyped bindings.
+- Code generation:
+  - Python: support for deeply-nested match statements; more complete `let` support;
+    Pythonic syntax for polymorphic function definitions; refinements for complex
+    case-hoisting scenarios; performance improvements ([#209](https://github.com/CategoricalData/hydra/issues/209), [#239](https://github.com/CategoricalData/hydra/issues/239), [#240](https://github.com/CategoricalData/hydra/issues/240)); inline
+    let/case rewriting for Python targets ([#203](https://github.com/CategoricalData/hydra/issues/203)).
+  - Java: method declaration style consistent with calling style.
+  - Haskell: standardized typeclass names.
+  - Increased maximum trace depth to support more complex sources.
+- Common test suite promotion: all tests promoted into a shared, implementation-independent
+  test kernel ([#213](https://github.com/CategoricalData/hydra/issues/213)).
+- Statically-compiled test suite in Haskell ([#207](https://github.com/CategoricalData/hydra/issues/207)).
+- Included all Hydra kernel types in test schema ([#205](https://github.com/CategoricalData/hydra/issues/205)).
+- Reorganized Haskell DSL definitions; standardized imports.
+- Added TODO comments to all unsafe primitives ([#201](https://github.com/CategoricalData/hydra/issues/201)).
+- New `rewriteAndFoldTerm` utility for simultaneous rewriting and folding.
+- Lexical helper for dereferencing schema types through aliases.
+- Made JSON parser lazy with new `lazy` parser combinator.
+- More efficient substitution helpers for empty substitutions.
+- Precomputed type/inference context in kernel test runner for performance.
+- Property graph encoding and decoding modules promoted into DSL.
+- `hydra.tabular` and `hydra.pg.graphson` modules promoted into DSL.
+- `hydra.show.*` modules generated into Java and Python.
+- Aligned epsilon encoding with the LambdaGraph spec ([#89](https://github.com/CategoricalData/hydra/issues/89)).
+- Fixed asymmetry of introductions and eliminations ([#86](https://github.com/CategoricalData/hydra/issues/86), [#134](https://github.com/CategoricalData/hydra/issues/134)).
+- Minimized inferred type annotations ([#114](https://github.com/CategoricalData/hydra/issues/114)).
+- Investigated combining products with records, sums with unions ([#196](https://github.com/CategoricalData/hydra/issues/196), [#212](https://github.com/CategoricalData/hydra/issues/212)).
+- Refined type reduction in adapters ([#144](https://github.com/CategoricalData/hydra/issues/144)).
+- Investigation of unification issues ([#163](https://github.com/CategoricalData/hydra/issues/163)).
+- Refactored RowType ([#82](https://github.com/CategoricalData/hydra/issues/82)).
+- LLM-assisted PG schemas and mappings ([#171](https://github.com/CategoricalData/hydra/issues/171)).
+- Simplified unit-valued variants in Python ([#206](https://github.com/CategoricalData/hydra/issues/206)).
+- Checked for inconsistencies between Term/TTerm and Type/TType DSLs ([#218](https://github.com/CategoricalData/hydra/issues/218)).
+- GenPG demo: refactored to support Haskell, Python, and Java; Python runner;
+  Java generation; finalized output format.
+- Testing: extended test runners for let hoisting (Haskell, Python, Java);
+  floating-point precision tests; ordering tests for `hydra.lib.maps`/`hydra.lib.sets`;
+  inference tests for inferred System F terms; case-hoisting test cases; new JSON coder tests;
+  thorough test cases for all primitives ([#199](https://github.com/CategoricalData/hydra/issues/199)).
+
+### Bug fixes
+
+- Fixed interpreter bugs causing test failures ([#235](https://github.com/CategoricalData/hydra/issues/235)).
+- Fixed bug in type checking in connection with dead code.
+- Fixed bug in `removeTypesFromTerm`.
+- Fixed bug in `typeOfMap`.
+- Fixed 32-bit max int value in `hydra.constants`.
+- Fixed numeric precision in Python.
+- Added `BigDecimal` support and fixed `uint8` (short) support in Java.
+- Fixed Haskell coder with respect to imports for binary literals.
+- Excluded `Prelude.encodeFloat` and `Prelude.decodeFloat` from generated Haskell
+  due to name collisions.
+- Fixed consistency issues in Python primitives:
+  `hydra.lib.sets.toList`, `hydra.lib.maps.union` (precedence),
+  `hydra.lib.strings.lines`, `hydra.lib.strings.readString` (dequoting),
+  `hydra.lib.lists.apply`, `hydra.lib.maps.toList`.
+- Fixed Haskell type signature of `hydra.lists.span`.
+- Fixed issue with eta expansion of typed terms.
+- Fixed shadowing issue in generated encoding modules.
+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.
+
+### Documentation
+
+- Updated main README with complete implementation status.
+- Added Documentation sections to all implementation READMEs.
+- Fixed outdated Code-organization.md (Python now uses `src/gen-main`).
+- Fixed incorrect code paths in Implementation.md.
+- Added Java section to Testing wiki.
+- Comprehensive developer recipes in `docs/recipes/`.
+- Documentation for tail-call optimization implementation.
+- Added Haddock comments to Haskell primitives.
+- Created wiki page on the release process ([#194](https://github.com/CategoricalData/hydra/issues/194)).
+
+### Community
+
+- Accepted babeloff's `isTrivialTerm` changes.
+
+---
+
+## [0.12.0] - 2025-08-28
+
+A consolidation release: significant Python progress, kernel-level cleanup,
+and a wave of bookkeeping closures for Hydra-Java module ports.
+
+### Breaking changes
+
+- Removed `hydra.decoding` module ([#190](https://github.com/CategoricalData/hydra/issues/190)).
+- Flattened dependency tiers; eliminated tier-1, tier-2, tier-3 organization ([#184](https://github.com/CategoricalData/hydra/issues/184)).
+- Removed `typed` term variant ([#173](https://github.com/CategoricalData/hydra/issues/173), [#162](https://github.com/CategoricalData/hydra/issues/162)).
+- Module naming changes: moved tabular and relational modules into kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).
+- Standardized on uncurried helper functions in term-level DSLs ([#174](https://github.com/CategoricalData/hydra/issues/174)).
+- Renamed `hydra.lib.flows.traverseOptional` to `hydra.lib.flows.mapOptional`.
+- Eliminated camel-cased namespace parts from the kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).
+- Replaced list and optional eliminations with primitive functions ([#150](https://github.com/CategoricalData/hydra/issues/150)).
+- Moved `Hydra.Ext` to hydra-ext ([#178](https://github.com/CategoricalData/hydra/issues/178)); moved 'ext' sources into hydra-ext ([#189](https://github.com/CategoricalData/hydra/issues/189)).
+
+### New features
+
+- Significant progress toward Hydra-Python completion:
+  generated all kernel types and terms into Python;
+  added `Decimal` support for bigfloat values;
+  environment tracking for variable scoping;
+  generated `hydra.languages` into Python;
+  `__hash__` and `__eq__` on serializable generated classes ([#160](https://github.com/CategoricalData/hydra/issues/160)).
+- Designated `unit` term and type variants ([#186](https://github.com/CategoricalData/hydra/issues/186)).
+- `hydra.lib.flows.mapElems` and `hydra.lib.flows.mapKeys` utilities.
+- Promoted JSON coder into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).
+- Promoted JSON utilities into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).
+- C# coder ([#139](https://github.com/CategoricalData/hydra/issues/139)).
+- GQL model and parser ([#140](https://github.com/CategoricalData/hydra/issues/140)).
+- Tabular adapters ([#142](https://github.com/CategoricalData/hydra/issues/142)).
+- Type-level C++ coder ([#170](https://github.com/CategoricalData/hydra/issues/170)).
+- Variable-types-to-Haskell-typedefs transformation ([#70](https://github.com/CategoricalData/hydra/issues/70)).
+- A newline at the end of each generated file ([#154](https://github.com/CategoricalData/hydra/issues/154)).
+- Refactor kernel modules and primitives by connectivity ([#177](https://github.com/CategoricalData/hydra/issues/177)).
+
+### Improvements
+
+- Condensed repeated elements in error traces ([#165](https://github.com/CategoricalData/hydra/issues/165)).
+- Fixed transitive schema dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).
+- Improved adapter solution with respect to literals.
+- Better handling of type variables in Python coder.
+- Enhanced term-level Python generation with proper ordering to minimize forward references.
+- Topo-sort helper function for dependency management.
+- Updated all Python libraries with latest changes.
+- Distinguished between deannotation and detyping of terms.
+- Adapted primitives when applying language constraints to a graph.
+- Use unqualified names where possible in generated code ([#153](https://github.com/CategoricalData/hydra/issues/153)).
+- Eliminated `Data.Graph` (containers) dependency ([#167](https://github.com/CategoricalData/hydra/issues/167)).
+- "Close the loop" demonstration ([#175](https://github.com/CategoricalData/hydra/issues/175)).
+- Implemented `typeOf` ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+
+### Bug fixes
+
+- Fixed System F terms for records and case statements ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+- Fixed issue with transitive type-level module dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).
+- Corrected handling of variable references in Python application terms.
+- Fixed nullary functions in Python (added empty parens).
+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.
+
+### Bookkeeping
+
+- Closed long-standing Hydra-Java module-port issues
+  ([#9](https://github.com/CategoricalData/hydra/issues/9), [#11](https://github.com/CategoricalData/hydra/issues/11), [#15](https://github.com/CategoricalData/hydra/issues/15), [#16](https://github.com/CategoricalData/hydra/issues/16), [#18](https://github.com/CategoricalData/hydra/issues/18), [#19](https://github.com/CategoricalData/hydra/issues/19), [#20](https://github.com/CategoricalData/hydra/issues/20), [#21](https://github.com/CategoricalData/hydra/issues/21), [#22](https://github.com/CategoricalData/hydra/issues/22), [#23](https://github.com/CategoricalData/hydra/issues/23), [#25](https://github.com/CategoricalData/hydra/issues/25), [#44](https://github.com/CategoricalData/hydra/issues/44), [#45](https://github.com/CategoricalData/hydra/issues/45));
+  most of the underlying work shipped in earlier releases.
+- Closed Hydra-Java DSL-port issues ([#24](https://github.com/CategoricalData/hydra/issues/24), [#26](https://github.com/CategoricalData/hydra/issues/26), [#27](https://github.com/CategoricalData/hydra/issues/27), [#28](https://github.com/CategoricalData/hydra/issues/28), [#29](https://github.com/CategoricalData/hydra/issues/29)) and
+  the Scala/Avro tracking issues ([#77](https://github.com/CategoricalData/hydra/issues/77), [#81](https://github.com/CategoricalData/hydra/issues/81)); these had been resolved
+  by earlier releases (Scala in 0.14.0, Avro bidi in 0.14.0).
+
+### Documentation
+
+- Updated Hydra-Haskell README.
+- Updated Hydra-Java README with corrected links.
+- Updated JavaDocs.
+
+---
+
+## [0.11.0] - 2025-03-16
+
+Untagged in-repository version.
+A type-inference rebase release: major restructuring of inference internals
+to align with Algorithm W, plus a sweeping removal of explicit type annotations
+across the kernel.
+
+### Highlights
+
+- **Inference rebased on Algorithm W** ([#118](https://github.com/CategoricalData/hydra/issues/118)): unify-early strategy ([#146](https://github.com/CategoricalData/hydra/issues/146)),
+  infinite-type checks restored ([#116](https://github.com/CategoricalData/hydra/issues/116)), recursive-element inference ([#90](https://github.com/CategoricalData/hydra/issues/90)),
+  unified handling of elements and let bindings ([#112](https://github.com/CategoricalData/hydra/issues/112)), minimized manual
+  type annotations ([#119](https://github.com/CategoricalData/hydra/issues/119)).
+- **`hydra.inference` module** introduced for inference type definitions;
+  substitution and unification moved up a level.
+
+### Breaking changes
+
+- Argument order of `Logic.ifElse` changed ([#147](https://github.com/CategoricalData/hydra/issues/147)).
+
+### New features
+
+- Inference test cases promoted into the common test suite ([#148](https://github.com/CategoricalData/hydra/issues/148));
+  added "kernel examples" inference tests; more recursion / mutual recursion cases.
+
+### Improvements
+
+- Removed type annotations across all kernel sources ([#119](https://github.com/CategoricalData/hydra/issues/119)).
+- Migrated to fully-applied primitive library DSLs ([#157](https://github.com/CategoricalData/hydra/issues/157)).
+- Aligned `Graph` and `Element` with `LetBinding` ([#159](https://github.com/CategoricalData/hydra/issues/159)).
+- `hydra.core.Unit` recognized by the Haskell coder.
+- Refactored inference tests.
+
+### Bug fixes
+
+- Fix for underdetermined type in `hydra.decode`.
+
+---
+
+## [0.10.0] - 2025-02-19
+
+Untagged in-repository version.
+Adds Hydra-Python (initial completion), a GraphSON coder,
+provisional Hydra-Go support, and dot-separated namespace conventions.
+
+### Highlights
+
+- **Hydra-Python initial completion** ([#80](https://github.com/CategoricalData/hydra/issues/80), [#66](https://github.com/CategoricalData/hydra/issues/66)): Python coder, generated kernel
+  modules in Python, and full library implementations across kernel namespaces.
+- **GraphSON coder** ([#79](https://github.com/CategoricalData/hydra/issues/79)).
+- **Provisional Hydra-Go** ([#65](https://github.com/CategoricalData/hydra/issues/65)).
+- **Namespace formatting** standardized to dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).
+
+### Breaking changes
+
+- All namespaces use dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).
+
+### New features
+
+- Hydra-Python: Python coder; generated `hydra.coreEncoding`, `hydra.strip`,
+  `hydra.literals` and other kernel modules in Python; tuple-expression support;
+  updated `hydra.constants` in Python.
+- GraphSON coder ([#79](https://github.com/CategoricalData/hydra/issues/79)).
+- Provisional Hydra-Go ([#65](https://github.com/CategoricalData/hydra/issues/65)).
+- `string-to-char-list` and `char-list-to-string` primitives ([#149](https://github.com/CategoricalData/hydra/issues/149)).
+- Restored normalization for generated term variables ([#145](https://github.com/CategoricalData/hydra/issues/145)).
+
+### Improvements
+
+- Re-leveled dependency tiers ([#135](https://github.com/CategoricalData/hydra/issues/135)).
+- Updated all Java, Haskell, hydra-ext, and Python primitives to current sources.
+
+---
+
+## [0.9.0] - 2025-01-06
+
+Untagged in-repository version.
+Bootstraps Hydra-Python and the JSON Schema coder; introduces a fluent Java DSL for flows.
+
+### Highlights
+
+- **JSON Schema coder** ([#141](https://github.com/CategoricalData/hydra/issues/141)).
+- **Python coder scaffold**: serde, language constraints, and generated Haskell
+  sources for Python.
+- **Fluent-style Java DSL for flows** ([#143](https://github.com/CategoricalData/hydra/issues/143)).
+
+### New features
+
+- JSON Schema coder ([#141](https://github.com/CategoricalData/hydra/issues/141)).
+- Python coder scaffold and serde.
+- Provisional Python language constraints module.
+- Fluent-style Java DSL for flows ([#143](https://github.com/CategoricalData/hydra/issues/143)); moved Flows DSL into `hydra.dsl`.
+- New `hydra.coders` DSL.
+- New DSL functions for core variants.
+
+### Improvements
+
+- Generalized `Namespaces` so it can be used for languages other than Haskell.
+- Local-name-only Python type aliases (the directory tree provides the namespace).
+- Coders DSL used to simplify Java language-constraint sources.
+- Removed redundant productions in the Python grammar.
+- Added unit tests for fluent flows.
+
+### Documentation
+
+- Updated JavaDocs for 0.9.0.
+
+---
+
+## [0.8.1] - 2024-09-24
+
+Patch release.
+
+### Improvements
+
+- Generalized the property graph merging utility to accept type systems other than Hydra Core.
+
+---
+
+## [0.8.0] - 2024-09-09
+
+C# support ([#139](https://github.com/CategoricalData/hydra/issues/139)), Graphviz DOT coder, term accessors, and a small breaking change in Java
+to support Spark.
+
+### Breaking changes
+
+- Made `FlowException` serializable for Spark support (may affect existing error handling).
+
+### New features
+
+- C# syntax module based on the Microsoft ANTLR grammar ([#139](https://github.com/CategoricalData/hydra/issues/139)).
+- Graphviz DOT coder ([#136](https://github.com/CategoricalData/hydra/issues/136)):
+  full support for lambdas and recursive `let` statements;
+  compact 'accessor graph' visualization option;
+  customizable label styles;
+  highlighted let-bound terms; edge labels.
+- Term accessor type to facilitate lenses and path-aware transformations.
+- OpenGQL grammar and generated Haskell for the OpenGQL model ([#140](https://github.com/CategoricalData/hydra/issues/140)).
+
+### Improvements
+
+- Added `</>` as alternative to `@@` application operator in Haskell DSLs.
+- Utilities for working with term accessors.
+- More specific exception class for JSON decoding.
+- Additional convenience methods on `JsonDecoding.java`.
+- Used transitive dependencies in hydra-java and hydra-ext.
+- Upgraded ANTLR to address a vulnerability.
+- Moved TinkerPop utilities from `hydra/ext/org/apache/tinkerpop` into `hydra/pg`.
+
+---
+
+## [0.7.0] - 2024-08-21
+
+Major refactoring of module organization and namespace management.
+Establishes the DNS-style namespace convention in hydra-ext
+and lifts property-graph models into a top-level `hydra/pg` namespace.
+
+### Breaking changes
+
+- Namespace reorganization: migrated to DNS-based module naming in hydra-ext ([#138](https://github.com/CategoricalData/hydra/issues/138)):
+  `hydra/ext/avro` → `hydra/ext/org/apache/avro`,
+  `hydra/ext/graphql` → `hydra/ext/org/graphql`,
+  `hydra/ext/yaml` → `hydra/ext/org/yaml`,
+  `hydra/ext/json/decoding` → `hydra/ext/org/json/decoding`,
+  `hydra/ext/rdf` → `hydra/ext/org/w3/rdf`,
+  `hydra/ext/shacl` → `hydra/ext/org/w3/shacl`,
+  `hydra/ext/tinkerpop` → `hydra/ext/org/apache/tinkerpop`.
+- Property graphs: promoted property graph modules from
+  `hydra/ext/org/apache/tinkerpop` to `hydra/pg`.
+- Project structure: renamed `hydra-extensions` to `hydra-ext`;
+  renamed `hydra/langs` to `hydra/ext` ([#138](https://github.com/CategoricalData/hydra/issues/138));
+  made hydra-ext into a Gradle subproject alongside hydra-java;
+  added top-level Gradle build.
+
+### Improvements
+
+- Moved TinkerPop modules from hydra-haskell into hydra-ext for better separation.
+- Moved miscellaneous models to `Hydra.Ext.Other` ([#138](https://github.com/CategoricalData/hydra/issues/138)).
+- Moved XML Schema, SQL, ShEx, and OWL models to hydra-ext.
+- Moved KQL, Parquet, and Python modules to hydra-ext.
+- Separated JavaDocs for hydra-java and hydra-ext.
+- Updated publishing configuration in `build.gradle`.
+
+---
+
+## [0.6.0] - 2024-08-19
+
+Type-system improvements (System F type abstraction/application; eliminated polymorphic
+types from Hydra Core), expanded language support (Graphviz DOT model, generated Java
+field-name constants), and revamped annotation handling.
+
+### Breaking changes
+
+- Eliminated `InferenceContext` helper type ([#103](https://github.com/CategoricalData/hydra/issues/103)).
+- Changed typing environment from `Map Name Type` to `Map Name TypeScheme` in graphs ([#76](https://github.com/CategoricalData/hydra/issues/76)).
+- Updated annotations and flows to use `map<Name, Term>` instead of `map<string, Term>` ([#133](https://github.com/CategoricalData/hydra/issues/133)).
+- Unified `Name` and `FieldName`; aliased to `string` ([#121](https://github.com/CategoricalData/hydra/issues/121)).
+- Renamed `hydra/core.UnitType` to `hydra/core.Unit` ([#123](https://github.com/CategoricalData/hydra/issues/123)).
+- Eliminated annotation classes; Hydra has a single built-in notion of annotations ([#113](https://github.com/CategoricalData/hydra/issues/113)).
+- Unified the `Nominal` type with `RowType` ([#115](https://github.com/CategoricalData/hydra/issues/115)).
+- Removed the `extends` parameter for row types ([#132](https://github.com/CategoricalData/hydra/issues/132)).
+- Replaced `hydra/Kv` with `hydra/Annotations` (rename revisited).
+
+### New features
+
+- System F support: `typeAbstraction` and `typeApplication` term constructors.
+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).
+- Graphviz DOT model and initial support ([#136](https://github.com/CategoricalData/hydra/issues/136)).
+- Field-name constants generated in Java code generation ([#137](https://github.com/CategoricalData/hydra/issues/137)).
+- Provisional Algorithm W implementation in Haskell (originally from @wisnesky), kept for reference.
+
+### Improvements
+
+- Primitive organization: Hydra primitives organized into libraries for namespace management.
+- Code generation:
+  - Escaped field name constants and `with_` methods in Java coder.
+  - Generated field name constants in Java ([#137](https://github.com/CategoricalData/hydra/issues/137)).
+  - Avoided duplicated comments in wrapper classes in generated Java.
+  - Removed superfluous newtype comments in Haskell coder.
+- Updated Delta Parquet model to follow the Java API more closely.
+- Enriched OpenCypher features module with the complete list of standard Cypher functions.
+- Added convenience methods to `JsonEncoding.java`.
+- Restored `Hydra.Inference` subdirectory.
+- Allowed arbitrary case for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+- Corrected `uint8` representation in Java to `Short` ([#120](https://github.com/CategoricalData/hydra/issues/120)).
+
+### Bug fixes
+
+- Fixed handling of type annotations in term adapters.
+- Fixed decoding of encoded terms annotated with a type.
+- Corrected encoding of universal types in `showTerm` ([#117](https://github.com/CategoricalData/hydra/issues/117)).
+
+---
+
+## [0.5.3] - 2024-08-06
+
+Patch release.
+Preserves order of map key/value pairs and set elements during JSON serialization.
+
+### Bug fixes
+
+- Preserved ordering of key/value pairs and set elements in JSON output.
+
+### New features
+
+- Polymorphic `equal` primitive in Haskell and Java.
+- Generated Hydra type definitions together with native instantiations of Hydra types
+  in Haskell (a stepping stone toward generated coders, [#47](https://github.com/CategoricalData/hydra/issues/47)).
+
+---
+
+## [0.5.1] - 2024-08-01
+
+Patch release.
+Dependency updates and minor improvements following the 0.5.0 Hydra Core overhaul.
+
+### Improvements
+
+- Updated dependencies.
+
+---
+
+## [0.5.0] - 2024-07-26
+
+Untagged in-repository version.
+Major Hydra Core overhaul: eliminates polymorphic types in favor of explicit
+TypeScheme; consolidates the annotation system; revamps `Let` term encoding.
+
+### Breaking changes
+
+- Eliminated polymorphic types from Hydra Core in Haskell ([#125](https://github.com/CategoricalData/hydra/issues/125)):
+  removed type parameters from `hydra/core` types in Hydra-Java; replaced type schemes
+  with forall types ([#76](https://github.com/CategoricalData/hydra/issues/76)).
+- Revamped core encoding and `Let`: bindings are now a list of
+  `(name, term, optional type scheme)` triplets instead of a map.
+- Unified typed-term types and moved `TypeScheme` into Hydra Core.
+- Eliminated `AnnotationClass`; Hydra has a single built-in notion of annotations now ([#113](https://github.com/CategoricalData/hydra/issues/113)).
+- Renamed and refactored phantom-type wrappers ([#128](https://github.com/CategoricalData/hydra/issues/128)); removed deprecated `Reference`
+  type from `hydra/phantoms`.
+- Removed incomplete support for stream types and stream terms ([#88](https://github.com/CategoricalData/hydra/issues/88)).
+
+### New features
+
+- `LiteralTypes` DSL module so literals can be built independently of terms.
+- `Hydra.Minimal` module to facilitate collaboration on Hydra application prototypes.
+- `TypeConstraint` type added to the kernel.
+- `foldl` primitive in Haskell and Java; DSL uses `foldl` instead of the built-in
+  list elimination term by default.
+
+### Improvements
+
+- Improvements to Java and JSON coders; improved untyped JSON coder.
+- Pre-order and post-order term-traversal test cases added.
+- Refactored type inference tests.
+- Restored generated Java (Core through Tier 3) with only a few manual tweaks.
+- Element names allow arbitrary case ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+
+---
+
+## [0.4.0] - 2024-07-10
+
+Untagged in-repository version.
+Adds null checks to generated Java (breaking, but justified — Hydra-Java disallows nulls),
+the Gremlin model, and Protobuf annotation refinements.
+
+### Breaking changes
+
+- Null checks added to constructors and `withXXX()` methods in generated Java;
+  null values are no longer permitted in Hydra-Java.
+- Removed Java 8 restriction (raised minimum Java version).
+
+### New features
+
+- Gremlin model ([#127](https://github.com/CategoricalData/hydra/issues/127)); generated Haskell for Gremlin.
+- `hydra/lib/lists.safeHead` primitive in Haskell (necessary in Java due to eager evaluation).
+- Support for Protobuf `deprecated=true` annotation; non-string Protobuf options.
+- Java options in generated Protobuf.
+
+### Improvements
+
+- Used `java.util.Objects.requireNonNull` instead of a custom null check in generated Java.
+- Added 'automatically generated file' disclaimer to generated Java files.
+- Added autogen comments and null checks to (most) generated Java.
+- Added necessary schema-level dependencies for built-in modules.
+- Added null checks to the Flows DSL in Java.
+
+---
+
+## [0.3.0] - 2024-06-05
+
+Untagged in-repository version.
+Adds an OpenCypher parser based on an ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124)),
+a KQL (Kusto Query Language) model and serializer,
+a Delta Parquet model,
+and an early property graph queries model in the style of Cypher.
+
+### New features
+
+- OpenCypher parser based on the OpenCypher M23 ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124));
+  ANTLR added as a build dependency;
+  large Cypher test suite drawn from the Cypher Manual.
+- Cypher-to-PG-query transformer (Java; partially implemented).
+- Property graph queries DSL and generated property graph query classes in Java.
+- Property graph queries model (Cypher / future GQL style).
+- KQL (Kusto Query Language) initial model and basic serializer.
+- Delta Parquet model with generated sources.
+
+### Improvements
+
+- Java options and `deprecated=true` support in generated Protobuf.
+- Convenience methods in Java.
+
+---
+
+## [0.2.0] - 2024-01-10
+
+Hydra-Java 0.2.0 release.
+Significant Java tooling and DSL build-out, Protobuf bidirectional coder,
+Python3 syntax model ([#80](https://github.com/CategoricalData/hydra/issues/80)), property graph validation ([#100](https://github.com/CategoricalData/hydra/issues/100)),
+JSON bidirectional support in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)),
+OpenCypher initial model ([#108](https://github.com/CategoricalData/hydra/issues/108)),
+Cypher unification, and the start of the typed-DSL story in Haskell.
+
+### New features
+
+- Property graph validation: validator type, optionality on property types,
+  customizable id/property handling in the merging adapter, fine-tuned validation,
+  comprehensive unit tests in Java ([#100](https://github.com/CategoricalData/hydra/issues/100)).
+- Bidirectional JSON serialization/deserialization in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)).
+- Checkstyle configuration based on Google style guide ([#111](https://github.com/CategoricalData/hydra/issues/111)).
+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).
+- Initial OpenCypher model and parser scaffold ([#108](https://github.com/CategoricalData/hydra/issues/108)).
+- Protobuf coder ([#99](https://github.com/CategoricalData/hydra/issues/99)): type encoder, field numbering, formatting, deprecated annotation,
+  Java options, non-string options.
+- Adapter framework tolerance of recursive types ([#58](https://github.com/CategoricalData/hydra/issues/58)); default branch for case
+  statements ([#60](https://github.com/CategoricalData/hydra/issues/60)).
+- Topological sort in type inference ([#67](https://github.com/CategoricalData/hydra/issues/67)).
+- `hydra/query` model ([#73](https://github.com/CategoricalData/hydra/issues/73)).
+- Records-to-TinkerPop-elements coder ([#64](https://github.com/CategoricalData/hydra/issues/64)).
+- Equality primitives for all literal types ([#92](https://github.com/CategoricalData/hydra/issues/92)); polymorphic logic primitives ([#95](https://github.com/CategoricalData/hydra/issues/95)).
+- `mapKeys` primitive ([#93](https://github.com/CategoricalData/hydra/issues/93)).
+- Tuple support in Java ([#94](https://github.com/CategoricalData/hydra/issues/94)).
+- Java 8 as an optional target ([#96](https://github.com/CategoricalData/hydra/issues/96)); optionally generate Java classes as `Serializable` ([#97](https://github.com/CategoricalData/hydra/issues/97)).
+- Bidirectional "merged vertex" and "merged edge" coders ([#106](https://github.com/CategoricalData/hydra/issues/106)).
+- Nullability and parameterization in the tabular model ([#107](https://github.com/CategoricalData/hydra/issues/107)).
+- Term-level / type-level dependency distinction for modules ([#109](https://github.com/CategoricalData/hydra/issues/109)).
+- Flatten nested `let` terms for transformation into Java ([#110](https://github.com/CategoricalData/hydra/issues/110)).
+- Various `Flow` utilities in Java: `bind3`; convenience methods for consuming results;
+  `fromFlow` variants including one that throws.
+
+### Improvements
+
+- Hydra-Java module ports ([#10](https://github.com/CategoricalData/hydra/issues/10), [#12](https://github.com/CategoricalData/hydra/issues/12), [#13](https://github.com/CategoricalData/hydra/issues/13), [#14](https://github.com/CategoricalData/hydra/issues/14), [#17](https://github.com/CategoricalData/hydra/issues/17), [#30](https://github.com/CategoricalData/hydra/issues/30), [#31](https://github.com/CategoricalData/hydra/issues/31), [#32](https://github.com/CategoricalData/hydra/issues/32), [#33](https://github.com/CategoricalData/hydra/issues/33), [#34](https://github.com/CategoricalData/hydra/issues/34), [#35](https://github.com/CategoricalData/hydra/issues/35),
+  [#38](https://github.com/CategoricalData/hydra/issues/38), [#39](https://github.com/CategoricalData/hydra/issues/39), [#41](https://github.com/CategoricalData/hydra/issues/41), [#43](https://github.com/CategoricalData/hydra/issues/43), [#48](https://github.com/CategoricalData/hydra/issues/48), [#71](https://github.com/CategoricalData/hydra/issues/71), [#72](https://github.com/CategoricalData/hydra/issues/72), [#75](https://github.com/CategoricalData/hydra/issues/75), [#83](https://github.com/CategoricalData/hydra/issues/83)):
+  `Common`, `CoreEncoding`, `CoreLanguage`, `Kernel`, `Flows`, `Lists`, `Literals`,
+  `Math`, `Sets`, `Strings`, `Optionals`, `Maps`, `Flows` primitives, `Sets` primitives.
+- Common DSLs in Haskell: Flow support ([#68](https://github.com/CategoricalData/hydra/issues/68)), Let support ([#69](https://github.com/CategoricalData/hydra/issues/69)).
+- Renamed annotation type parameter `m` to `a` ([#41](https://github.com/CategoricalData/hydra/issues/41)).
+- Updated wrapper, element, and variable types ([#75](https://github.com/CategoricalData/hydra/issues/75)).
+- Removed `schema` field from `Element` ([#83](https://github.com/CategoricalData/hydra/issues/83)).
+- GraphQL coder ([#78](https://github.com/CategoricalData/hydra/issues/78)).
+- Code quality:
+  - Updated main and test sources to conform to Checkstyle configuration ([#111](https://github.com/CategoricalData/hydra/issues/111)).
+  - Extended line-length limit from 100 to 120 characters.
+  - Disabled overly restrictive indentation and import-order rules.
+  - Disabled `RightCurlyAlone` for compact inline map definitions.
+- Streamlined property-graph element merging to unify properties with identical
+  keys and types ([#106](https://github.com/CategoricalData/hydra/issues/106)).
+- Convenience functions for printing literals and literal types in the Java DSL.
+- Minor addition to JSON decoding.
+- DSL convenience: alphabetic-case flexibility for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+
+### Bug fixes
+
+- Fixed type annotations for the Sets Java port ([#48](https://github.com/CategoricalData/hydra/issues/48)).
+- Various minor fixes during the Java module ports.
+
+---
+
+## [0.1.1] - 2022-12-04
+
+Patch release the same day as 0.1.0.
+README polish only.
+
+---
+
+## [0.1.0] - 2022-12-04
+
+First packaged release of Hydra (Hackage).
+This release contains the complete foundation of Hydra.
+
+### Core language
+
+- Hydra's core type and data languages (`hydra.core`).
+- Core models for graphs and modules.
+- Computation model with the `Flow` monad.
+- BNF grammars support.
+- Phantom types.
+- Basic operations on types and terms.
+
+### Type system
+
+- Hindley–Milner-style type inference.
+- Type schemes with polymorphism.
+- Type/term validation.
+
+### Transformations
+
+- Adapter system: type-to-type rewriting and transformation.
+- Coders:
+  Haskell coder (types and terms),
+  Java coder (types and terms),
+  partial Scala coder (terms only),
+  Avro coder,
+  JSON coder,
+  PDL (Pegasus Data Language) coder,
+  RDF + SHACL coder,
+  YAML coder.
+
+### Language support
+
+- Models for GraphQL, OWL (Web Ontology Language), ShEx (Shape Expressions),
+  and TinkerPop-style property graphs.
+
+### Developer tools
+
+- Type-construction DSL and term-construction DSL.
+- QuickCheck property-based tests.
+
+### Implementations
+
+- Hydra-Haskell: bootstrapping implementation with full kernel.
+- Hydra-Java: Java implementation with mature tooling.
+
+### Community
+
+- Set up the LambdaGraph Discord server ([#2](https://github.com/CategoricalData/hydra/issues/2)).
+
+---
+
+## Contributing
+
+We welcome contributions! Please see:
+
+- [Developer recipes](https://github.com/CategoricalData/hydra/tree/main/docs/recipes)
+- [LambdaGraph Discord](https://bit.ly/lg-discord)
+
+## Release process
+
+See the [Release policy](https://github.com/CategoricalData/hydra/wiki/Release-policy)
+wiki page and [docs/release-workflow.md](docs/release-workflow.md)
+for information on how Hydra releases are versioned, built, and published.
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/NOTICE b/NOTICE
new file mode 100644
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,3 @@
+Hydra
+Copyright 2021-2026 The Hydra authors
+https://github.com/CategoricalData/hydra
diff --git a/hydra-rdf.cabal b/hydra-rdf.cabal
new file mode 100644
--- /dev/null
+++ b/hydra-rdf.cabal
@@ -0,0 +1,50 @@
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.39.1.
+--
+-- see: https://github.com/sol/hpack
+
+name:           hydra-rdf
+version:        0.17.0
+synopsis:       Hydra's RDF/SHACL/OWL model and coder support
+description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". RDF support for Hydra
+category:       Data
+homepage:       https://github.com/CategoricalData/hydra#readme
+bug-reports:    https://github.com/CategoricalData/hydra/issues
+author:         Joshua Shinavier <josh@fortytwo.net>
+maintainer:     Joshua Shinavier <josh@fortytwo.net>
+license:        Apache-2.0
+license-file:   LICENSE
+build-type:     Simple
+extra-source-files:
+    LICENSE
+    NOTICE
+    CHANGELOG.md
+
+source-repository head
+  type: git
+  location: https://github.com/CategoricalData/hydra
+
+library
+  exposed-modules:
+      Hydra.Dsl.Rdf.Syntax
+      Hydra.Dsl.Shacl.Model
+      Hydra.Owl.Syntax
+      Hydra.Rdf.Serde
+      Hydra.Rdf.Syntax
+      Hydra.Rdf.Utils
+      Hydra.Shacl.Coder
+      Hydra.Shacl.Language
+      Hydra.Shacl.Model
+      Hydra.Shex.Syntax
+      Hydra.Xml.Schema
+  other-modules:
+      Paths_hydra_rdf
+  hs-source-dirs:
+      src/main/haskell
+  build-depends:
+      base >=4.19.0 && <4.22
+    , containers >=0.6.7 && <0.8
+    , hydra-kernel ==0.17.0
+    , scientific >=0.3.7 && <0.4
+  default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs b/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs
@@ -0,0 +1,706 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | DSL functions for hydra.rdf.syntax
+
+module Hydra.Dsl.Rdf.Syntax where
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Rdf.Syntax as Syntax
+import qualified Hydra.Typed as Typed
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Map as M
+import qualified Data.Set as S
+-- | DSL constructor for the hydra.rdf.syntax.BlankNode wrapper
+blankNode :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.BlankNode
+blankNode x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.BlankNode"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL constructor for the hydra.rdf.syntax.Dataset wrapper
+dataset :: Typed.TypedTerm (S.Set Syntax.Quad) -> Typed.TypedTerm Syntax.Dataset
+dataset x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.Dataset"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL constructor for hydra.rdf.syntax.Description
+description :: Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm Syntax.Description
+description subject graph =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Typed.unTypedTerm subject)},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Typed.unTypedTerm graph)}]}))
+-- | DSL accessor for the graph field of hydra.rdf.syntax.Description
+descriptionGraph :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Graph
+descriptionGraph x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+        Core.projectionFieldName = (Core.Name "graph")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the subject field of hydra.rdf.syntax.Description
+descriptionSubject :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Node
+descriptionSubject x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+        Core.projectionFieldName = (Core.Name "subject")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the graph field of hydra.rdf.syntax.Description
+descriptionWithGraph :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm Syntax.Description
+descriptionWithGraph original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+              Core.projectionFieldName = (Core.Name "subject")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL updater for the subject field of hydra.rdf.syntax.Description
+descriptionWithSubject :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Description
+descriptionWithSubject original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),
+              Core.projectionFieldName = (Core.Name "graph")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL constructor for the hydra.rdf.syntax.Graph wrapper
+graph :: Typed.TypedTerm (S.Set Syntax.Triple) -> Typed.TypedTerm Syntax.Graph
+graph x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.Graph"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL constructor for the hydra.rdf.syntax.Iri wrapper
+iri :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Iri
+iri x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.Iri"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL injection for the iri variant of hydra.rdf.syntax.IriOrLiteral
+iriOrLiteralIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.IriOrLiteral
+iriOrLiteralIri x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.IriOrLiteral"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "iri"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the literal variant of hydra.rdf.syntax.IriOrLiteral
+iriOrLiteralLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.IriOrLiteral
+iriOrLiteralLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.IriOrLiteral"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL constructor for the hydra.rdf.syntax.LangStrings wrapper
+langStrings :: Typed.TypedTerm (M.Map (Maybe Syntax.LanguageTag) String) -> Typed.TypedTerm Syntax.LangStrings
+langStrings x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.LangStrings"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL constructor for the hydra.rdf.syntax.LanguageTag wrapper
+languageTag :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.LanguageTag
+languageTag x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.LanguageTag"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL constructor for hydra.rdf.syntax.Literal
+literal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (Maybe Syntax.LanguageTag) -> Typed.TypedTerm Syntax.Literal
+literal lexicalForm datatypeIri languageTag =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lexicalForm"),
+          Core.fieldTerm = (Typed.unTypedTerm lexicalForm)},
+        Core.Field {
+          Core.fieldName = (Core.Name "datatypeIri"),
+          Core.fieldTerm = (Typed.unTypedTerm datatypeIri)},
+        Core.Field {
+          Core.fieldName = (Core.Name "languageTag"),
+          Core.fieldTerm = (Typed.unTypedTerm languageTag)}]}))
+-- | DSL accessor for the datatypeIri field of hydra.rdf.syntax.Literal
+literalDatatypeIri :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Iri
+literalDatatypeIri x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+        Core.projectionFieldName = (Core.Name "datatypeIri")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the languageTag field of hydra.rdf.syntax.Literal
+literalLanguageTag :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm (Maybe Syntax.LanguageTag)
+literalLanguageTag x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+        Core.projectionFieldName = (Core.Name "languageTag")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the lexicalForm field of hydra.rdf.syntax.Literal
+literalLexicalForm :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm String
+literalLexicalForm x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+        Core.projectionFieldName = (Core.Name "lexicalForm")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the datatypeIri field of hydra.rdf.syntax.Literal
+literalWithDatatypeIri :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Literal
+literalWithDatatypeIri original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lexicalForm"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+              Core.projectionFieldName = (Core.Name "lexicalForm")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "datatypeIri"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "languageTag"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+              Core.projectionFieldName = (Core.Name "languageTag")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the languageTag field of hydra.rdf.syntax.Literal
+literalWithLanguageTag :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm (Maybe Syntax.LanguageTag) -> Typed.TypedTerm Syntax.Literal
+literalWithLanguageTag original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lexicalForm"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+              Core.projectionFieldName = (Core.Name "lexicalForm")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "datatypeIri"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+              Core.projectionFieldName = (Core.Name "datatypeIri")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "languageTag"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL updater for the lexicalForm field of hydra.rdf.syntax.Literal
+literalWithLexicalForm :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal
+literalWithLexicalForm original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lexicalForm"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "datatypeIri"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+              Core.projectionFieldName = (Core.Name "datatypeIri")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "languageTag"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),
+              Core.projectionFieldName = (Core.Name "languageTag")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL injection for the bnode variant of hydra.rdf.syntax.Node
+nodeBnode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm Syntax.Node
+nodeBnode x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Node"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bnode"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the iri variant of hydra.rdf.syntax.Node
+nodeIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Node
+nodeIri x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Node"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "iri"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the literal variant of hydra.rdf.syntax.Node
+nodeLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Node
+nodeLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Node"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL constructor for hydra.rdf.syntax.Property
+property :: Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Syntax.Property
+property domain range subPropertyOf =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "domain"),
+          Core.fieldTerm = (Typed.unTypedTerm domain)},
+        Core.Field {
+          Core.fieldName = (Core.Name "range"),
+          Core.fieldTerm = (Typed.unTypedTerm range)},
+        Core.Field {
+          Core.fieldName = (Core.Name "subPropertyOf"),
+          Core.fieldTerm = (Typed.unTypedTerm subPropertyOf)}]}))
+-- | DSL accessor for the domain field of hydra.rdf.syntax.Property
+propertyDomain :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass)
+propertyDomain x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+        Core.projectionFieldName = (Core.Name "domain")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the range field of hydra.rdf.syntax.Property
+propertyRange :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass)
+propertyRange x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+        Core.projectionFieldName = (Core.Name "range")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the subPropertyOf field of hydra.rdf.syntax.Property
+propertySubPropertyOf :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.Property)
+propertySubPropertyOf x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+        Core.projectionFieldName = (Core.Name "subPropertyOf")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the domain field of hydra.rdf.syntax.Property
+propertyWithDomain :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Syntax.Property
+propertyWithDomain original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "domain"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "range"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+              Core.projectionFieldName = (Core.Name "range")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "subPropertyOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+              Core.projectionFieldName = (Core.Name "subPropertyOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the range field of hydra.rdf.syntax.Property
+propertyWithRange :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Syntax.Property
+propertyWithRange original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "domain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+              Core.projectionFieldName = (Core.Name "domain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "range"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "subPropertyOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+              Core.projectionFieldName = (Core.Name "subPropertyOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the subPropertyOf field of hydra.rdf.syntax.Property
+propertyWithSubPropertyOf :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Syntax.Property
+propertyWithSubPropertyOf original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "domain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+              Core.projectionFieldName = (Core.Name "domain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "range"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),
+              Core.projectionFieldName = (Core.Name "range")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "subPropertyOf"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL constructor for hydra.rdf.syntax.Quad
+quad :: Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm (Maybe Syntax.Iri) -> Typed.TypedTerm Syntax.Quad
+quad subject predicate object graph =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Typed.unTypedTerm subject)},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Typed.unTypedTerm predicate)},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Typed.unTypedTerm object)},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Typed.unTypedTerm graph)}]}))
+-- | DSL accessor for the graph field of hydra.rdf.syntax.Quad
+quadGraph :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm (Maybe Syntax.Iri)
+quadGraph x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+        Core.projectionFieldName = (Core.Name "graph")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the object field of hydra.rdf.syntax.Quad
+quadObject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Node
+quadObject x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+        Core.projectionFieldName = (Core.Name "object")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the predicate field of hydra.rdf.syntax.Quad
+quadPredicate :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Iri
+quadPredicate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+        Core.projectionFieldName = (Core.Name "predicate")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the subject field of hydra.rdf.syntax.Quad
+quadSubject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Resource
+quadSubject x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+        Core.projectionFieldName = (Core.Name "subject")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the graph field of hydra.rdf.syntax.Quad
+quadWithGraph :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm (Maybe Syntax.Iri) -> Typed.TypedTerm Syntax.Quad
+quadWithGraph original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "subject")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "predicate")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "object")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL updater for the object field of hydra.rdf.syntax.Quad
+quadWithObject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Quad
+quadWithObject original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "subject")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "predicate")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "graph")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the predicate field of hydra.rdf.syntax.Quad
+quadWithPredicate :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Quad
+quadWithPredicate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "subject")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "object")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "graph")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the subject field of hydra.rdf.syntax.Quad
+quadWithSubject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Quad
+quadWithSubject original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "predicate")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "object")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),
+              Core.projectionFieldName = (Core.Name "graph")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL constructor for the hydra.rdf.syntax.RdfsClass wrapper
+rdfsClass :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.RdfsClass
+rdfsClass x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.RdfsClass"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL injection for the bnode variant of hydra.rdf.syntax.Resource
+resourceBnode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm Syntax.Resource
+resourceBnode x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Resource"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bnode"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the iri variant of hydra.rdf.syntax.Resource
+resourceIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Resource
+resourceIri x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Resource"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "iri"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL constructor for hydra.rdf.syntax.Triple
+triple :: Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Triple
+triple subject predicate object =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Typed.unTypedTerm subject)},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Typed.unTypedTerm predicate)},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Typed.unTypedTerm object)}]}))
+-- | DSL accessor for the object field of hydra.rdf.syntax.Triple
+tripleObject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Node
+tripleObject x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+        Core.projectionFieldName = (Core.Name "object")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the predicate field of hydra.rdf.syntax.Triple
+triplePredicate :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Iri
+triplePredicate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+        Core.projectionFieldName = (Core.Name "predicate")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the subject field of hydra.rdf.syntax.Triple
+tripleSubject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Resource
+tripleSubject x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+        Core.projectionFieldName = (Core.Name "subject")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the object field of hydra.rdf.syntax.Triple
+tripleWithObject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Triple
+tripleWithObject original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+              Core.projectionFieldName = (Core.Name "subject")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+              Core.projectionFieldName = (Core.Name "predicate")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL updater for the predicate field of hydra.rdf.syntax.Triple
+tripleWithPredicate :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Triple
+tripleWithPredicate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+              Core.projectionFieldName = (Core.Name "subject")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+              Core.projectionFieldName = (Core.Name "object")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the subject field of hydra.rdf.syntax.Triple
+tripleWithSubject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Triple
+tripleWithSubject original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "subject"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "predicate"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+              Core.projectionFieldName = (Core.Name "predicate")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "object"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),
+              Core.projectionFieldName = (Core.Name "object")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL accessor for the body of hydra.rdf.syntax.BlankNode
+unBlankNode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm String
+unBlankNode x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.BlankNode")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.rdf.syntax.Dataset
+unDataset :: Typed.TypedTerm Syntax.Dataset -> Typed.TypedTerm (S.Set Syntax.Quad)
+unDataset x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.Dataset")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.rdf.syntax.Graph
+unGraph :: Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm (S.Set Syntax.Triple)
+unGraph x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.Graph")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.rdf.syntax.Iri
+unIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm String
+unIri x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.Iri")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.rdf.syntax.LangStrings
+unLangStrings :: Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm (M.Map (Maybe Syntax.LanguageTag) String)
+unLangStrings x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.LangStrings")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.rdf.syntax.LanguageTag
+unLanguageTag :: Typed.TypedTerm Syntax.LanguageTag -> Typed.TypedTerm String
+unLanguageTag x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.LanguageTag")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.rdf.syntax.RdfsClass
+unRdfsClass :: Typed.TypedTerm Syntax.RdfsClass -> Typed.TypedTerm ()
+unRdfsClass x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.RdfsClass")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
diff --git a/src/main/haskell/Hydra/Dsl/Shacl/Model.hs b/src/main/haskell/Hydra/Dsl/Shacl/Model.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Shacl/Model.hs
@@ -0,0 +1,1735 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | DSL functions for hydra.shacl.model
+
+module Hydra.Dsl.Shacl.Model where
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Dsl.Rdf.Syntax as RdfSyntax
+import qualified Hydra.Rdf.Syntax as Syntax
+import qualified Hydra.Shacl.Model as Model
+import qualified Hydra.Typed as Typed
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Set as S
+-- | DSL constructor for hydra.shacl.model.Closed
+closed :: Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe (S.Set Syntax.Property)) -> Typed.TypedTerm Model.Closed
+closed isClosed ignoredProperties =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Closed"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "isClosed"),
+          Core.fieldTerm = (Typed.unTypedTerm isClosed)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ignoredProperties"),
+          Core.fieldTerm = (Typed.unTypedTerm ignoredProperties)}]}))
+-- | DSL accessor for the ignoredProperties field of hydra.shacl.model.Closed
+closedIgnoredProperties :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm (Maybe (S.Set Syntax.Property))
+closedIgnoredProperties x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),
+        Core.projectionFieldName = (Core.Name "ignoredProperties")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the isClosed field of hydra.shacl.model.Closed
+closedIsClosed :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm Bool
+closedIsClosed x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),
+        Core.projectionFieldName = (Core.Name "isClosed")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the ignoredProperties field of hydra.shacl.model.Closed
+closedWithIgnoredProperties :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm (Maybe (S.Set Syntax.Property)) -> Typed.TypedTerm Model.Closed
+closedWithIgnoredProperties original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Closed"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "isClosed"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),
+              Core.projectionFieldName = (Core.Name "isClosed")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ignoredProperties"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL updater for the isClosed field of hydra.shacl.model.Closed
+closedWithIsClosed :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm Bool -> Typed.TypedTerm Model.Closed
+closedWithIsClosed original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Closed"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "isClosed"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ignoredProperties"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),
+              Core.projectionFieldName = (Core.Name "ignoredProperties")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL injection for the and variant of hydra.shacl.model.CommonConstraint
+commonConstraintAnd :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintAnd x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "and"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the class variant of hydra.shacl.model.CommonConstraint
+commonConstraintClass :: Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the closed variant of hydra.shacl.model.CommonConstraint
+commonConstraintClosed :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintClosed x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "closed"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the datatype variant of hydra.shacl.model.CommonConstraint
+commonConstraintDatatype :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintDatatype x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "datatype"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the disjoint variant of hydra.shacl.model.CommonConstraint
+commonConstraintDisjoint :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintDisjoint x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "disjoint"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the equals variant of hydra.shacl.model.CommonConstraint
+commonConstraintEquals :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintEquals x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "equals"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the hasValue variant of hydra.shacl.model.CommonConstraint
+commonConstraintHasValue :: Typed.TypedTerm (S.Set Syntax.Node) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintHasValue x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "hasValue"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the in variant of hydra.shacl.model.CommonConstraint
+commonConstraintIn :: Typed.TypedTerm [Syntax.Node] -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintIn x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "in"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the languageIn variant of hydra.shacl.model.CommonConstraint
+commonConstraintLanguageIn :: Typed.TypedTerm (S.Set Syntax.LanguageTag) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintLanguageIn x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "languageIn"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the maxExclusive variant of hydra.shacl.model.CommonConstraint
+commonConstraintMaxExclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintMaxExclusive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "maxExclusive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the maxInclusive variant of hydra.shacl.model.CommonConstraint
+commonConstraintMaxInclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintMaxInclusive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "maxInclusive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the maxLength variant of hydra.shacl.model.CommonConstraint
+commonConstraintMaxLength :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintMaxLength x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "maxLength"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the minExclusive variant of hydra.shacl.model.CommonConstraint
+commonConstraintMinExclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintMinExclusive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minExclusive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the minInclusive variant of hydra.shacl.model.CommonConstraint
+commonConstraintMinInclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintMinInclusive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minInclusive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the minLength variant of hydra.shacl.model.CommonConstraint
+commonConstraintMinLength :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintMinLength x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minLength"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the node variant of hydra.shacl.model.CommonConstraint
+commonConstraintNode :: Typed.TypedTerm (S.Set (Model.Reference Model.NodeShape)) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintNode x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "node"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the nodeKind variant of hydra.shacl.model.CommonConstraint
+commonConstraintNodeKind :: Typed.TypedTerm Model.NodeKind -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintNodeKind x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "nodeKind"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the not variant of hydra.shacl.model.CommonConstraint
+commonConstraintNot :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintNot x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "not"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the or variant of hydra.shacl.model.CommonConstraint
+commonConstraintOr :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintOr x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "or"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the pattern variant of hydra.shacl.model.CommonConstraint
+commonConstraintPattern :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintPattern x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pattern"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the property variant of hydra.shacl.model.CommonConstraint
+commonConstraintProperty :: Typed.TypedTerm (S.Set (Model.Reference Model.PropertyShape)) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintProperty x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "property"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the xone variant of hydra.shacl.model.CommonConstraint
+commonConstraintXone :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint
+commonConstraintXone x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "xone"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL constructor for hydra.shacl.model.CommonProperties
+commonProperties :: Typed.TypedTerm (S.Set Model.CommonConstraint) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.Severity -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonProperties
+commonProperties constraints deactivated message severity targetClass targetNode targetObjectsOf targetSubjectsOf =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Typed.unTypedTerm constraints)},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Typed.unTypedTerm deactivated)},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Typed.unTypedTerm message)},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Typed.unTypedTerm severity)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Typed.unTypedTerm targetClass)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Typed.unTypedTerm targetNode)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Typed.unTypedTerm targetObjectsOf)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Typed.unTypedTerm targetSubjectsOf)}]}))
+-- | DSL accessor for the constraints field of hydra.shacl.model.CommonProperties
+commonPropertiesConstraints :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.CommonConstraint)
+commonPropertiesConstraints x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "constraints")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the deactivated field of hydra.shacl.model.CommonProperties
+commonPropertiesDeactivated :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (Maybe Bool)
+commonPropertiesDeactivated x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "deactivated")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the message field of hydra.shacl.model.CommonProperties
+commonPropertiesMessage :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Syntax.LangStrings
+commonPropertiesMessage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "message")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the severity field of hydra.shacl.model.CommonProperties
+commonPropertiesSeverity :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.Severity
+commonPropertiesSeverity x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "severity")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the targetClass field of hydra.shacl.model.CommonProperties
+commonPropertiesTargetClass :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.RdfsClass)
+commonPropertiesTargetClass x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "targetClass")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the targetNode field of hydra.shacl.model.CommonProperties
+commonPropertiesTargetNode :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral)
+commonPropertiesTargetNode x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "targetNode")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the targetObjectsOf field of hydra.shacl.model.CommonProperties
+commonPropertiesTargetObjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property)
+commonPropertiesTargetObjectsOf x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the targetSubjectsOf field of hydra.shacl.model.CommonProperties
+commonPropertiesTargetSubjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property)
+commonPropertiesTargetSubjectsOf x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+        Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the constraints field of hydra.shacl.model.CommonProperties
+commonPropertiesWithConstraints :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.CommonConstraint) -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithConstraints original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the deactivated field of hydra.shacl.model.CommonProperties
+commonPropertiesWithDeactivated :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithDeactivated original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the message field of hydra.shacl.model.CommonProperties
+commonPropertiesWithMessage :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithMessage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the severity field of hydra.shacl.model.CommonProperties
+commonPropertiesWithSeverity :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.Severity -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithSeverity original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the targetClass field of hydra.shacl.model.CommonProperties
+commonPropertiesWithTargetClass :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithTargetClass original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the targetNode field of hydra.shacl.model.CommonProperties
+commonPropertiesWithTargetNode :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral) -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithTargetNode original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the targetObjectsOf field of hydra.shacl.model.CommonProperties
+commonPropertiesWithTargetObjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithTargetObjectsOf original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the targetSubjectsOf field of hydra.shacl.model.CommonProperties
+commonPropertiesWithTargetSubjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonProperties
+commonPropertiesWithTargetSubjectsOf original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "deactivated"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "deactivated")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "message"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "message")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "severity"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "severity")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetClass"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetClass")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetNode"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetNode")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetObjectsOf"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),
+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targetSubjectsOf"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL constructor for hydra.shacl.model.Definition
+definition :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm a -> Typed.TypedTerm (Model.Definition a)
+definition iri target =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Definition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "iri"),
+          Core.fieldTerm = (Typed.unTypedTerm iri)},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))
+-- | DSL accessor for the iri field of hydra.shacl.model.Definition
+definitionIri :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm Syntax.Iri
+definitionIri x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),
+        Core.projectionFieldName = (Core.Name "iri")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the target field of hydra.shacl.model.Definition
+definitionTarget :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm a
+definitionTarget x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),
+        Core.projectionFieldName = (Core.Name "target")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the iri field of hydra.shacl.model.Definition
+definitionWithIri :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (Model.Definition a)
+definitionWithIri original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Definition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "iri"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),
+              Core.projectionFieldName = (Core.Name "target")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the target field of hydra.shacl.model.Definition
+definitionWithTarget :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm a -> Typed.TypedTerm (Model.Definition a)
+definitionWithTarget original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Definition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "iri"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),
+              Core.projectionFieldName = (Core.Name "iri")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL injection for the blankNode variant of hydra.shacl.model.NodeKind
+nodeKindBlankNode :: Typed.TypedTerm Model.NodeKind
+nodeKindBlankNode =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "blankNode"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the blankNodeOrIri variant of hydra.shacl.model.NodeKind
+nodeKindBlankNodeOrIri :: Typed.TypedTerm Model.NodeKind
+nodeKindBlankNodeOrIri =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "blankNodeOrIri"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the blankNodeOrLiteral variant of hydra.shacl.model.NodeKind
+nodeKindBlankNodeOrLiteral :: Typed.TypedTerm Model.NodeKind
+nodeKindBlankNodeOrLiteral =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "blankNodeOrLiteral"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the iri variant of hydra.shacl.model.NodeKind
+nodeKindIri :: Typed.TypedTerm Model.NodeKind
+nodeKindIri =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "iri"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the iriOrLiteral variant of hydra.shacl.model.NodeKind
+nodeKindIriOrLiteral :: Typed.TypedTerm Model.NodeKind
+nodeKindIriOrLiteral =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "iriOrLiteral"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the literal variant of hydra.shacl.model.NodeKind
+nodeKindLiteral :: Typed.TypedTerm Model.NodeKind
+nodeKindLiteral =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL constructor for hydra.shacl.model.NodeShape
+nodeShape :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.NodeShape
+nodeShape common =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.NodeShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Typed.unTypedTerm common)}]}))
+-- | DSL accessor for the common field of hydra.shacl.model.NodeShape
+nodeShapeCommon :: Typed.TypedTerm Model.NodeShape -> Typed.TypedTerm Model.CommonProperties
+nodeShapeCommon x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.NodeShape"),
+        Core.projectionFieldName = (Core.Name "common")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the common field of hydra.shacl.model.NodeShape
+nodeShapeWithCommon :: Typed.TypedTerm Model.NodeShape -> Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.NodeShape
+nodeShapeWithCommon original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.NodeShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL constructor for hydra.shacl.model.Pattern
+pattern :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Model.Pattern
+pattern regex flags =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "regex"),
+          Core.fieldTerm = (Typed.unTypedTerm regex)},
+        Core.Field {
+          Core.fieldName = (Core.Name "flags"),
+          Core.fieldTerm = (Typed.unTypedTerm flags)}]}))
+-- | DSL accessor for the flags field of hydra.shacl.model.Pattern
+patternFlags :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm (Maybe String)
+patternFlags x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+        Core.projectionFieldName = (Core.Name "flags")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the regex field of hydra.shacl.model.Pattern
+patternRegex :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm String
+patternRegex x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+        Core.projectionFieldName = (Core.Name "regex")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the flags field of hydra.shacl.model.Pattern
+patternWithFlags :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Model.Pattern
+patternWithFlags original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "regex"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+              Core.projectionFieldName = (Core.Name "regex")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "flags"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL updater for the regex field of hydra.shacl.model.Pattern
+patternWithRegex :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm String -> Typed.TypedTerm Model.Pattern
+patternWithRegex original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "regex"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "flags"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),
+              Core.projectionFieldName = (Core.Name "flags")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL constructor for hydra.shacl.model.PropertyShape
+propertyShape :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.PropertyShapeConstraint) -> Typed.TypedTerm (Maybe Syntax.Node) -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.PropertyShape
+propertyShape common constraints defaultValue description name order path =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Typed.unTypedTerm common)},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Typed.unTypedTerm constraints)},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Typed.unTypedTerm defaultValue)},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Typed.unTypedTerm description)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Typed.unTypedTerm order)},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Typed.unTypedTerm path)}]}))
+-- | DSL accessor for the common field of hydra.shacl.model.PropertyShape
+propertyShapeCommon :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Model.CommonProperties
+propertyShapeCommon x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "common")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL injection for the lessThan variant of hydra.shacl.model.PropertyShapeConstraint
+propertyShapeConstraintLessThan :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.PropertyShapeConstraint
+propertyShapeConstraintLessThan x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lessThan"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the lessThanOrEquals variant of hydra.shacl.model.PropertyShapeConstraint
+propertyShapeConstraintLessThanOrEquals :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.PropertyShapeConstraint
+propertyShapeConstraintLessThanOrEquals x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lessThanOrEquals"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the maxCount variant of hydra.shacl.model.PropertyShapeConstraint
+propertyShapeConstraintMaxCount :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.PropertyShapeConstraint
+propertyShapeConstraintMaxCount x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "maxCount"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the minCount variant of hydra.shacl.model.PropertyShapeConstraint
+propertyShapeConstraintMinCount :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.PropertyShapeConstraint
+propertyShapeConstraintMinCount x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minCount"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the qualifiedValueShape variant of hydra.shacl.model.PropertyShapeConstraint
+propertyShapeConstraintQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Model.PropertyShapeConstraint
+propertyShapeConstraintQualifiedValueShape x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "qualifiedValueShape"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the uniqueLang variant of hydra.shacl.model.PropertyShapeConstraint
+propertyShapeConstraintUniqueLang :: Typed.TypedTerm Bool -> Typed.TypedTerm Model.PropertyShapeConstraint
+propertyShapeConstraintUniqueLang x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "uniqueLang"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL accessor for the constraints field of hydra.shacl.model.PropertyShape
+propertyShapeConstraints :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (S.Set Model.PropertyShapeConstraint)
+propertyShapeConstraints x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "constraints")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the defaultValue field of hydra.shacl.model.PropertyShape
+propertyShapeDefaultValue :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Syntax.Node)
+propertyShapeDefaultValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "defaultValue")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the description field of hydra.shacl.model.PropertyShape
+propertyShapeDescription :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings
+propertyShapeDescription x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "description")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the name field of hydra.shacl.model.PropertyShape
+propertyShapeName :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings
+propertyShapeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the order field of hydra.shacl.model.PropertyShape
+propertyShapeOrder :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Integer)
+propertyShapeOrder x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "order")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the path field of hydra.shacl.model.PropertyShape
+propertyShapePath :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.Iri
+propertyShapePath x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+        Core.projectionFieldName = (Core.Name "path")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the common field of hydra.shacl.model.PropertyShape
+propertyShapeWithCommon :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithCommon original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "description")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "order")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the constraints field of hydra.shacl.model.PropertyShape
+propertyShapeWithConstraints :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (S.Set Model.PropertyShapeConstraint) -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithConstraints original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "common")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "description")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "order")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the defaultValue field of hydra.shacl.model.PropertyShape
+propertyShapeWithDefaultValue :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Syntax.Node) -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithDefaultValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "common")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "description")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "order")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the description field of hydra.shacl.model.PropertyShape
+propertyShapeWithDescription :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithDescription original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "common")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "order")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the name field of hydra.shacl.model.PropertyShape
+propertyShapeWithName :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "common")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "description")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "order")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the order field of hydra.shacl.model.PropertyShape
+propertyShapeWithOrder :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithOrder original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "common")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "description")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the path field of hydra.shacl.model.PropertyShape
+propertyShapeWithPath :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.PropertyShape
+propertyShapeWithPath original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "common"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "common")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "constraints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "description"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "description")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "order"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),
+              Core.projectionFieldName = (Core.Name "order")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL constructor for hydra.shacl.model.QualifiedValueShape
+qualifiedValueShape :: Typed.TypedTerm (Model.Reference Model.Shape) -> Typed.TypedTerm Integer -> Typed.TypedTerm Integer -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Model.QualifiedValueShape
+qualifiedValueShape qualifiedValueShape qualifiedMaxCount qualifiedMinCount qualifiedValueShapesDisjoint =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShape"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifiedValueShape)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMaxCount"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifiedMaxCount)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMinCount"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifiedMinCount)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifiedValueShapesDisjoint)}]}))
+-- | DSL accessor for the qualifiedMaxCount field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeQualifiedMaxCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer
+qualifiedValueShapeQualifiedMaxCount x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+        Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the qualifiedMinCount field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeQualifiedMinCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer
+qualifiedValueShapeQualifiedMinCount x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+        Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the qualifiedValueShape field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Model.Reference Model.Shape)
+qualifiedValueShapeQualifiedValueShape x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+        Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the qualifiedValueShapesDisjoint field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeQualifiedValueShapesDisjoint :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Maybe Bool)
+qualifiedValueShapeQualifiedValueShapesDisjoint x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+        Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+-- | DSL updater for the qualifiedMaxCount field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedMaxCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer -> Typed.TypedTerm Model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedMaxCount original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShape"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMaxCount"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMinCount"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the qualifiedMinCount field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedMinCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer -> Typed.TypedTerm Model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedMinCount original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShape"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMaxCount"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMinCount"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the qualifiedValueShape field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Model.Reference Model.Shape) -> Typed.TypedTerm Model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedValueShape original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShape"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMaxCount"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMinCount"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+-- | DSL updater for the qualifiedValueShapesDisjoint field of hydra.shacl.model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedValueShapesDisjoint :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Model.QualifiedValueShape
+qualifiedValueShapeWithQualifiedValueShapesDisjoint original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShape"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMaxCount"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedMinCount"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),
+              Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+-- | DSL injection for the anonymous variant of hydra.shacl.model.Reference
+referenceAnonymous :: Typed.TypedTerm a -> Typed.TypedTerm (Model.Reference a)
+referenceAnonymous x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Reference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "anonymous"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the definition variant of hydra.shacl.model.Reference
+referenceDefinition :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm (Model.Reference a)
+referenceDefinition x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Reference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "definition"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the named variant of hydra.shacl.model.Reference
+referenceNamed :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (Model.Reference a)
+referenceNamed x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Reference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "named"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the info variant of hydra.shacl.model.Severity
+severityInfo :: Typed.TypedTerm Model.Severity
+severityInfo =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Severity"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "info"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the violation variant of hydra.shacl.model.Severity
+severityViolation :: Typed.TypedTerm Model.Severity
+severityViolation =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Severity"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "violation"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the warning variant of hydra.shacl.model.Severity
+severityWarning :: Typed.TypedTerm Model.Severity
+severityWarning =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Severity"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "warning"),
+        Core.fieldTerm = Core.TermUnit}}))
+-- | DSL injection for the node variant of hydra.shacl.model.Shape
+shapeNode :: Typed.TypedTerm Model.NodeShape -> Typed.TypedTerm Model.Shape
+shapeNode x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Shape"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "node"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL injection for the property variant of hydra.shacl.model.Shape
+shapeProperty :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Model.Shape
+shapeProperty x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Shape"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "property"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+-- | DSL constructor for the hydra.shacl.model.ShapesGraph wrapper
+shapesGraph :: Typed.TypedTerm (S.Set (Model.Definition Model.Shape)) -> Typed.TypedTerm Model.ShapesGraph
+shapesGraph x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.shacl.model.ShapesGraph"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+-- | DSL accessor for the body of hydra.shacl.model.ShapesGraph
+unShapesGraph :: Typed.TypedTerm Model.ShapesGraph -> Typed.TypedTerm (S.Set (Model.Definition Model.Shape))
+unShapesGraph x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.shacl.model.ShapesGraph")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
diff --git a/src/main/haskell/Hydra/Owl/Syntax.hs b/src/main/haskell/Hydra/Owl/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Owl/Syntax.hs
@@ -0,0 +1,818 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | An OWL 2 syntax model. See https://www.w3.org/TR/owl2-syntax
+
+module Hydra.Owl.Syntax where
+import qualified Hydra.Core as Core
+import qualified Hydra.Rdf.Syntax as Syntax
+import qualified Hydra.Xml.Schema as Schema
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+data Ontology =
+  Ontology {
+    ontologyDirectImports :: [Ontology],
+    ontologyAnnotations :: [Annotation],
+    ontologyAxioms :: [Axiom]}
+  deriving (Eq, Ord, Read, Show)
+_Ontology = Core.Name "hydra.owl.syntax.Ontology"
+_Ontology_directImports = Core.Name "directImports"
+_Ontology_annotations = Core.Name "annotations"
+_Ontology_axioms = Core.Name "axioms"
+data Declaration =
+  Declaration {
+    declarationAnnotations :: [Annotation],
+    declarationEntity :: Entity}
+  deriving (Eq, Ord, Read, Show)
+_Declaration = Core.Name "hydra.owl.syntax.Declaration"
+_Declaration_annotations = Core.Name "annotations"
+_Declaration_entity = Core.Name "entity"
+data Entity =
+  EntityAnnotationProperty AnnotationProperty |
+  EntityClass Class |
+  EntityDataProperty DataProperty |
+  EntityDatatype Datatype |
+  EntityNamedIndividual NamedIndividual |
+  EntityObjectProperty ObjectProperty
+  deriving (Eq, Ord, Read, Show)
+_Entity = Core.Name "hydra.owl.syntax.Entity"
+_Entity_annotationProperty = Core.Name "annotationProperty"
+_Entity_class = Core.Name "class"
+_Entity_dataProperty = Core.Name "dataProperty"
+_Entity_datatype = Core.Name "datatype"
+_Entity_namedIndividual = Core.Name "namedIndividual"
+_Entity_objectProperty = Core.Name "objectProperty"
+data AnnotationSubject =
+  AnnotationSubjectIri Syntax.Iri |
+  AnnotationSubjectAnonymousIndividual AnonymousIndividual
+  deriving (Eq, Ord, Read, Show)
+_AnnotationSubject = Core.Name "hydra.owl.syntax.AnnotationSubject"
+_AnnotationSubject_iri = Core.Name "iri"
+_AnnotationSubject_anonymousIndividual = Core.Name "anonymousIndividual"
+data AnnotationValue =
+  AnnotationValueAnonymousIndividual AnonymousIndividual |
+  AnnotationValueIri Syntax.Iri |
+  AnnotationValueLiteral Syntax.Literal
+  deriving (Eq, Ord, Read, Show)
+_AnnotationValue = Core.Name "hydra.owl.syntax.AnnotationValue"
+_AnnotationValue_anonymousIndividual = Core.Name "anonymousIndividual"
+_AnnotationValue_iri = Core.Name "iri"
+_AnnotationValue_literal = Core.Name "literal"
+data Annotation =
+  Annotation {
+    annotationAnnotations :: [Annotation],
+    annotationProperty :: AnnotationProperty,
+    annotationValue :: AnnotationValue}
+  deriving (Eq, Ord, Read, Show)
+_Annotation = Core.Name "hydra.owl.syntax.Annotation"
+_Annotation_annotations = Core.Name "annotations"
+_Annotation_property = Core.Name "property"
+_Annotation_value = Core.Name "value"
+data AnnotationAxiom =
+  AnnotationAxiomAnnotationAssertion AnnotationAssertion |
+  AnnotationAxiomAnnotationPropertyDomain AnnotationPropertyDomain |
+  AnnotationAxiomAnnotationPropertyRange AnnotationPropertyRange |
+  AnnotationAxiomSubAnnotationPropertyOf SubAnnotationPropertyOf
+  deriving (Eq, Ord, Read, Show)
+_AnnotationAxiom = Core.Name "hydra.owl.syntax.AnnotationAxiom"
+_AnnotationAxiom_annotationAssertion = Core.Name "annotationAssertion"
+_AnnotationAxiom_annotationPropertyDomain = Core.Name "annotationPropertyDomain"
+_AnnotationAxiom_annotationPropertyRange = Core.Name "annotationPropertyRange"
+_AnnotationAxiom_subAnnotationPropertyOf = Core.Name "subAnnotationPropertyOf"
+data AnnotationAssertion =
+  AnnotationAssertion {
+    annotationAssertionAnnotations :: [Annotation],
+    annotationAssertionProperty :: AnnotationProperty,
+    annotationAssertionSubject :: AnnotationSubject,
+    annotationAssertionValue :: AnnotationValue}
+  deriving (Eq, Ord, Read, Show)
+_AnnotationAssertion = Core.Name "hydra.owl.syntax.AnnotationAssertion"
+_AnnotationAssertion_annotations = Core.Name "annotations"
+_AnnotationAssertion_property = Core.Name "property"
+_AnnotationAssertion_subject = Core.Name "subject"
+_AnnotationAssertion_value = Core.Name "value"
+data SubAnnotationPropertyOf =
+  SubAnnotationPropertyOf {
+    subAnnotationPropertyOfAnnotations :: [Annotation],
+    subAnnotationPropertyOfSubProperty :: AnnotationProperty,
+    subAnnotationPropertyOfSuperProperty :: AnnotationProperty}
+  deriving (Eq, Ord, Read, Show)
+_SubAnnotationPropertyOf = Core.Name "hydra.owl.syntax.SubAnnotationPropertyOf"
+_SubAnnotationPropertyOf_annotations = Core.Name "annotations"
+_SubAnnotationPropertyOf_subProperty = Core.Name "subProperty"
+_SubAnnotationPropertyOf_superProperty = Core.Name "superProperty"
+data AnnotationPropertyDomain =
+  AnnotationPropertyDomain {
+    annotationPropertyDomainAnnotations :: [Annotation],
+    annotationPropertyDomainProperty :: AnnotationProperty,
+    annotationPropertyDomainIri :: Syntax.Iri}
+  deriving (Eq, Ord, Read, Show)
+_AnnotationPropertyDomain = Core.Name "hydra.owl.syntax.AnnotationPropertyDomain"
+_AnnotationPropertyDomain_annotations = Core.Name "annotations"
+_AnnotationPropertyDomain_property = Core.Name "property"
+_AnnotationPropertyDomain_iri = Core.Name "iri"
+data AnnotationPropertyRange =
+  AnnotationPropertyRange {
+    annotationPropertyRangeAnnotations :: [Annotation],
+    annotationPropertyRangeProperty :: AnnotationProperty,
+    annotationPropertyRangeIri :: Syntax.Iri}
+  deriving (Eq, Ord, Read, Show)
+_AnnotationPropertyRange = Core.Name "hydra.owl.syntax.AnnotationPropertyRange"
+_AnnotationPropertyRange_annotations = Core.Name "annotations"
+_AnnotationPropertyRange_property = Core.Name "property"
+_AnnotationPropertyRange_iri = Core.Name "iri"
+-- | See https://www.w3.org/TR/owl2-syntax/#Classes
+newtype Class =
+  Class {
+    unClass :: ()}
+  deriving (Eq, Ord, Read, Show)
+_Class = Core.Name "hydra.owl.syntax.Class"
+-- | See https://www.w3.org/TR/owl2-syntax/#Datatypes
+data Datatype =
+  -- | Note: XML Schema datatypes are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common
+  DatatypeXmlSchema Schema.Datatype |
+  DatatypeOther Syntax.Iri
+  deriving (Eq, Ord, Read, Show)
+_Datatype = Core.Name "hydra.owl.syntax.Datatype"
+_Datatype_xmlSchema = Core.Name "xmlSchema"
+_Datatype_other = Core.Name "other"
+-- | See https://www.w3.org/TR/owl2-syntax/#Object_Properties
+newtype ObjectProperty =
+  ObjectProperty {
+    unObjectProperty :: ()}
+  deriving (Eq, Ord, Read, Show)
+_ObjectProperty = Core.Name "hydra.owl.syntax.ObjectProperty"
+newtype DataProperty =
+  DataProperty {
+    unDataProperty :: ()}
+  deriving (Eq, Ord, Read, Show)
+_DataProperty = Core.Name "hydra.owl.syntax.DataProperty"
+newtype AnnotationProperty =
+  AnnotationProperty {
+    unAnnotationProperty :: ()}
+  deriving (Eq, Ord, Read, Show)
+_AnnotationProperty = Core.Name "hydra.owl.syntax.AnnotationProperty"
+data Individual =
+  IndividualNamed NamedIndividual |
+  IndividualAnonymous AnonymousIndividual
+  deriving (Eq, Ord, Read, Show)
+_Individual = Core.Name "hydra.owl.syntax.Individual"
+_Individual_named = Core.Name "named"
+_Individual_anonymous = Core.Name "anonymous"
+newtype NamedIndividual =
+  NamedIndividual {
+    unNamedIndividual :: ()}
+  deriving (Eq, Ord, Read, Show)
+_NamedIndividual = Core.Name "hydra.owl.syntax.NamedIndividual"
+newtype AnonymousIndividual =
+  AnonymousIndividual {
+    unAnonymousIndividual :: ()}
+  deriving (Eq, Ord, Read, Show)
+_AnonymousIndividual = Core.Name "hydra.owl.syntax.AnonymousIndividual"
+data ObjectPropertyExpression =
+  ObjectPropertyExpressionObject ObjectProperty |
+  ObjectPropertyExpressionInverseObject InverseObjectProperty
+  deriving (Eq, Ord, Read, Show)
+_ObjectPropertyExpression = Core.Name "hydra.owl.syntax.ObjectPropertyExpression"
+_ObjectPropertyExpression_object = Core.Name "object"
+_ObjectPropertyExpression_inverseObject = Core.Name "inverseObject"
+newtype InverseObjectProperty =
+  InverseObjectProperty {
+    unInverseObjectProperty :: ObjectProperty}
+  deriving (Eq, Ord, Read, Show)
+_InverseObjectProperty = Core.Name "hydra.owl.syntax.InverseObjectProperty"
+newtype DataPropertyExpression =
+  DataPropertyExpression {
+    unDataPropertyExpression :: DataProperty}
+  deriving (Eq, Ord, Read, Show)
+_DataPropertyExpression = Core.Name "hydra.owl.syntax.DataPropertyExpression"
+-- | See https://www.w3.org/TR/owl2-syntax/#Data_Ranges
+data DataRange =
+  DataRangeDataComplementOf DataComplementOf |
+  DataRangeDataIntersectionOf DataIntersectionOf |
+  DataRangeDataOneOf DataOneOf |
+  DataRangeDataUnionOf DataUnionOf |
+  DataRangeDatatype Datatype |
+  DataRangeDatatypeRestriction DatatypeRestriction
+  deriving (Eq, Ord, Read, Show)
+_DataRange = Core.Name "hydra.owl.syntax.DataRange"
+_DataRange_dataComplementOf = Core.Name "dataComplementOf"
+_DataRange_dataIntersectionOf = Core.Name "dataIntersectionOf"
+_DataRange_dataOneOf = Core.Name "dataOneOf"
+_DataRange_dataUnionOf = Core.Name "dataUnionOf"
+_DataRange_datatype = Core.Name "datatype"
+_DataRange_datatypeRestriction = Core.Name "datatypeRestriction"
+-- | See https://www.w3.org/TR/owl2-syntax/#Intersection_of_Data_Ranges
+newtype DataIntersectionOf =
+  DataIntersectionOf {
+    unDataIntersectionOf :: [DataRange]}
+  deriving (Eq, Ord, Read, Show)
+_DataIntersectionOf = Core.Name "hydra.owl.syntax.DataIntersectionOf"
+-- | See https://www.w3.org/TR/owl2-syntax/#Union_of_Data_Ranges
+newtype DataUnionOf =
+  DataUnionOf {
+    unDataUnionOf :: [DataRange]}
+  deriving (Eq, Ord, Read, Show)
+_DataUnionOf = Core.Name "hydra.owl.syntax.DataUnionOf"
+-- | See https://www.w3.org/TR/owl2-syntax/#Complement_of_Data_Ranges
+newtype DataComplementOf =
+  DataComplementOf {
+    unDataComplementOf :: DataRange}
+  deriving (Eq, Ord, Read, Show)
+_DataComplementOf = Core.Name "hydra.owl.syntax.DataComplementOf"
+-- | See https://www.w3.org/TR/owl2-syntax/#Enumeration_of_Literals
+newtype DataOneOf =
+  DataOneOf {
+    unDataOneOf :: [Syntax.Literal]}
+  deriving (Eq, Ord, Read, Show)
+_DataOneOf = Core.Name "hydra.owl.syntax.DataOneOf"
+-- | See https://www.w3.org/TR/owl2-syntax/#Datatype_Restrictions
+data DatatypeRestriction =
+  DatatypeRestriction {
+    datatypeRestrictionDatatype :: Datatype,
+    datatypeRestrictionConstraints :: [DatatypeRestriction_Constraint]}
+  deriving (Eq, Ord, Read, Show)
+_DatatypeRestriction = Core.Name "hydra.owl.syntax.DatatypeRestriction"
+_DatatypeRestriction_datatype = Core.Name "datatype"
+_DatatypeRestriction_constraints = Core.Name "constraints"
+data DatatypeRestriction_Constraint =
+  DatatypeRestriction_Constraint {
+    datatypeRestriction_ConstraintConstrainingFacet :: DatatypeRestriction_ConstrainingFacet,
+    datatypeRestriction_ConstraintRestrictionValue :: Syntax.Literal}
+  deriving (Eq, Ord, Read, Show)
+_DatatypeRestriction_Constraint = Core.Name "hydra.owl.syntax.DatatypeRestriction_Constraint"
+_DatatypeRestriction_Constraint_constrainingFacet = Core.Name "constrainingFacet"
+_DatatypeRestriction_Constraint_restrictionValue = Core.Name "restrictionValue"
+data DatatypeRestriction_ConstrainingFacet =
+  -- | Note: XML Schema constraining facets are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common
+  DatatypeRestriction_ConstrainingFacetXmlSchema Schema.ConstrainingFacet |
+  DatatypeRestriction_ConstrainingFacetOther Syntax.Iri
+  deriving (Eq, Ord, Read, Show)
+_DatatypeRestriction_ConstrainingFacet = Core.Name "hydra.owl.syntax.DatatypeRestriction_ConstrainingFacet"
+_DatatypeRestriction_ConstrainingFacet_xmlSchema = Core.Name "xmlSchema"
+_DatatypeRestriction_ConstrainingFacet_other = Core.Name "other"
+data ClassExpression =
+  ClassExpressionClass Class |
+  ClassExpressionDataSomeValuesFrom DataSomeValuesFrom |
+  ClassExpressionDataAllValuesFrom DataAllValuesFrom |
+  ClassExpressionDataHasValue DataHasValue |
+  ClassExpressionDataMinCardinality DataMinCardinality |
+  ClassExpressionDataMaxCardinality DataMaxCardinality |
+  ClassExpressionDataExactCardinality DataExactCardinality |
+  ClassExpressionObjectAllValuesFrom ObjectAllValuesFrom |
+  ClassExpressionObjectExactCardinality ObjectExactCardinality |
+  ClassExpressionObjectHasSelf ObjectHasSelf |
+  ClassExpressionObjectHasValue ObjectHasValue |
+  ClassExpressionObjectIntersectionOf ObjectIntersectionOf |
+  ClassExpressionObjectMaxCardinality ObjectMaxCardinality |
+  ClassExpressionObjectMinCardinality ObjectMinCardinality |
+  ClassExpressionObjectOneOf ObjectOneOf |
+  ClassExpressionObjectSomeValuesFrom ObjectSomeValuesFrom |
+  ClassExpressionObjectUnionOf ObjectUnionOf
+  deriving (Eq, Ord, Read, Show)
+_ClassExpression = Core.Name "hydra.owl.syntax.ClassExpression"
+_ClassExpression_class = Core.Name "class"
+_ClassExpression_dataSomeValuesFrom = Core.Name "dataSomeValuesFrom"
+_ClassExpression_dataAllValuesFrom = Core.Name "dataAllValuesFrom"
+_ClassExpression_dataHasValue = Core.Name "dataHasValue"
+_ClassExpression_dataMinCardinality = Core.Name "dataMinCardinality"
+_ClassExpression_dataMaxCardinality = Core.Name "dataMaxCardinality"
+_ClassExpression_dataExactCardinality = Core.Name "dataExactCardinality"
+_ClassExpression_objectAllValuesFrom = Core.Name "objectAllValuesFrom"
+_ClassExpression_objectExactCardinality = Core.Name "objectExactCardinality"
+_ClassExpression_objectHasSelf = Core.Name "objectHasSelf"
+_ClassExpression_objectHasValue = Core.Name "objectHasValue"
+_ClassExpression_objectIntersectionOf = Core.Name "objectIntersectionOf"
+_ClassExpression_objectMaxCardinality = Core.Name "objectMaxCardinality"
+_ClassExpression_objectMinCardinality = Core.Name "objectMinCardinality"
+_ClassExpression_objectOneOf = Core.Name "objectOneOf"
+_ClassExpression_objectSomeValuesFrom = Core.Name "objectSomeValuesFrom"
+_ClassExpression_objectUnionOf = Core.Name "objectUnionOf"
+newtype ObjectIntersectionOf =
+  ObjectIntersectionOf {
+    unObjectIntersectionOf :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_ObjectIntersectionOf = Core.Name "hydra.owl.syntax.ObjectIntersectionOf"
+newtype ObjectUnionOf =
+  ObjectUnionOf {
+    unObjectUnionOf :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_ObjectUnionOf = Core.Name "hydra.owl.syntax.ObjectUnionOf"
+newtype ObjectComplementOf =
+  ObjectComplementOf {
+    unObjectComplementOf :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_ObjectComplementOf = Core.Name "hydra.owl.syntax.ObjectComplementOf"
+newtype ObjectOneOf =
+  ObjectOneOf {
+    unObjectOneOf :: [Individual]}
+  deriving (Eq, Ord, Read, Show)
+_ObjectOneOf = Core.Name "hydra.owl.syntax.ObjectOneOf"
+data ObjectSomeValuesFrom =
+  ObjectSomeValuesFrom {
+    objectSomeValuesFromProperty :: ObjectPropertyExpression,
+    objectSomeValuesFromClass :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_ObjectSomeValuesFrom = Core.Name "hydra.owl.syntax.ObjectSomeValuesFrom"
+_ObjectSomeValuesFrom_property = Core.Name "property"
+_ObjectSomeValuesFrom_class = Core.Name "class"
+data ObjectAllValuesFrom =
+  ObjectAllValuesFrom {
+    objectAllValuesFromProperty :: ObjectPropertyExpression,
+    objectAllValuesFromClass :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_ObjectAllValuesFrom = Core.Name "hydra.owl.syntax.ObjectAllValuesFrom"
+_ObjectAllValuesFrom_property = Core.Name "property"
+_ObjectAllValuesFrom_class = Core.Name "class"
+data ObjectHasValue =
+  ObjectHasValue {
+    objectHasValueProperty :: ObjectPropertyExpression,
+    objectHasValueIndividual :: Individual}
+  deriving (Eq, Ord, Read, Show)
+_ObjectHasValue = Core.Name "hydra.owl.syntax.ObjectHasValue"
+_ObjectHasValue_property = Core.Name "property"
+_ObjectHasValue_individual = Core.Name "individual"
+newtype ObjectHasSelf =
+  ObjectHasSelf {
+    unObjectHasSelf :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_ObjectHasSelf = Core.Name "hydra.owl.syntax.ObjectHasSelf"
+-- | See https://www.w3.org/TR/owl2-syntax/#Minimum_Cardinality
+data ObjectMinCardinality =
+  ObjectMinCardinality {
+    objectMinCardinalityBound :: Integer,
+    objectMinCardinalityProperty :: ObjectPropertyExpression,
+    objectMinCardinalityClass :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_ObjectMinCardinality = Core.Name "hydra.owl.syntax.ObjectMinCardinality"
+_ObjectMinCardinality_bound = Core.Name "bound"
+_ObjectMinCardinality_property = Core.Name "property"
+_ObjectMinCardinality_class = Core.Name "class"
+-- | See https://www.w3.org/TR/owl2-syntax/#Maximum_Cardinality
+data ObjectMaxCardinality =
+  ObjectMaxCardinality {
+    objectMaxCardinalityBound :: Integer,
+    objectMaxCardinalityProperty :: ObjectPropertyExpression,
+    objectMaxCardinalityClass :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_ObjectMaxCardinality = Core.Name "hydra.owl.syntax.ObjectMaxCardinality"
+_ObjectMaxCardinality_bound = Core.Name "bound"
+_ObjectMaxCardinality_property = Core.Name "property"
+_ObjectMaxCardinality_class = Core.Name "class"
+-- | See https://www.w3.org/TR/owl2-syntax/#Exact_Cardinality
+data ObjectExactCardinality =
+  ObjectExactCardinality {
+    objectExactCardinalityBound :: Integer,
+    objectExactCardinalityProperty :: ObjectPropertyExpression,
+    objectExactCardinalityClass :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_ObjectExactCardinality = Core.Name "hydra.owl.syntax.ObjectExactCardinality"
+_ObjectExactCardinality_bound = Core.Name "bound"
+_ObjectExactCardinality_property = Core.Name "property"
+_ObjectExactCardinality_class = Core.Name "class"
+data DataSomeValuesFrom =
+  DataSomeValuesFrom {
+    dataSomeValuesFromProperty :: [DataPropertyExpression],
+    dataSomeValuesFromRange :: DataRange}
+  deriving (Eq, Ord, Read, Show)
+_DataSomeValuesFrom = Core.Name "hydra.owl.syntax.DataSomeValuesFrom"
+_DataSomeValuesFrom_property = Core.Name "property"
+_DataSomeValuesFrom_range = Core.Name "range"
+data DataAllValuesFrom =
+  DataAllValuesFrom {
+    dataAllValuesFromProperty :: [DataPropertyExpression],
+    dataAllValuesFromRange :: DataRange}
+  deriving (Eq, Ord, Read, Show)
+_DataAllValuesFrom = Core.Name "hydra.owl.syntax.DataAllValuesFrom"
+_DataAllValuesFrom_property = Core.Name "property"
+_DataAllValuesFrom_range = Core.Name "range"
+data DataHasValue =
+  DataHasValue {
+    dataHasValueProperty :: DataPropertyExpression,
+    dataHasValueValue :: Syntax.Literal}
+  deriving (Eq, Ord, Read, Show)
+_DataHasValue = Core.Name "hydra.owl.syntax.DataHasValue"
+_DataHasValue_property = Core.Name "property"
+_DataHasValue_value = Core.Name "value"
+data DataMinCardinality =
+  DataMinCardinality {
+    dataMinCardinalityBound :: Integer,
+    dataMinCardinalityProperty :: DataPropertyExpression,
+    dataMinCardinalityRange :: [DataRange]}
+  deriving (Eq, Ord, Read, Show)
+_DataMinCardinality = Core.Name "hydra.owl.syntax.DataMinCardinality"
+_DataMinCardinality_bound = Core.Name "bound"
+_DataMinCardinality_property = Core.Name "property"
+_DataMinCardinality_range = Core.Name "range"
+data DataMaxCardinality =
+  DataMaxCardinality {
+    dataMaxCardinalityBound :: Integer,
+    dataMaxCardinalityProperty :: DataPropertyExpression,
+    dataMaxCardinalityRange :: [DataRange]}
+  deriving (Eq, Ord, Read, Show)
+_DataMaxCardinality = Core.Name "hydra.owl.syntax.DataMaxCardinality"
+_DataMaxCardinality_bound = Core.Name "bound"
+_DataMaxCardinality_property = Core.Name "property"
+_DataMaxCardinality_range = Core.Name "range"
+data DataExactCardinality =
+  DataExactCardinality {
+    dataExactCardinalityBound :: Integer,
+    dataExactCardinalityProperty :: DataPropertyExpression,
+    dataExactCardinalityRange :: [DataRange]}
+  deriving (Eq, Ord, Read, Show)
+_DataExactCardinality = Core.Name "hydra.owl.syntax.DataExactCardinality"
+_DataExactCardinality_bound = Core.Name "bound"
+_DataExactCardinality_property = Core.Name "property"
+_DataExactCardinality_range = Core.Name "range"
+-- | See https://www.w3.org/TR/owl2-syntax/#Axioms
+data Axiom =
+  AxiomAnnotationAxiom AnnotationAxiom |
+  AxiomAssertion Assertion |
+  AxiomClassAxiom ClassAxiom |
+  AxiomDataPropertyAxiom DataPropertyAxiom |
+  AxiomDatatypeDefinition DatatypeDefinition |
+  AxiomDeclaration Declaration |
+  AxiomHasKey HasKey |
+  AxiomObjectPropertyAxiom ObjectPropertyAxiom
+  deriving (Eq, Ord, Read, Show)
+_Axiom = Core.Name "hydra.owl.syntax.Axiom"
+_Axiom_annotationAxiom = Core.Name "annotationAxiom"
+_Axiom_assertion = Core.Name "assertion"
+_Axiom_classAxiom = Core.Name "classAxiom"
+_Axiom_dataPropertyAxiom = Core.Name "dataPropertyAxiom"
+_Axiom_datatypeDefinition = Core.Name "datatypeDefinition"
+_Axiom_declaration = Core.Name "declaration"
+_Axiom_hasKey = Core.Name "hasKey"
+_Axiom_objectPropertyAxiom = Core.Name "objectPropertyAxiom"
+data ClassAxiom =
+  ClassAxiomDisjointClasses DisjointClasses |
+  ClassAxiomDisjointUnion DisjointUnion |
+  ClassAxiomEquivalentClasses EquivalentClasses |
+  ClassAxiomSubClassOf SubClassOf
+  deriving (Eq, Ord, Read, Show)
+_ClassAxiom = Core.Name "hydra.owl.syntax.ClassAxiom"
+_ClassAxiom_disjointClasses = Core.Name "disjointClasses"
+_ClassAxiom_disjointUnion = Core.Name "disjointUnion"
+_ClassAxiom_equivalentClasses = Core.Name "equivalentClasses"
+_ClassAxiom_subClassOf = Core.Name "subClassOf"
+data SubClassOf =
+  SubClassOf {
+    subClassOfAnnotations :: [Annotation],
+    subClassOfSubClass :: ClassExpression,
+    subClassOfSuperClass :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_SubClassOf = Core.Name "hydra.owl.syntax.SubClassOf"
+_SubClassOf_annotations = Core.Name "annotations"
+_SubClassOf_subClass = Core.Name "subClass"
+_SubClassOf_superClass = Core.Name "superClass"
+data EquivalentClasses =
+  EquivalentClasses {
+    equivalentClassesAnnotations :: [Annotation],
+    equivalentClassesClasses :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_EquivalentClasses = Core.Name "hydra.owl.syntax.EquivalentClasses"
+_EquivalentClasses_annotations = Core.Name "annotations"
+_EquivalentClasses_classes = Core.Name "classes"
+data DisjointClasses =
+  DisjointClasses {
+    disjointClassesAnnotations :: [Annotation],
+    disjointClassesClasses :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_DisjointClasses = Core.Name "hydra.owl.syntax.DisjointClasses"
+_DisjointClasses_annotations = Core.Name "annotations"
+_DisjointClasses_classes = Core.Name "classes"
+-- | See https://www.w3.org/TR/owl2-syntax/#Disjoint_Union_of_Class_Expressions
+data DisjointUnion =
+  DisjointUnion {
+    disjointUnionAnnotations :: [Annotation],
+    disjointUnionClass :: Class,
+    disjointUnionClasses :: [ClassExpression]}
+  deriving (Eq, Ord, Read, Show)
+_DisjointUnion = Core.Name "hydra.owl.syntax.DisjointUnion"
+_DisjointUnion_annotations = Core.Name "annotations"
+_DisjointUnion_class = Core.Name "class"
+_DisjointUnion_classes = Core.Name "classes"
+data ObjectPropertyAxiom =
+  ObjectPropertyAxiomAsymmetricObjectProperty AsymmetricObjectProperty |
+  ObjectPropertyAxiomDisjointObjectProperties DisjointObjectProperties |
+  ObjectPropertyAxiomEquivalentObjectProperties EquivalentObjectProperties |
+  ObjectPropertyAxiomFunctionalObjectProperty FunctionalObjectProperty |
+  ObjectPropertyAxiomInverseFunctionalObjectProperty InverseFunctionalObjectProperty |
+  ObjectPropertyAxiomInverseObjectProperties InverseObjectProperties |
+  ObjectPropertyAxiomIrreflexiveObjectProperty IrreflexiveObjectProperty |
+  ObjectPropertyAxiomObjectPropertyDomain ObjectPropertyDomain |
+  ObjectPropertyAxiomObjectPropertyRange ObjectPropertyRange |
+  ObjectPropertyAxiomReflexiveObjectProperty ReflexiveObjectProperty |
+  ObjectPropertyAxiomSubObjectPropertyOf SubObjectPropertyOf |
+  ObjectPropertyAxiomSymmetricObjectProperty SymmetricObjectProperty |
+  ObjectPropertyAxiomTransitiveObjectProperty TransitiveObjectProperty
+  deriving (Eq, Ord, Read, Show)
+_ObjectPropertyAxiom = Core.Name "hydra.owl.syntax.ObjectPropertyAxiom"
+_ObjectPropertyAxiom_asymmetricObjectProperty = Core.Name "asymmetricObjectProperty"
+_ObjectPropertyAxiom_disjointObjectProperties = Core.Name "disjointObjectProperties"
+_ObjectPropertyAxiom_equivalentObjectProperties = Core.Name "equivalentObjectProperties"
+_ObjectPropertyAxiom_functionalObjectProperty = Core.Name "functionalObjectProperty"
+_ObjectPropertyAxiom_inverseFunctionalObjectProperty = Core.Name "inverseFunctionalObjectProperty"
+_ObjectPropertyAxiom_inverseObjectProperties = Core.Name "inverseObjectProperties"
+_ObjectPropertyAxiom_irreflexiveObjectProperty = Core.Name "irreflexiveObjectProperty"
+_ObjectPropertyAxiom_objectPropertyDomain = Core.Name "objectPropertyDomain"
+_ObjectPropertyAxiom_objectPropertyRange = Core.Name "objectPropertyRange"
+_ObjectPropertyAxiom_reflexiveObjectProperty = Core.Name "reflexiveObjectProperty"
+_ObjectPropertyAxiom_subObjectPropertyOf = Core.Name "subObjectPropertyOf"
+_ObjectPropertyAxiom_symmetricObjectProperty = Core.Name "symmetricObjectProperty"
+_ObjectPropertyAxiom_transitiveObjectProperty = Core.Name "transitiveObjectProperty"
+data SubObjectPropertyOf =
+  SubObjectPropertyOf {
+    subObjectPropertyOfAnnotations :: [Annotation],
+    subObjectPropertyOfSubProperty :: [ObjectPropertyExpression],
+    subObjectPropertyOfSuperProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_SubObjectPropertyOf = Core.Name "hydra.owl.syntax.SubObjectPropertyOf"
+_SubObjectPropertyOf_annotations = Core.Name "annotations"
+_SubObjectPropertyOf_subProperty = Core.Name "subProperty"
+_SubObjectPropertyOf_superProperty = Core.Name "superProperty"
+data EquivalentObjectProperties =
+  EquivalentObjectProperties {
+    equivalentObjectPropertiesAnnotations :: [Annotation],
+    equivalentObjectPropertiesProperties :: [ObjectPropertyExpression]}
+  deriving (Eq, Ord, Read, Show)
+_EquivalentObjectProperties = Core.Name "hydra.owl.syntax.EquivalentObjectProperties"
+_EquivalentObjectProperties_annotations = Core.Name "annotations"
+_EquivalentObjectProperties_properties = Core.Name "properties"
+data DisjointObjectProperties =
+  DisjointObjectProperties {
+    disjointObjectPropertiesAnnotations :: [Annotation],
+    disjointObjectPropertiesProperties :: [ObjectPropertyExpression]}
+  deriving (Eq, Ord, Read, Show)
+_DisjointObjectProperties = Core.Name "hydra.owl.syntax.DisjointObjectProperties"
+_DisjointObjectProperties_annotations = Core.Name "annotations"
+_DisjointObjectProperties_properties = Core.Name "properties"
+-- | See https://www.w3.org/TR/owl2-syntax/#Object_Property_Domain
+data ObjectPropertyDomain =
+  ObjectPropertyDomain {
+    objectPropertyDomainAnnotations :: [Annotation],
+    objectPropertyDomainProperty :: ObjectPropertyExpression,
+    objectPropertyDomainDomain :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_ObjectPropertyDomain = Core.Name "hydra.owl.syntax.ObjectPropertyDomain"
+_ObjectPropertyDomain_annotations = Core.Name "annotations"
+_ObjectPropertyDomain_property = Core.Name "property"
+_ObjectPropertyDomain_domain = Core.Name "domain"
+-- | See https://www.w3.org/TR/owl2-syntax/#Object_Property_Range
+data ObjectPropertyRange =
+  ObjectPropertyRange {
+    objectPropertyRangeAnnotations :: [Annotation],
+    objectPropertyRangeProperty :: ObjectPropertyExpression,
+    objectPropertyRangeRange :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_ObjectPropertyRange = Core.Name "hydra.owl.syntax.ObjectPropertyRange"
+_ObjectPropertyRange_annotations = Core.Name "annotations"
+_ObjectPropertyRange_property = Core.Name "property"
+_ObjectPropertyRange_range = Core.Name "range"
+data InverseObjectProperties =
+  InverseObjectProperties {
+    inverseObjectPropertiesAnnotations :: [Annotation],
+    inverseObjectPropertiesProperty1 :: ObjectPropertyExpression,
+    inverseObjectPropertiesProperty2 :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_InverseObjectProperties = Core.Name "hydra.owl.syntax.InverseObjectProperties"
+_InverseObjectProperties_annotations = Core.Name "annotations"
+_InverseObjectProperties_property1 = Core.Name "property1"
+_InverseObjectProperties_property2 = Core.Name "property2"
+data FunctionalObjectProperty =
+  FunctionalObjectProperty {
+    functionalObjectPropertyAnnotations :: [Annotation],
+    functionalObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_FunctionalObjectProperty = Core.Name "hydra.owl.syntax.FunctionalObjectProperty"
+_FunctionalObjectProperty_annotations = Core.Name "annotations"
+_FunctionalObjectProperty_property = Core.Name "property"
+data InverseFunctionalObjectProperty =
+  InverseFunctionalObjectProperty {
+    inverseFunctionalObjectPropertyAnnotations :: [Annotation],
+    inverseFunctionalObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_InverseFunctionalObjectProperty = Core.Name "hydra.owl.syntax.InverseFunctionalObjectProperty"
+_InverseFunctionalObjectProperty_annotations = Core.Name "annotations"
+_InverseFunctionalObjectProperty_property = Core.Name "property"
+data ReflexiveObjectProperty =
+  ReflexiveObjectProperty {
+    reflexiveObjectPropertyAnnotations :: [Annotation],
+    reflexiveObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_ReflexiveObjectProperty = Core.Name "hydra.owl.syntax.ReflexiveObjectProperty"
+_ReflexiveObjectProperty_annotations = Core.Name "annotations"
+_ReflexiveObjectProperty_property = Core.Name "property"
+data IrreflexiveObjectProperty =
+  IrreflexiveObjectProperty {
+    irreflexiveObjectPropertyAnnotations :: [Annotation],
+    irreflexiveObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_IrreflexiveObjectProperty = Core.Name "hydra.owl.syntax.IrreflexiveObjectProperty"
+_IrreflexiveObjectProperty_annotations = Core.Name "annotations"
+_IrreflexiveObjectProperty_property = Core.Name "property"
+data SymmetricObjectProperty =
+  SymmetricObjectProperty {
+    symmetricObjectPropertyAnnotations :: [Annotation],
+    symmetricObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_SymmetricObjectProperty = Core.Name "hydra.owl.syntax.SymmetricObjectProperty"
+_SymmetricObjectProperty_annotations = Core.Name "annotations"
+_SymmetricObjectProperty_property = Core.Name "property"
+data AsymmetricObjectProperty =
+  AsymmetricObjectProperty {
+    asymmetricObjectPropertyAnnotations :: [Annotation],
+    asymmetricObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_AsymmetricObjectProperty = Core.Name "hydra.owl.syntax.AsymmetricObjectProperty"
+_AsymmetricObjectProperty_annotations = Core.Name "annotations"
+_AsymmetricObjectProperty_property = Core.Name "property"
+data TransitiveObjectProperty =
+  TransitiveObjectProperty {
+    transitiveObjectPropertyAnnotations :: [Annotation],
+    transitiveObjectPropertyProperty :: ObjectPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_TransitiveObjectProperty = Core.Name "hydra.owl.syntax.TransitiveObjectProperty"
+_TransitiveObjectProperty_annotations = Core.Name "annotations"
+_TransitiveObjectProperty_property = Core.Name "property"
+data DataPropertyAxiom =
+  DataPropertyAxiomDataPropertyAxiom DataPropertyAxiom |
+  DataPropertyAxiomDataPropertyRange DataPropertyRange |
+  DataPropertyAxiomDisjointDataProperties DisjointDataProperties |
+  DataPropertyAxiomEquivalentDataProperties EquivalentDataProperties |
+  DataPropertyAxiomFunctionalDataProperty FunctionalDataProperty |
+  DataPropertyAxiomSubDataPropertyOf SubDataPropertyOf
+  deriving (Eq, Ord, Read, Show)
+_DataPropertyAxiom = Core.Name "hydra.owl.syntax.DataPropertyAxiom"
+_DataPropertyAxiom_dataPropertyAxiom = Core.Name "dataPropertyAxiom"
+_DataPropertyAxiom_dataPropertyRange = Core.Name "dataPropertyRange"
+_DataPropertyAxiom_disjointDataProperties = Core.Name "disjointDataProperties"
+_DataPropertyAxiom_equivalentDataProperties = Core.Name "equivalentDataProperties"
+_DataPropertyAxiom_functionalDataProperty = Core.Name "functionalDataProperty"
+_DataPropertyAxiom_subDataPropertyOf = Core.Name "subDataPropertyOf"
+data SubDataPropertyOf =
+  SubDataPropertyOf {
+    subDataPropertyOfAnnotations :: [Annotation],
+    subDataPropertyOfSubProperty :: DataPropertyExpression,
+    subDataPropertyOfSuperProperty :: DataPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_SubDataPropertyOf = Core.Name "hydra.owl.syntax.SubDataPropertyOf"
+_SubDataPropertyOf_annotations = Core.Name "annotations"
+_SubDataPropertyOf_subProperty = Core.Name "subProperty"
+_SubDataPropertyOf_superProperty = Core.Name "superProperty"
+data EquivalentDataProperties =
+  EquivalentDataProperties {
+    equivalentDataPropertiesAnnotations :: [Annotation],
+    equivalentDataPropertiesProperties :: [DataPropertyExpression]}
+  deriving (Eq, Ord, Read, Show)
+_EquivalentDataProperties = Core.Name "hydra.owl.syntax.EquivalentDataProperties"
+_EquivalentDataProperties_annotations = Core.Name "annotations"
+_EquivalentDataProperties_properties = Core.Name "properties"
+data DisjointDataProperties =
+  DisjointDataProperties {
+    disjointDataPropertiesAnnotations :: [Annotation],
+    disjointDataPropertiesProperties :: [DataPropertyExpression]}
+  deriving (Eq, Ord, Read, Show)
+_DisjointDataProperties = Core.Name "hydra.owl.syntax.DisjointDataProperties"
+_DisjointDataProperties_annotations = Core.Name "annotations"
+_DisjointDataProperties_properties = Core.Name "properties"
+data DataPropertyDomain =
+  DataPropertyDomain {
+    dataPropertyDomainAnnotations :: [Annotation],
+    dataPropertyDomainProperty :: DataPropertyExpression,
+    dataPropertyDomainDomain :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_DataPropertyDomain = Core.Name "hydra.owl.syntax.DataPropertyDomain"
+_DataPropertyDomain_annotations = Core.Name "annotations"
+_DataPropertyDomain_property = Core.Name "property"
+_DataPropertyDomain_domain = Core.Name "domain"
+data DataPropertyRange =
+  DataPropertyRange {
+    dataPropertyRangeAnnotations :: [Annotation],
+    dataPropertyRangeProperty :: DataPropertyExpression,
+    dataPropertyRangeRange :: ClassExpression}
+  deriving (Eq, Ord, Read, Show)
+_DataPropertyRange = Core.Name "hydra.owl.syntax.DataPropertyRange"
+_DataPropertyRange_annotations = Core.Name "annotations"
+_DataPropertyRange_property = Core.Name "property"
+_DataPropertyRange_range = Core.Name "range"
+data FunctionalDataProperty =
+  FunctionalDataProperty {
+    functionalDataPropertyAnnotations :: [Annotation],
+    functionalDataPropertyProperty :: DataPropertyExpression}
+  deriving (Eq, Ord, Read, Show)
+_FunctionalDataProperty = Core.Name "hydra.owl.syntax.FunctionalDataProperty"
+_FunctionalDataProperty_annotations = Core.Name "annotations"
+_FunctionalDataProperty_property = Core.Name "property"
+data DatatypeDefinition =
+  DatatypeDefinition {
+    datatypeDefinitionAnnotations :: [Annotation],
+    datatypeDefinitionDatatype :: Datatype,
+    datatypeDefinitionRange :: DataRange}
+  deriving (Eq, Ord, Read, Show)
+_DatatypeDefinition = Core.Name "hydra.owl.syntax.DatatypeDefinition"
+_DatatypeDefinition_annotations = Core.Name "annotations"
+_DatatypeDefinition_datatype = Core.Name "datatype"
+_DatatypeDefinition_range = Core.Name "range"
+-- | See https://www.w3.org/TR/owl2-syntax/#Keys
+data HasKey =
+  HasKey {
+    hasKeyAnnotations :: [Annotation],
+    hasKeyClass :: ClassExpression,
+    hasKeyObjectProperties :: [ObjectPropertyExpression],
+    hasKeyDataProperties :: [DataPropertyExpression]}
+  deriving (Eq, Ord, Read, Show)
+_HasKey = Core.Name "hydra.owl.syntax.HasKey"
+_HasKey_annotations = Core.Name "annotations"
+_HasKey_class = Core.Name "class"
+_HasKey_objectProperties = Core.Name "objectProperties"
+_HasKey_dataProperties = Core.Name "dataProperties"
+data Assertion =
+  AssertionClassAssertion ClassAssertion |
+  AssertionDataPropertyAssertion DataPropertyAssertion |
+  AssertionDifferentIndividuals DifferentIndividuals |
+  AssertionObjectPropertyAssertion ObjectPropertyAssertion |
+  AssertionNegativeDataPropertyAssertion NegativeDataPropertyAssertion |
+  AssertionNegativeObjectPropertyAssertion NegativeObjectPropertyAssertion |
+  AssertionSameIndividual SameIndividual
+  deriving (Eq, Ord, Read, Show)
+_Assertion = Core.Name "hydra.owl.syntax.Assertion"
+_Assertion_classAssertion = Core.Name "classAssertion"
+_Assertion_dataPropertyAssertion = Core.Name "dataPropertyAssertion"
+_Assertion_differentIndividuals = Core.Name "differentIndividuals"
+_Assertion_objectPropertyAssertion = Core.Name "objectPropertyAssertion"
+_Assertion_negativeDataPropertyAssertion = Core.Name "negativeDataPropertyAssertion"
+_Assertion_negativeObjectPropertyAssertion = Core.Name "negativeObjectPropertyAssertion"
+_Assertion_sameIndividual = Core.Name "sameIndividual"
+data SameIndividual =
+  SameIndividual {
+    sameIndividualAnnotations :: [Annotation],
+    sameIndividualIndividuals :: [Individual]}
+  deriving (Eq, Ord, Read, Show)
+_SameIndividual = Core.Name "hydra.owl.syntax.SameIndividual"
+_SameIndividual_annotations = Core.Name "annotations"
+_SameIndividual_individuals = Core.Name "individuals"
+data DifferentIndividuals =
+  DifferentIndividuals {
+    differentIndividualsAnnotations :: [Annotation],
+    differentIndividualsIndividuals :: [Individual]}
+  deriving (Eq, Ord, Read, Show)
+_DifferentIndividuals = Core.Name "hydra.owl.syntax.DifferentIndividuals"
+_DifferentIndividuals_annotations = Core.Name "annotations"
+_DifferentIndividuals_individuals = Core.Name "individuals"
+data ClassAssertion =
+  ClassAssertion {
+    classAssertionAnnotations :: [Annotation],
+    classAssertionClass :: ClassExpression,
+    classAssertionIndividual :: Individual}
+  deriving (Eq, Ord, Read, Show)
+_ClassAssertion = Core.Name "hydra.owl.syntax.ClassAssertion"
+_ClassAssertion_annotations = Core.Name "annotations"
+_ClassAssertion_class = Core.Name "class"
+_ClassAssertion_individual = Core.Name "individual"
+data ObjectPropertyAssertion =
+  ObjectPropertyAssertion {
+    objectPropertyAssertionAnnotations :: [Annotation],
+    objectPropertyAssertionProperty :: ObjectPropertyExpression,
+    objectPropertyAssertionSource :: Individual,
+    objectPropertyAssertionTarget :: Individual}
+  deriving (Eq, Ord, Read, Show)
+_ObjectPropertyAssertion = Core.Name "hydra.owl.syntax.ObjectPropertyAssertion"
+_ObjectPropertyAssertion_annotations = Core.Name "annotations"
+_ObjectPropertyAssertion_property = Core.Name "property"
+_ObjectPropertyAssertion_source = Core.Name "source"
+_ObjectPropertyAssertion_target = Core.Name "target"
+data NegativeObjectPropertyAssertion =
+  NegativeObjectPropertyAssertion {
+    negativeObjectPropertyAssertionAnnotations :: [Annotation],
+    negativeObjectPropertyAssertionProperty :: ObjectPropertyExpression,
+    negativeObjectPropertyAssertionSource :: Individual,
+    negativeObjectPropertyAssertionTarget :: Individual}
+  deriving (Eq, Ord, Read, Show)
+_NegativeObjectPropertyAssertion = Core.Name "hydra.owl.syntax.NegativeObjectPropertyAssertion"
+_NegativeObjectPropertyAssertion_annotations = Core.Name "annotations"
+_NegativeObjectPropertyAssertion_property = Core.Name "property"
+_NegativeObjectPropertyAssertion_source = Core.Name "source"
+_NegativeObjectPropertyAssertion_target = Core.Name "target"
+data DataPropertyAssertion =
+  DataPropertyAssertion {
+    dataPropertyAssertionAnnotations :: [Annotation],
+    dataPropertyAssertionProperty :: DataPropertyExpression,
+    dataPropertyAssertionSource :: Individual,
+    dataPropertyAssertionTarget :: Individual}
+  deriving (Eq, Ord, Read, Show)
+_DataPropertyAssertion = Core.Name "hydra.owl.syntax.DataPropertyAssertion"
+_DataPropertyAssertion_annotations = Core.Name "annotations"
+_DataPropertyAssertion_property = Core.Name "property"
+_DataPropertyAssertion_source = Core.Name "source"
+_DataPropertyAssertion_target = Core.Name "target"
+data NegativeDataPropertyAssertion =
+  NegativeDataPropertyAssertion {
+    negativeDataPropertyAssertionAnnotations :: [Annotation],
+    negativeDataPropertyAssertionProperty :: DataPropertyExpression,
+    negativeDataPropertyAssertionSource :: Individual,
+    negativeDataPropertyAssertionTarget :: Individual}
+  deriving (Eq, Ord, Read, Show)
+_NegativeDataPropertyAssertion = Core.Name "hydra.owl.syntax.NegativeDataPropertyAssertion"
+_NegativeDataPropertyAssertion_annotations = Core.Name "annotations"
+_NegativeDataPropertyAssertion_property = Core.Name "property"
+_NegativeDataPropertyAssertion_source = Core.Name "source"
+_NegativeDataPropertyAssertion_target = Core.Name "target"
diff --git a/src/main/haskell/Hydra/Rdf/Serde.hs b/src/main/haskell/Hydra/Rdf/Serde.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Rdf/Serde.hs
@@ -0,0 +1,140 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | Serialization functions for converting RDF graphs to N-Triples format expressions
+
+module Hydra.Rdf.Serde where
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Rdf.Syntax as Syntax
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Convert a blank node to an expression
+blankNodeToExpr :: Syntax.BlankNode -> Ast.Expr
+blankNodeToExpr bnode =
+    Serialization.noSep [
+      Serialization.cst "_:",
+      (Serialization.cst (Syntax.unBlankNode bnode))]
+-- | Escape a single IRI character code to a string
+escapeIriChar :: Int -> String
+escapeIriChar c =
+    Logic.ifElse (Logic.or (Equality.lte c 32) (Logic.or (Equality.equal c 60) (Logic.or (Equality.equal c 62) (Logic.or (Equality.equal c 34) (Logic.or (Equality.equal c 123) (Logic.or (Equality.equal c 125) (Logic.or (Equality.equal c 124) (Logic.or (Equality.equal c 94) (Logic.or (Equality.equal c 96) (Equality.equal c 92)))))))))) (uchar4 c) (Strings.fromList [
+      c])
+-- | Escape a string for use in an N-Triples IRI. Disallowed characters are emitted as 4-digit UCHAR escapes.
+escapeIriStr :: String -> String
+escapeIriStr s = Strings.cat (Lists.map escapeIriChar (Strings.toList s))
+-- | Escape a single literal character code to a string
+escapeLiteralChar :: Int -> String
+escapeLiteralChar c =
+    Logic.ifElse (Equality.equal c 34) "\\\"" (Logic.ifElse (Equality.equal c 92) "\\\\" (Logic.ifElse (Equality.equal c 10) "\\n" (Logic.ifElse (Equality.equal c 13) "\\r" (Strings.fromList [
+      c]))))
+-- | Escape a string for use in an N-Triples literal
+escapeLiteralString :: String -> String
+escapeLiteralString s = Strings.cat (Lists.map escapeLiteralChar (Strings.toList s))
+-- | Convert an RDF graph to an expression
+graphToExpr :: Syntax.Graph -> Ast.Expr
+graphToExpr g = Serialization.newlineSep (Lists.map tripleToExpr (Sets.toList (Syntax.unGraph g)))
+-- | Convert a value 0-15 to an uppercase hex digit code point
+hexDigit :: Int -> Int
+hexDigit n = Logic.ifElse (Equality.lt n 10) (Math.add n 48) (Math.add (Math.sub n 10) 65)
+-- | Convert an IRI to an expression
+iriToExpr :: Syntax.Iri -> Ast.Expr
+iriToExpr iri =
+    Serialization.noSep [
+      Serialization.cst "<",
+      (Serialization.cst (escapeIriStr (Syntax.unIri iri))),
+      (Serialization.cst ">")]
+-- | Convert a language tag to an expression
+languageTagToExpr :: Syntax.LanguageTag -> Ast.Expr
+languageTagToExpr lang =
+    Serialization.noSep [
+      Serialization.cst "@",
+      (Serialization.cst (Syntax.unLanguageTag lang))]
+-- | Convert a literal to an expression
+literalToExpr :: Syntax.Literal -> Ast.Expr
+literalToExpr lit =
+
+      let lex = Syntax.literalLexicalForm lit
+          dt = Syntax.literalDatatypeIri lit
+          lang = Syntax.literalLanguageTag lit
+          lexExpr =
+                  Serialization.cst (Strings.cat [
+                    "\"",
+                    (escapeLiteralString lex),
+                    "\""])
+          suffix =
+                  Optionals.cases lang (Serialization.noSep [
+                    Serialization.cst "^^",
+                    (iriToExpr dt)]) languageTagToExpr
+      in (Serialization.noSep [
+        lexExpr,
+        suffix])
+-- | Convert a node to an expression
+nodeToExpr :: Syntax.Node -> Ast.Expr
+nodeToExpr n =
+    case n of
+      Syntax.NodeIri v0 -> iriToExpr v0
+      Syntax.NodeBnode v0 -> blankNodeToExpr v0
+      Syntax.NodeLiteral v0 -> literalToExpr v0
+-- | Convert an RDF graph to an N-Triples string
+rdfGraphToNtriples :: Syntax.Graph -> String
+rdfGraphToNtriples g = Serialization.printExpr (graphToExpr g)
+-- | Convert a resource to an expression
+resourceToExpr :: Syntax.Resource -> Ast.Expr
+resourceToExpr r =
+    case r of
+      Syntax.ResourceIri v0 -> iriToExpr v0
+      Syntax.ResourceBnode v0 -> blankNodeToExpr v0
+-- | Convert a triple to an expression
+tripleToExpr :: Syntax.Triple -> Ast.Expr
+tripleToExpr t =
+
+      let subj = Syntax.tripleSubject t
+          pred = Syntax.triplePredicate t
+          obj = Syntax.tripleObject t
+      in (Serialization.spaceSep [
+        resourceToExpr subj,
+        (iriToExpr pred),
+        (nodeToExpr obj),
+        (Serialization.cst ".")])
+-- | Format a code point as a 4-digit UCHAR escape sequence
+uchar4 :: Int -> String
+uchar4 c =
+
+      let d3 = Optionals.fromOptional 0 (Math.maybeDiv c 4096)
+          r3 = Optionals.fromOptional 0 (Math.maybeMod c 4096)
+          d2 = Optionals.fromOptional 0 (Math.maybeDiv r3 256)
+          r2 = Optionals.fromOptional 0 (Math.maybeMod r3 256)
+          d1 = Optionals.fromOptional 0 (Math.maybeDiv r2 16)
+          d0 = Optionals.fromOptional 0 (Math.maybeMod r2 16)
+      in (Strings.cat2 "\\u" (Strings.fromList [
+        hexDigit d3,
+        (hexDigit d2),
+        (hexDigit d1),
+        (hexDigit d0)]))
diff --git a/src/main/haskell/Hydra/Rdf/Syntax.hs b/src/main/haskell/Hydra/Rdf/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Rdf/Syntax.hs
@@ -0,0 +1,132 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | An RDF 1.1 syntax model
+
+module Hydra.Rdf.Syntax where
+import qualified Hydra.Core as Core
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Map as M
+import qualified Data.Set as S
+newtype BlankNode =
+  BlankNode {
+    unBlankNode :: String}
+  deriving (Eq, Ord, Read, Show)
+_BlankNode = Core.Name "hydra.rdf.syntax.BlankNode"
+-- | Stand-in for rdfs:Class
+newtype RdfsClass =
+  RdfsClass {
+    unRdfsClass :: ()}
+  deriving (Eq, Ord, Read, Show)
+_RdfsClass = Core.Name "hydra.rdf.syntax.RdfsClass"
+newtype Dataset =
+  Dataset {
+    unDataset :: (S.Set Quad)}
+  deriving (Eq, Ord, Read, Show)
+_Dataset = Core.Name "hydra.rdf.syntax.Dataset"
+-- | A graph of RDF statements together with a distinguished subject and/or object node
+data Description =
+  Description {
+    descriptionSubject :: Node,
+    descriptionGraph :: Graph}
+  deriving (Eq, Ord, Read, Show)
+_Description = Core.Name "hydra.rdf.syntax.Description"
+_Description_subject = Core.Name "subject"
+_Description_graph = Core.Name "graph"
+newtype Graph =
+  Graph {
+    unGraph :: (S.Set Triple)}
+  deriving (Eq, Ord, Read, Show)
+_Graph = Core.Name "hydra.rdf.syntax.Graph"
+-- | An Internationalized Resource Identifier
+newtype Iri =
+  Iri {
+    unIri :: String}
+  deriving (Eq, Ord, Read, Show)
+_Iri = Core.Name "hydra.rdf.syntax.Iri"
+-- | An IRI or a literal; this type is a convenience for downstream models like SHACL which may exclude blank nodes
+data IriOrLiteral =
+  IriOrLiteralIri Iri |
+  IriOrLiteralLiteral Literal
+  deriving (Eq, Ord, Read, Show)
+_IriOrLiteral = Core.Name "hydra.rdf.syntax.IriOrLiteral"
+_IriOrLiteral_iri = Core.Name "iri"
+_IriOrLiteral_literal = Core.Name "literal"
+-- | A convenience type which provides at most one string value per language, and optionally a value without a language
+newtype LangStrings =
+  LangStrings {
+    unLangStrings :: (M.Map (Maybe LanguageTag) String)}
+  deriving (Eq, Ord, Read, Show)
+_LangStrings = Core.Name "hydra.rdf.syntax.LangStrings"
+-- | A BCP47 language tag
+newtype LanguageTag =
+  LanguageTag {
+    unLanguageTag :: String}
+  deriving (Eq, Ord, Read, Show)
+_LanguageTag = Core.Name "hydra.rdf.syntax.LanguageTag"
+-- | A value such as a string, number, or date
+data Literal =
+  Literal {
+    -- | a Unicode string, which should be in Normal Form C
+    literalLexicalForm :: String,
+    -- | an IRI identifying a datatype that determines how the lexical form maps to a literal value
+    literalDatatypeIri :: Iri,
+    -- | An optional language tag, present if and only if the datatype IRI is http://www.w3.org/1999/02/22-rdf-syntax-ns#langString
+    literalLanguageTag :: (Maybe LanguageTag)}
+  deriving (Eq, Ord, Read, Show)
+_Literal = Core.Name "hydra.rdf.syntax.Literal"
+_Literal_lexicalForm = Core.Name "lexicalForm"
+_Literal_datatypeIri = Core.Name "datatypeIri"
+_Literal_languageTag = Core.Name "languageTag"
+data Node =
+  NodeIri Iri |
+  NodeBnode BlankNode |
+  NodeLiteral Literal
+  deriving (Eq, Ord, Read, Show)
+_Node = Core.Name "hydra.rdf.syntax.Node"
+_Node_iri = Core.Name "iri"
+_Node_bnode = Core.Name "bnode"
+_Node_literal = Core.Name "literal"
+-- | A type representing an RDF property, and encapsulating its domain, range, and subclass relationships
+data Property =
+  Property {
+    -- | State that any resource that has a given property is an instance of one or more classes
+    propertyDomain :: (S.Set RdfsClass),
+    -- | States that the values of a property are instances of one or more classes
+    propertyRange :: (S.Set RdfsClass),
+    propertySubPropertyOf :: (S.Set Property)}
+  deriving (Eq, Ord, Read, Show)
+_Property = Core.Name "hydra.rdf.syntax.Property"
+_Property_domain = Core.Name "domain"
+_Property_range = Core.Name "range"
+_Property_subPropertyOf = Core.Name "subPropertyOf"
+-- | An RDF triple with an optional named graph component
+data Quad =
+  Quad {
+    quadSubject :: Resource,
+    quadPredicate :: Iri,
+    quadObject :: Node,
+    quadGraph :: (Maybe Iri)}
+  deriving (Eq, Ord, Read, Show)
+_Quad = Core.Name "hydra.rdf.syntax.Quad"
+_Quad_subject = Core.Name "subject"
+_Quad_predicate = Core.Name "predicate"
+_Quad_object = Core.Name "object"
+_Quad_graph = Core.Name "graph"
+data Resource =
+  ResourceIri Iri |
+  ResourceBnode BlankNode
+  deriving (Eq, Ord, Read, Show)
+_Resource = Core.Name "hydra.rdf.syntax.Resource"
+_Resource_iri = Core.Name "iri"
+_Resource_bnode = Core.Name "bnode"
+-- | An RDF triple defined by a subject, predicate, and object
+data Triple =
+  Triple {
+    tripleSubject :: Resource,
+    triplePredicate :: Iri,
+    tripleObject :: Node}
+  deriving (Eq, Ord, Read, Show)
+_Triple = Core.Name "hydra.rdf.syntax.Triple"
+_Triple_subject = Core.Name "subject"
+_Triple_predicate = Core.Name "predicate"
+_Triple_object = Core.Name "object"
diff --git a/src/main/haskell/Hydra/Rdf/Utils.hs b/src/main/haskell/Hydra/Rdf/Utils.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Rdf/Utils.hs
@@ -0,0 +1,170 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | Utility functions for working with RDF graphs and descriptions
+
+module Hydra.Rdf.Utils where
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
+import qualified Hydra.Overlay.Haskell.Lib.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Rdf.Syntax as Syntax
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Convert a list of descriptions to an RDF graph
+descriptionsToGraph :: [Syntax.Description] -> Syntax.Graph
+descriptionsToGraph ds = Syntax.Graph (Sets.fromList (triplesOf ds))
+-- | Create an empty description with a given node
+emptyDescription :: Syntax.Node -> Syntax.Description
+emptyDescription node =
+    Syntax.Description {
+      Syntax.descriptionSubject = node,
+      Syntax.descriptionGraph = emptyRdfGraph}
+-- | An empty LangStrings value
+emptyLangStrings :: Syntax.LangStrings
+emptyLangStrings = Syntax.LangStrings Maps.empty
+-- | An empty RDF graph
+emptyRdfGraph :: Syntax.Graph
+emptyRdfGraph = Syntax.Graph Sets.empty
+-- | Encode a Hydra literal as an RDF literal
+encodeLiteral :: Core.Literal -> Syntax.Literal
+encodeLiteral lit =
+    case lit of
+      Core.LiteralBinary v0 -> Syntax.Literal {
+        Syntax.literalLexicalForm = (Literals.binaryToString v0),
+        Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "base64Binary"),
+        Syntax.literalLanguageTag = Nothing}
+      Core.LiteralBoolean v0 -> Syntax.Literal {
+        Syntax.literalLexicalForm = (Logic.ifElse v0 "true" "false"),
+        Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "boolean"),
+        Syntax.literalLanguageTag = Nothing}
+      Core.LiteralFloat v0 -> case v0 of
+        Core.FloatValueFloat32 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showFloat32 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "float"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.FloatValueFloat64 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showFloat64 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "double"),
+          Syntax.literalLanguageTag = Nothing}
+      Core.LiteralInteger v0 -> case v0 of
+        Core.IntegerValueBigint v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showBigint v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "integer"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueInt8 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showInt8 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "byte"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueInt16 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showInt16 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "short"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueInt32 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showInt32 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "int"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueInt64 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showInt64 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "long"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueUint8 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showUint8 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedByte"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueUint16 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showUint16 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedShort"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueUint32 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showUint32 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedInt"),
+          Syntax.literalLanguageTag = Nothing}
+        Core.IntegerValueUint64 v1 -> Syntax.Literal {
+          Syntax.literalLexicalForm = (Literals.showUint64 v1),
+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedLong"),
+          Syntax.literalLanguageTag = Nothing}
+      Core.LiteralString v0 -> Syntax.Literal {
+        Syntax.literalLexicalForm = v0,
+        Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "string"),
+        Syntax.literalLanguageTag = Nothing}
+-- | Create triples from a subject, predicate, and list of object nodes
+forObjects :: Syntax.Resource -> Syntax.Iri -> [Syntax.Node] -> [Syntax.Triple]
+forObjects subj pred objs =
+    Lists.map (\obj -> Syntax.Triple {
+      Syntax.tripleSubject = subj,
+      Syntax.triplePredicate = pred,
+      Syntax.tripleObject = obj}) objs
+-- | Construct an IRI from a namespace and local name
+iri :: String -> String -> Syntax.Iri
+iri ns local = Syntax.Iri (Strings.cat2 ns local)
+-- | Construct a key IRI from a local name
+keyIri :: String -> Syntax.Iri
+keyIri local = iri "urn:key:" local
+-- | Merge a list of RDF graphs into a single graph
+mergeGraphs :: [Syntax.Graph] -> Syntax.Graph
+mergeGraphs graphs = Syntax.Graph (Sets.unions (Lists.map Syntax.unGraph graphs))
+-- | Convert a Hydra name to an RDF IRI
+nameToIri :: Core.Name -> Syntax.Iri
+nameToIri name = Syntax.Iri (Strings.cat2 "urn:" (Core.unName name))
+-- | Generate the next blank node and an incremented counter
+nextBlankNode :: Int -> (Syntax.Resource, Int)
+nextBlankNode counter =
+    (Syntax.ResourceBnode (Syntax.BlankNode (Strings.cat2 "b" (Literals.showInt32 counter))), (Math.add counter 1))
+-- | Construct a property IRI from a record name and field name
+propertyIri :: Core.Name -> Core.Name -> Syntax.Iri
+propertyIri rname fname =
+
+      let qualName = Names.qualifyName rname
+          gname = Util.qualifiedNameModuleName qualName
+          local_ = Util.qualifiedNameLocal qualName
+      in (Syntax.Iri (Strings.cat [
+        "urn:",
+        (Optionals.cases gname "" Packaging.unModuleName),
+        "#",
+        (Formatting.decapitalize local_),
+        (Formatting.capitalize (Core.unName fname))]))
+-- | Construct an RDF namespace IRI
+rdfIri :: String -> Syntax.Iri
+rdfIri local = iri "http://www.w3.org/1999/02/22-rdf-syntax-ns#" local
+-- | Convert a resource to a node
+resourceToNode :: Syntax.Resource -> Syntax.Node
+resourceToNode r =
+    case r of
+      Syntax.ResourceIri v0 -> Syntax.NodeIri v0
+      Syntax.ResourceBnode v0 -> Syntax.NodeBnode v0
+-- | Extract subjects from a list of descriptions
+subjectsOf :: [Syntax.Description] -> [Syntax.Node]
+subjectsOf descs = Lists.map Syntax.descriptionSubject descs
+-- | Extract all triples from a list of descriptions
+triplesOf :: [Syntax.Description] -> [Syntax.Triple]
+triplesOf descs = Lists.concat (Lists.map (\d -> Sets.toList (Syntax.unGraph (Syntax.descriptionGraph d))) descs)
+-- | Construct an XML Schema datatype IRI
+xmlSchemaDatatypeIri :: String -> Syntax.Iri
+xmlSchemaDatatypeIri local = iri "http://www.w3.org/2001/XMLSchema#" local
diff --git a/src/main/haskell/Hydra/Shacl/Coder.hs b/src/main/haskell/Hydra/Shacl/Coder.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Shacl/Coder.hs
@@ -0,0 +1,317 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | SHACL coder: converts Hydra types and terms to SHACL shapes and RDF descriptions
+
+module Hydra.Shacl.Coder where
+import qualified Hydra.Annotations as Annotations
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Constants as Constants
+import qualified Hydra.Core as Core
+import qualified Hydra.Decode.Core as DecodeCore
+import qualified Hydra.Encode.Core as EncodeCore
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Extract.Core as ExtractCore
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as JsonModel
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
+import qualified Hydra.Overlay.Haskell.Lib.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Rdf.Syntax as Syntax
+import qualified Hydra.Rdf.Utils as Utils
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Shacl.Model as ShaclModel
+import qualified Hydra.Strip as Strip
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Construct CommonProperties from a list of constraints, using defaults for other fields
+common :: [ShaclModel.CommonConstraint] -> ShaclModel.CommonProperties
+common constraints =
+    ShaclModel.CommonProperties {
+      ShaclModel.commonPropertiesConstraints = (Sets.fromList constraints),
+      ShaclModel.commonPropertiesDeactivated = Nothing,
+      ShaclModel.commonPropertiesMessage = (Syntax.LangStrings Maps.empty),
+      ShaclModel.commonPropertiesSeverity = ShaclModel.SeverityInfo,
+      ShaclModel.commonPropertiesTargetClass = Sets.empty,
+      ShaclModel.commonPropertiesTargetNode = Sets.empty,
+      ShaclModel.commonPropertiesTargetObjectsOf = Sets.empty,
+      ShaclModel.commonPropertiesTargetSubjectsOf = Sets.empty}
+-- | Default CommonProperties with empty constraints and default severity
+defaultCommonProperties :: ShaclModel.CommonProperties
+defaultCommonProperties = common []
+-- | Convert a binding's name to an RDF IRI
+elementIri :: Core.Binding -> Syntax.Iri
+elementIri el = Utils.nameToIri (Core.bindingName el)
+-- | Encode a record field as RDF triples with a given subject
+encodeField :: Core.Name -> Syntax.Resource -> Core.Field -> Int -> Graph.Graph -> Either Errors.Error ([Syntax.Triple], Int)
+encodeField rname subject field cx g =
+
+      let pair1 = Utils.nextBlankNode cx
+          node = Pairs.first pair1
+          cx1 = Pairs.second pair1
+      in (Eithers.bind (encodeTerm node (Core.fieldTerm field) cx1 g) (\_r1 ->
+        let descs = Pairs.first _r1
+            cx2 = Pairs.second _r1
+        in (Right (
+          Lists.concat2 (Utils.triplesOf descs) (Utils.forObjects subject (Utils.propertyIri rname (Core.fieldName field)) (Utils.subjectsOf descs)),
+          cx2))))
+-- | Encode a FieldType as a SHACL property shape Definition
+encodeFieldType :: Core.Name -> Maybe Integer -> Core.FieldType -> t0 -> Either Errors.Error (ShaclModel.Definition ShaclModel.PropertyShape)
+encodeFieldType rname order ft cx =
+
+      let fname = Core.fieldTypeName ft
+          ftype = Core.fieldTypeType ft
+          iri = Utils.propertyIri rname fname
+          forType =
+                  \mn -> \mx -> \t -> case (Strip.deannotateType t) of
+                    Core.TypeOptional v0 -> forType (Just 0) mx v0
+                    Core.TypeSet v0 -> forType mn Nothing v0
+                    _ -> forTypeDefault mn mx t
+          forTypeDefault =
+                  \mn -> \mx -> \t -> Eithers.map (\_cp ->
+                    let baseProp = property iri
+                        minC = Optionals.map (\_n -> ShaclModel.PropertyShapeConstraintMinCount _n) mn
+                        maxC = Optionals.map (\_n -> ShaclModel.PropertyShapeConstraintMaxCount _n) mx
+                    in ShaclModel.Definition {
+                      ShaclModel.definitionIri = iri,
+                      ShaclModel.definitionTarget = ShaclModel.PropertyShape {
+                        ShaclModel.propertyShapeCommon = _cp,
+                        ShaclModel.propertyShapeConstraints = (Sets.fromList (Optionals.cat [
+                          minC,
+                          maxC])),
+                        ShaclModel.propertyShapeDefaultValue = Nothing,
+                        ShaclModel.propertyShapeDescription = (Syntax.LangStrings Maps.empty),
+                        ShaclModel.propertyShapeName = (Syntax.LangStrings Maps.empty),
+                        ShaclModel.propertyShapeOrder = order,
+                        ShaclModel.propertyShapePath = iri}}) (encodeType rname t cx)
+      in (forType (Just 1) (Just 1) ftype)
+-- | Encode a list of terms as RDF list structure
+encodeList :: Syntax.Resource -> [Core.Term] -> Int -> Graph.Graph -> Either Errors.Error ([Syntax.Description], Int)
+encodeList subj terms cx0 g =
+    Logic.ifElse (Lists.null terms) (Right (
+      [
+        Syntax.Description {
+          Syntax.descriptionSubject = (Syntax.NodeIri (Syntax.Iri "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil")),
+          Syntax.descriptionGraph = (Syntax.Graph Sets.empty)}],
+      cx0)) (Optionals.cases (Lists.uncons terms) (Right ([], cx0)) (\p ->
+      let pair1 = Utils.nextBlankNode cx0
+          node1 = Pairs.first pair1
+          cx1 = Pairs.second pair1
+      in (Eithers.bind (encodeTerm node1 (Pairs.first p) cx1 g) (\_r1 ->
+        let fdescs = Pairs.first _r1
+            cx2 = Pairs.second _r1
+            firstTriples = Lists.concat2 (Utils.triplesOf fdescs) (Utils.forObjects subj (Utils.rdfIri "first") (Utils.subjectsOf fdescs))
+            pair2 = Utils.nextBlankNode cx2
+            next = Pairs.first pair2
+            cx3 = Pairs.second pair2
+        in (Eithers.map (\_r2 ->
+          let rdescs = Pairs.first _r2
+              cx4 = Pairs.second _r2
+              restTriples = Lists.concat2 (Utils.triplesOf rdescs) (Utils.forObjects subj (Utils.rdfIri "rest") (Utils.subjectsOf rdescs))
+          in (
+            [
+              Syntax.Description {
+                Syntax.descriptionSubject = (Utils.resourceToNode subj),
+                Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Lists.concat2 firstTriples restTriples)))}],
+            cx4)) (encodeList next (Pairs.second p) cx3 g))))))
+-- | Encode a LiteralType as SHACL CommonProperties with an XSD datatype constraint
+encodeLiteralType :: Core.LiteralType -> ShaclModel.CommonProperties
+encodeLiteralType lt =
+
+      let xsd = \local -> common [
+            ShaclModel.CommonConstraintDatatype (Utils.xmlSchemaDatatypeIri local)]
+      in case lt of
+        Core.LiteralTypeBinary -> xsd "base64Binary"
+        Core.LiteralTypeBoolean -> xsd "boolean"
+        Core.LiteralTypeFloat v0 -> case v0 of
+          Core.FloatTypeFloat32 -> xsd "float"
+          Core.FloatTypeFloat64 -> xsd "double"
+        Core.LiteralTypeInteger v0 -> case v0 of
+          Core.IntegerTypeBigint -> xsd "integer"
+          Core.IntegerTypeInt8 -> xsd "byte"
+          Core.IntegerTypeInt16 -> xsd "short"
+          Core.IntegerTypeInt32 -> xsd "int"
+          Core.IntegerTypeInt64 -> xsd "long"
+          Core.IntegerTypeUint8 -> xsd "unsignedByte"
+          Core.IntegerTypeUint16 -> xsd "unsignedShort"
+          Core.IntegerTypeUint32 -> xsd "unsignedInt"
+          Core.IntegerTypeUint64 -> xsd "unsignedLong"
+        Core.LiteralTypeString -> xsd "string"
+-- | Encode a Hydra term as a list of RDF Descriptions
+encodeTerm :: Syntax.Resource -> Core.Term -> Int -> Graph.Graph -> Either Errors.Error ([Syntax.Description], Int)
+encodeTerm subject term cx g =
+    case term of
+      Core.TermAnnotated v0 -> encodeTerm subject (Core.annotatedTermBody v0) cx g
+      Core.TermList v0 -> encodeList subject v0 cx g
+      Core.TermLiteral v0 -> Right (
+        [
+          Syntax.Description {
+            Syntax.descriptionSubject = (Syntax.NodeLiteral (Utils.encodeLiteral v0)),
+            Syntax.descriptionGraph = (Syntax.Graph Sets.empty)}],
+        cx)
+      Core.TermMap v0 -> Eithers.map (\_r -> (
+        [
+          Syntax.Description {
+            Syntax.descriptionSubject = (Utils.resourceToNode subject),
+            Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Lists.concat (Pairs.first _r))))}],
+        (Pairs.second _r))) (foldAccumResult (\_cx0 -> \kv -> Eithers.bind (ExtractCore.string g (Strip.deannotateTerm (Pairs.first kv))) (\_ks ->
+        let pair2 = Utils.nextBlankNode _cx0
+            node2 = Pairs.first pair2
+            cx2 = Pairs.second pair2
+        in (Eithers.map (\_dr -> (
+          Lists.concat2 (Utils.forObjects subject (Utils.keyIri _ks) (Utils.subjectsOf (Pairs.first _dr))) (Utils.triplesOf (Pairs.first _dr)),
+          (Pairs.second _dr))) (encodeTerm node2 (Pairs.second kv) cx2 g)))) cx (Maps.toList v0))
+      Core.TermWrap v0 -> Eithers.map (\_dr ->
+        let descs = Pairs.first _dr
+            cx1 = Pairs.second _dr
+        in (
+          Optionals.fromOptional descs (Optionals.map (\p -> Lists.cons (withType (Core.wrappedTermTypeName v0) (Pairs.first p)) (Pairs.second p)) (Lists.uncons descs)),
+          cx1)) (encodeTerm subject (Core.wrappedTermBody v0) cx g)
+      Core.TermOptional v0 -> Optionals.cases v0 (Right ([], cx)) (\_inner -> encodeTerm subject _inner cx g)
+      Core.TermRecord v0 ->
+        let rname = Core.recordTypeName v0
+            fields = Core.recordFields v0
+        in (Eithers.map (\_r -> (
+          [
+            withType rname (Syntax.Description {
+              Syntax.descriptionSubject = (Utils.resourceToNode subject),
+              Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Lists.concat (Pairs.first _r))))})],
+          (Pairs.second _r))) (foldAccumResult (\_cx0 -> \field -> encodeField rname subject field _cx0 g) cx fields))
+      Core.TermSet v0 -> Eithers.map (\_r -> (Lists.concat (Pairs.first _r), (Pairs.second _r))) (foldAccumResult (\_cx0 -> \t ->
+        let pair3 = Utils.nextBlankNode _cx0
+            node3 = Pairs.first pair3
+            cx3 = Pairs.second pair3
+        in (encodeTerm node3 t cx3 g)) cx (Sets.toList v0))
+      Core.TermInject v0 ->
+        let rname = Core.injectionTypeName v0
+            field = Core.injectionField v0
+        in (Eithers.map (\_r -> (
+          [
+            withType rname (Syntax.Description {
+              Syntax.descriptionSubject = (Utils.resourceToNode subject),
+              Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Pairs.first _r)))})],
+          (Pairs.second _r))) (encodeField rname subject field cx g))
+      _ -> unexpectedE "RDF-compatible term" "unsupported term variant"
+-- | Encode a Hydra type as SHACL CommonProperties
+encodeType :: Core.Name -> Core.Type -> t0 -> Either Errors.Error ShaclModel.CommonProperties
+encodeType tname typ cx =
+
+      let any = Right (common [])
+      in case (Strip.deannotateType typ) of
+        Core.TypeEither _ -> any
+        Core.TypeList _ -> any
+        Core.TypeLiteral v0 -> Right (encodeLiteralType v0)
+        Core.TypeMap _ -> any
+        Core.TypePair _ -> any
+        Core.TypeWrap _ -> any
+        Core.TypeRecord v0 -> Eithers.map (\_props -> common [
+          ShaclModel.CommonConstraintProperty (Sets.fromList (Lists.map (\_p -> ShaclModel.ReferenceDefinition _p) _props))]) (Eithers.mapList (\_pair -> encodeFieldType tname (Just (Pairs.first _pair)) (Pairs.second _pair) cx) (Lists.zip (Lists.map (\_i -> Literals.int32ToBigint _i) (Math.range 0 (Lists.length v0))) v0))
+        Core.TypeSet _ -> any
+        Core.TypeUnion v0 -> Eithers.map (\_props -> common [
+          ShaclModel.CommonConstraintXone (Sets.fromList (Lists.map (\_p -> ShaclModel.ReferenceAnonymous (node [
+            ShaclModel.CommonConstraintProperty (Sets.fromList [
+              ShaclModel.ReferenceDefinition _p])])) _props))]) (Eithers.mapList (\_ft -> encodeFieldType tname Nothing _ft cx) v0)
+        Core.TypeUnit -> any
+        Core.TypeVariable v0 -> Right (common [
+          ShaclModel.CommonConstraintNode (Sets.fromList [
+            ShaclModel.ReferenceNamed (Utils.nameToIri v0)])])
+        _ -> unexpectedE "type" "unsupported type variant"
+-- | Construct an error result with the given message
+err :: String -> Either Errors.Error t0
+err msg = Left (Errors.ErrorOther (Errors.OtherError msg))
+-- | Fold over a list, accumulating results and threading context through each step
+foldAccumResult :: (t0 -> t1 -> Either t2 (t3, t0)) -> t0 -> [t1] -> Either t2 ([t3], t0)
+foldAccumResult f cx xs =
+    Optionals.cases (Lists.uncons xs) (Right ([], cx)) (\p -> Eithers.bind (f cx (Pairs.first p)) (\_r -> Eithers.map (\_rest -> (Lists.cons (Pairs.first _r) (Pairs.first _rest), (Pairs.second _rest))) (foldAccumResult f (Pairs.second _r) (Pairs.second p))))
+-- | Construct a SHACL node shape from a list of common constraints
+node :: [ShaclModel.CommonConstraint] -> ShaclModel.Shape
+node constraints = ShaclModel.ShapeNode (ShaclModel.NodeShape {
+  ShaclModel.nodeShapeCommon = (common constraints)})
+-- | Construct a default property shape with the given IRI as its path
+property :: Syntax.Iri -> ShaclModel.PropertyShape
+property iri =
+    ShaclModel.PropertyShape {
+      ShaclModel.propertyShapeCommon = defaultCommonProperties,
+      ShaclModel.propertyShapeConstraints = Sets.empty,
+      ShaclModel.propertyShapeDefaultValue = Nothing,
+      ShaclModel.propertyShapeDescription = (Syntax.LangStrings Maps.empty),
+      ShaclModel.propertyShapeName = (Syntax.LangStrings Maps.empty),
+      ShaclModel.propertyShapeOrder = Nothing,
+      ShaclModel.propertyShapePath = iri}
+-- | Encode a module's type elements as a SHACL ShapesGraph
+shaclCoder :: Packaging.Module -> t0 -> Graph.Graph -> Either Errors.Error (ShaclModel.ShapesGraph, t0)
+shaclCoder mod cx g =
+
+      let typeEls =
+              Optionals.cat (Lists.map (\d -> case d of
+                Packaging.DefinitionType v0 -> Just ((\name -> \typ ->
+                  let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type")
+                      dataTerm =
+                              Annotations.normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm {
+                                Core.annotatedTermBody = (EncodeCore.type_ typ),
+                                Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.fromList [
+                                  (Constants.keyType, schemaTerm)]))}))
+                  in Core.Binding {
+                    Core.bindingName = name,
+                    Core.bindingTerm = dataTerm,
+                    Core.bindingTypeScheme = (Just (Core.TypeScheme {
+                      Core.typeSchemeVariables = [],
+                      Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),
+                      Core.typeSchemeConstraints = Nothing}))}) (Packaging.typeDefinitionName v0) (Core.typeSchemeBody (Packaging.typeDefinitionBody v0)))
+                _ -> Nothing) (Packaging.moduleDefinitions mod))
+          toShape =
+                  \el -> Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_t -> _t) (DecodeCore.type_ g (Core.bindingTerm el))) (\_typ -> Eithers.map (\_cp -> ShaclModel.Definition {
+                    ShaclModel.definitionIri = (elementIri el),
+                    ShaclModel.definitionTarget = (ShaclModel.ShapeNode (ShaclModel.NodeShape {
+                      ShaclModel.nodeShapeCommon = _cp}))}) (encodeType (Core.bindingName el) _typ cx))
+      in (Eithers.map (\_shapes -> (ShaclModel.ShapesGraph (Sets.fromList _shapes), cx)) (Eithers.mapList toShape typeEls))
+-- | Construct an error for unexpected input, given expected and found descriptions
+unexpectedE :: String -> String -> Either Errors.Error t0
+unexpectedE expected found =
+    err (Strings.cat [
+      "Expected ",
+      expected,
+      ", found: ",
+      found])
+-- | Add an rdf:type triple to an RDF Description
+withType :: Core.Name -> Syntax.Description -> Syntax.Description
+withType name desc =
+
+      let subj = Syntax.descriptionSubject desc
+          triples = Syntax.unGraph (Syntax.descriptionGraph desc)
+          subjRes =
+                  case subj of
+                    Syntax.NodeIri v0 -> Syntax.ResourceIri v0
+                    Syntax.NodeBnode v0 -> Syntax.ResourceBnode v0
+          triple =
+                  Syntax.Triple {
+                    Syntax.tripleSubject = subjRes,
+                    Syntax.triplePredicate = (Utils.rdfIri "type"),
+                    Syntax.tripleObject = (Syntax.NodeIri (Utils.nameToIri name))}
+      in Syntax.Description {
+        Syntax.descriptionSubject = subj,
+        Syntax.descriptionGraph = (Syntax.Graph (Sets.insert triple triples))}
diff --git a/src/main/haskell/Hydra/Shacl/Language.hs b/src/main/haskell/Hydra/Shacl/Language.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Shacl/Language.hs
@@ -0,0 +1,79 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | Language constraints for W3C SHACL
+
+module Hydra.Shacl.Language where
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Language constraints for W3C SHACL
+shaclLanguage :: Coders.Language
+shaclLanguage =
+    Coders.Language {
+      Coders.languageName = (Coders.LanguageName "hydra.shacl"),
+      Coders.languageConstraints = Coders.LanguageConstraints {
+        Coders.languageConstraintsLiteralVariants = literalVariants,
+        Coders.languageConstraintsFloatTypes = floatTypes,
+        Coders.languageConstraintsIntegerTypes = integerTypes,
+        Coders.languageConstraintsTermVariants = termVariants,
+        Coders.languageConstraintsTypeVariants = typeVariants,
+        Coders.languageConstraintsTypes = typePredicate}}
+  where
+    literalVariants =
+        Sets.fromList [
+          Variants.LiteralVariantBoolean,
+          Variants.LiteralVariantFloat,
+          Variants.LiteralVariantInteger,
+          Variants.LiteralVariantString]
+    floatTypes =
+        Sets.fromList [
+          Core.FloatTypeFloat32,
+          Core.FloatTypeFloat64]
+    integerTypes =
+        Sets.fromList [
+          Core.IntegerTypeInt32,
+          Core.IntegerTypeInt64]
+    termVariants =
+        Sets.fromList [
+          Variants.TermVariantList,
+          Variants.TermVariantLiteral,
+          Variants.TermVariantMap,
+          Variants.TermVariantWrap,
+          Variants.TermVariantOptional,
+          Variants.TermVariantRecord,
+          Variants.TermVariantSet,
+          Variants.TermVariantInject]
+    typeVariants =
+        Sets.fromList [
+          Variants.TypeVariantAnnotated,
+          Variants.TypeVariantList,
+          Variants.TypeVariantLiteral,
+          Variants.TypeVariantMap,
+          Variants.TypeVariantWrap,
+          Variants.TypeVariantOptional,
+          Variants.TypeVariantRecord,
+          Variants.TypeVariantSet,
+          Variants.TypeVariantUnion]
+    typePredicate = \_ -> True
diff --git a/src/main/haskell/Hydra/Shacl/Model.hs b/src/main/haskell/Hydra/Shacl/Model.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Shacl/Model.hs
@@ -0,0 +1,260 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | A SHACL syntax model. See https://www.w3.org/TR/shacl
+
+module Hydra.Shacl.Model where
+import qualified Hydra.Core as Core
+import qualified Hydra.Rdf.Syntax as Syntax
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Set as S
+-- | See https://www.w3.org/TR/shacl/#ClosedPatterConstraintComponent
+data Closed =
+  Closed {
+    closedIsClosed :: Bool,
+    closedIgnoredProperties :: (Maybe (S.Set Syntax.Property))}
+  deriving (Eq, Ord, Read, Show)
+_Closed = Core.Name "hydra.shacl.model.Closed"
+_Closed_isClosed = Core.Name "isClosed"
+_Closed_ignoredProperties = Core.Name "ignoredProperties"
+-- | Any of a number of constraint parameters which can be applied either to node or property shapes
+data CommonConstraint =
+  -- | See https://www.w3.org/TR/shacl/#AndConstraintComponent
+  CommonConstraintAnd (S.Set (Reference Shape)) |
+  -- | See https://www.w3.org/TR/shacl/#ClosedConstraintComponent
+  CommonConstraintClosed Closed |
+  -- | See https://www.w3.org/TR/shacl/#ClassConstraintComponent
+  CommonConstraintClass (S.Set Syntax.RdfsClass) |
+  -- | See https://www.w3.org/TR/shacl/#DatatypeConstraintComponent
+  CommonConstraintDatatype Syntax.Iri |
+  -- | See https://www.w3.org/TR/shacl/#DisjointConstraintComponent
+  CommonConstraintDisjoint (S.Set Syntax.Property) |
+  -- | See https://www.w3.org/TR/shacl/#EqualsConstraintComponent
+  CommonConstraintEquals (S.Set Syntax.Property) |
+  -- | Specifies the condition that at least one value node is equal to the given RDF term. See https://www.w3.org/TR/shacl/#HasValueConstraintComponent
+  CommonConstraintHasValue (S.Set Syntax.Node) |
+  -- | Specifies the condition that each value node is a member of a provided SHACL list. See https://www.w3.org/TR/shacl/#InConstraintComponent
+  CommonConstraintIn [Syntax.Node] |
+  -- | See https://www.w3.org/TR/shacl/#LanguageInConstraintComponent
+  CommonConstraintLanguageIn (S.Set Syntax.LanguageTag) |
+  -- | See https://www.w3.org/TR/shacl/#NodeKindConstraintComponent
+  CommonConstraintNodeKind NodeKind |
+  -- | See https://www.w3.org/TR/shacl/#NodeConstraintComponent
+  CommonConstraintNode (S.Set (Reference NodeShape)) |
+  -- | See https://www.w3.org/TR/shacl/#NotConstraintComponent
+  CommonConstraintNot (S.Set (Reference Shape)) |
+  -- | See https://www.w3.org/TR/shacl/#MaxExclusiveConstraintComponent
+  CommonConstraintMaxExclusive Syntax.Literal |
+  -- | See https://www.w3.org/TR/shacl/#MaxInclusiveConstraintComponent
+  CommonConstraintMaxInclusive Syntax.Literal |
+  -- | See https://www.w3.org/TR/shacl/#MaxLengthConstraintComponent
+  CommonConstraintMaxLength Integer |
+  -- | See https://www.w3.org/TR/shacl/#MinExclusiveConstraintComponent
+  CommonConstraintMinExclusive Syntax.Literal |
+  -- | See https://www.w3.org/TR/shacl/#MinInclusiveConstraintComponent
+  CommonConstraintMinInclusive Syntax.Literal |
+  -- | See https://www.w3.org/TR/shacl/#MinLengthConstraintComponent
+  CommonConstraintMinLength Integer |
+  -- | See https://www.w3.org/TR/shacl/#PatternConstraintComponent
+  CommonConstraintPattern Pattern |
+  -- | See https://www.w3.org/TR/shacl/#PropertyConstraintComponent
+  CommonConstraintProperty (S.Set (Reference PropertyShape)) |
+  -- | See https://www.w3.org/TR/shacl/#OrConstraintComponent
+  CommonConstraintOr (S.Set (Reference Shape)) |
+  -- | See https://www.w3.org/TR/shacl/#XoneConstraintComponent
+  CommonConstraintXone (S.Set (Reference Shape))
+  deriving (Eq, Ord, Read, Show)
+_CommonConstraint = Core.Name "hydra.shacl.model.CommonConstraint"
+_CommonConstraint_and = Core.Name "and"
+_CommonConstraint_closed = Core.Name "closed"
+_CommonConstraint_class = Core.Name "class"
+_CommonConstraint_datatype = Core.Name "datatype"
+_CommonConstraint_disjoint = Core.Name "disjoint"
+_CommonConstraint_equals = Core.Name "equals"
+_CommonConstraint_hasValue = Core.Name "hasValue"
+_CommonConstraint_in = Core.Name "in"
+_CommonConstraint_languageIn = Core.Name "languageIn"
+_CommonConstraint_nodeKind = Core.Name "nodeKind"
+_CommonConstraint_node = Core.Name "node"
+_CommonConstraint_not = Core.Name "not"
+_CommonConstraint_maxExclusive = Core.Name "maxExclusive"
+_CommonConstraint_maxInclusive = Core.Name "maxInclusive"
+_CommonConstraint_maxLength = Core.Name "maxLength"
+_CommonConstraint_minExclusive = Core.Name "minExclusive"
+_CommonConstraint_minInclusive = Core.Name "minInclusive"
+_CommonConstraint_minLength = Core.Name "minLength"
+_CommonConstraint_pattern = Core.Name "pattern"
+_CommonConstraint_property = Core.Name "property"
+_CommonConstraint_or = Core.Name "or"
+_CommonConstraint_xone = Core.Name "xone"
+-- | Common constraint parameters and other properties for SHACL shapes
+data CommonProperties =
+  CommonProperties {
+    -- | Common constraint parameters attached to this shape
+    commonPropertiesConstraints :: (S.Set CommonConstraint),
+    -- | See https://www.w3.org/TR/shacl/#deactivated
+    commonPropertiesDeactivated :: (Maybe Bool),
+    -- | See https://www.w3.org/TR/shacl/#message
+    commonPropertiesMessage :: Syntax.LangStrings,
+    -- | See https://www.w3.org/TR/shacl/#severity
+    commonPropertiesSeverity :: Severity,
+    -- | See https://www.w3.org/TR/shacl/#targetClass
+    commonPropertiesTargetClass :: (S.Set Syntax.RdfsClass),
+    -- | See https://www.w3.org/TR/shacl/#targetNode
+    commonPropertiesTargetNode :: (S.Set Syntax.IriOrLiteral),
+    -- | See https://www.w3.org/TR/shacl/#targetObjectsOf
+    commonPropertiesTargetObjectsOf :: (S.Set Syntax.Property),
+    -- | See https://www.w3.org/TR/shacl/#targetSubjectsOf
+    commonPropertiesTargetSubjectsOf :: (S.Set Syntax.Property)}
+  deriving (Eq, Ord, Read, Show)
+_CommonProperties = Core.Name "hydra.shacl.model.CommonProperties"
+_CommonProperties_constraints = Core.Name "constraints"
+_CommonProperties_deactivated = Core.Name "deactivated"
+_CommonProperties_message = Core.Name "message"
+_CommonProperties_severity = Core.Name "severity"
+_CommonProperties_targetClass = Core.Name "targetClass"
+_CommonProperties_targetNode = Core.Name "targetNode"
+_CommonProperties_targetObjectsOf = Core.Name "targetObjectsOf"
+_CommonProperties_targetSubjectsOf = Core.Name "targetSubjectsOf"
+-- | An instance of a type like sh:Shape or sh:NodeShape, together with a unique IRI for that instance
+data Definition a =
+  Definition {
+    definitionIri :: Syntax.Iri,
+    definitionTarget :: a}
+  deriving (Eq, Ord, Read, Show)
+_Definition = Core.Name "hydra.shacl.model.Definition"
+_Definition_iri = Core.Name "iri"
+_Definition_target = Core.Name "target"
+data NodeKind =
+  -- | A blank node
+  NodeKindBlankNode |
+  -- | An IRI
+  NodeKindIri |
+  -- | A literal
+  NodeKindLiteral |
+  -- | A blank node or an IRI
+  NodeKindBlankNodeOrIri |
+  -- | A blank node or a literal
+  NodeKindBlankNodeOrLiteral |
+  -- | An IRI or a literal
+  NodeKindIriOrLiteral
+  deriving (Eq, Ord, Read, Show)
+_NodeKind = Core.Name "hydra.shacl.model.NodeKind"
+_NodeKind_blankNode = Core.Name "blankNode"
+_NodeKind_iri = Core.Name "iri"
+_NodeKind_literal = Core.Name "literal"
+_NodeKind_blankNodeOrIri = Core.Name "blankNodeOrIri"
+_NodeKind_blankNodeOrLiteral = Core.Name "blankNodeOrLiteral"
+_NodeKind_iriOrLiteral = Core.Name "iriOrLiteral"
+-- | A SHACL node shape. See https://www.w3.org/TR/shacl/#node-shapes
+data NodeShape =
+  NodeShape {
+    nodeShapeCommon :: CommonProperties}
+  deriving (Eq, Ord, Read, Show)
+_NodeShape = Core.Name "hydra.shacl.model.NodeShape"
+_NodeShape_common = Core.Name "common"
+-- | A SHACL pattern. See https://www.w3.org/TR/shacl/#PatternConstraintComponent
+data Pattern =
+  Pattern {
+    patternRegex :: String,
+    patternFlags :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+_Pattern = Core.Name "hydra.shacl.model.Pattern"
+_Pattern_regex = Core.Name "regex"
+_Pattern_flags = Core.Name "flags"
+-- | A SHACL property shape. See https://www.w3.org/TR/shacl/#property-shapes
+data PropertyShape =
+  PropertyShape {
+    propertyShapeCommon :: CommonProperties,
+    -- | Any property shape -specific constraint parameters
+    propertyShapeConstraints :: (S.Set PropertyShapeConstraint),
+    -- | See https://www.w3.org/TR/shacl/#defaultValue
+    propertyShapeDefaultValue :: (Maybe Syntax.Node),
+    -- | See https://www.w3.org/TR/shacl/#name
+    propertyShapeDescription :: Syntax.LangStrings,
+    -- | See https://www.w3.org/TR/shacl/#name
+    propertyShapeName :: Syntax.LangStrings,
+    -- | See https://www.w3.org/TR/shacl/#order
+    propertyShapeOrder :: (Maybe Integer),
+    propertyShapePath :: Syntax.Iri}
+  deriving (Eq, Ord, Read, Show)
+_PropertyShape = Core.Name "hydra.shacl.model.PropertyShape"
+_PropertyShape_common = Core.Name "common"
+_PropertyShape_constraints = Core.Name "constraints"
+_PropertyShape_defaultValue = Core.Name "defaultValue"
+_PropertyShape_description = Core.Name "description"
+_PropertyShape_name = Core.Name "name"
+_PropertyShape_order = Core.Name "order"
+_PropertyShape_path = Core.Name "path"
+-- | A number of constraint parameters which are specific to property shapes, and cannot be applied to node shapes
+data PropertyShapeConstraint =
+  -- | See https://www.w3.org/TR/shacl/#LessThanConstraintComponent
+  PropertyShapeConstraintLessThan (S.Set Syntax.Property) |
+  -- | See https://www.w3.org/TR/shacl/#LessThanOrEqualsConstraintComponent
+  PropertyShapeConstraintLessThanOrEquals (S.Set Syntax.Property) |
+  -- | The maximum cardinality. Node shapes cannot have any value for sh:maxCount. See https://www.w3.org/TR/shacl/#MaxCountConstraintComponent
+  PropertyShapeConstraintMaxCount Integer |
+  -- | The minimum cardinality. Node shapes cannot have any value for sh:minCount. See https://www.w3.org/TR/shacl/#MinCountConstraintComponent
+  PropertyShapeConstraintMinCount Integer |
+  -- | See https://www.w3.org/TR/shacl/#UniqueLangConstraintComponent
+  PropertyShapeConstraintUniqueLang Bool |
+  -- | See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent
+  PropertyShapeConstraintQualifiedValueShape QualifiedValueShape
+  deriving (Eq, Ord, Read, Show)
+_PropertyShapeConstraint = Core.Name "hydra.shacl.model.PropertyShapeConstraint"
+_PropertyShapeConstraint_lessThan = Core.Name "lessThan"
+_PropertyShapeConstraint_lessThanOrEquals = Core.Name "lessThanOrEquals"
+_PropertyShapeConstraint_maxCount = Core.Name "maxCount"
+_PropertyShapeConstraint_minCount = Core.Name "minCount"
+_PropertyShapeConstraint_uniqueLang = Core.Name "uniqueLang"
+_PropertyShapeConstraint_qualifiedValueShape = Core.Name "qualifiedValueShape"
+-- | See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent
+data QualifiedValueShape =
+  QualifiedValueShape {
+    qualifiedValueShapeQualifiedValueShape :: (Reference Shape),
+    qualifiedValueShapeQualifiedMaxCount :: Integer,
+    qualifiedValueShapeQualifiedMinCount :: Integer,
+    qualifiedValueShapeQualifiedValueShapesDisjoint :: (Maybe Bool)}
+  deriving (Eq, Ord, Read, Show)
+_QualifiedValueShape = Core.Name "hydra.shacl.model.QualifiedValueShape"
+_QualifiedValueShape_qualifiedValueShape = Core.Name "qualifiedValueShape"
+_QualifiedValueShape_qualifiedMaxCount = Core.Name "qualifiedMaxCount"
+_QualifiedValueShape_qualifiedMinCount = Core.Name "qualifiedMinCount"
+_QualifiedValueShape_qualifiedValueShapesDisjoint = Core.Name "qualifiedValueShapesDisjoint"
+-- | Either an instance of a type like sh:Shape or sh:NodeShape, or an IRI which refers to an instance of that type
+data Reference a =
+  ReferenceNamed Syntax.Iri |
+  -- | An anonymous instance
+  ReferenceAnonymous a |
+  -- | An inline definition
+  ReferenceDefinition (Definition a)
+  deriving (Eq, Ord, Read, Show)
+_Reference = Core.Name "hydra.shacl.model.Reference"
+_Reference_named = Core.Name "named"
+_Reference_anonymous = Core.Name "anonymous"
+_Reference_definition = Core.Name "definition"
+data Severity =
+  -- | A non-critical constraint violation indicating an informative message
+  SeverityInfo |
+  -- | A non-critical constraint violation indicating a warning
+  SeverityWarning |
+  -- | A constraint violation
+  SeverityViolation
+  deriving (Eq, Ord, Read, Show)
+_Severity = Core.Name "hydra.shacl.model.Severity"
+_Severity_info = Core.Name "info"
+_Severity_warning = Core.Name "warning"
+_Severity_violation = Core.Name "violation"
+-- | A SHACL node or property shape. See https://www.w3.org/TR/shacl/#shapes
+data Shape =
+  ShapeNode NodeShape |
+  ShapeProperty PropertyShape
+  deriving (Eq, Ord, Read, Show)
+_Shape = Core.Name "hydra.shacl.model.Shape"
+_Shape_node = Core.Name "node"
+_Shape_property = Core.Name "property"
+-- | An RDF graph containing zero or more shapes that is passed into a SHACL validation process so that a data graph can be validated against the shapes
+newtype ShapesGraph =
+  ShapesGraph {
+    unShapesGraph :: (S.Set (Definition Shape))}
+  deriving (Eq, Ord, Read, Show)
+_ShapesGraph = Core.Name "hydra.shacl.model.ShapesGraph"
diff --git a/src/main/haskell/Hydra/Shex/Syntax.hs b/src/main/haskell/Hydra/Shex/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Shex/Syntax.hs
@@ -0,0 +1,1068 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | A Shex model. Based on the BNF at:
+-- |   https://github.com/shexSpec/grammar/blob/master/bnf
+
+module Hydra.Shex.Syntax where
+import qualified Hydra.Core as Core
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+data ShexDoc =
+  ShexDoc {
+    shexDocListOfDirective :: [Directive],
+    shexDocSequence :: (Maybe ShexDoc_Sequence_Option),
+    shexDocPrefixDecl :: PrefixDecl}
+  deriving (Eq, Ord, Read, Show)
+_ShexDoc = Core.Name "hydra.shex.syntax.ShexDoc"
+_ShexDoc_listOfDirective = Core.Name "listOfDirective"
+_ShexDoc_Sequence = Core.Name "Sequence"
+_ShexDoc_PrefixDecl = Core.Name "PrefixDecl"
+data ShexDoc_Sequence_Option =
+  ShexDoc_Sequence_Option {
+    shexDoc_Sequence_OptionAlts :: ShexDoc_Sequence_Option_Alts,
+    shexDoc_Sequence_OptionListOfStatement :: [Statement]}
+  deriving (Eq, Ord, Read, Show)
+_ShexDoc_Sequence_Option = Core.Name "hydra.shex.syntax.ShexDoc_Sequence_Option"
+_ShexDoc_Sequence_Option_alts = Core.Name "alts"
+_ShexDoc_Sequence_Option_listOfStatement = Core.Name "listOfStatement"
+data ShexDoc_Sequence_Option_Alts =
+  ShexDoc_Sequence_Option_AltsNotStartAction NotStartAction |
+  ShexDoc_Sequence_Option_AltsStartActions StartActions
+  deriving (Eq, Ord, Read, Show)
+_ShexDoc_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.ShexDoc_Sequence_Option_Alts"
+_ShexDoc_Sequence_Option_Alts_NotStartAction = Core.Name "NotStartAction"
+_ShexDoc_Sequence_Option_Alts_StartActions = Core.Name "StartActions"
+data Directive =
+  DirectiveBaseDecl BaseDecl |
+  DirectivePrefixDecl PrefixDecl
+  deriving (Eq, Ord, Read, Show)
+_Directive = Core.Name "hydra.shex.syntax.Directive"
+_Directive_BaseDecl = Core.Name "BaseDecl"
+_Directive_PrefixDecl = Core.Name "PrefixDecl"
+newtype BaseDecl =
+  BaseDecl {
+    unBaseDecl :: IriRef}
+  deriving (Eq, Ord, Read, Show)
+_BaseDecl = Core.Name "hydra.shex.syntax.BaseDecl"
+data PrefixDecl =
+  PrefixDecl {
+    prefixDeclPnameNs :: PnameNs,
+    prefixDeclIriRef :: IriRef}
+  deriving (Eq, Ord, Read, Show)
+_PrefixDecl = Core.Name "hydra.shex.syntax.PrefixDecl"
+_PrefixDecl_PnameNs = Core.Name "PnameNs"
+_PrefixDecl_IriRef = Core.Name "IriRef"
+data NotStartAction =
+  NotStartActionStart ShapeExpression |
+  NotStartActionShapeExprDecl NotStartAction_ShapeExprDecl
+  deriving (Eq, Ord, Read, Show)
+_NotStartAction = Core.Name "hydra.shex.syntax.NotStartAction"
+_NotStartAction_start = Core.Name "start"
+_NotStartAction_shapeExprDecl = Core.Name "shapeExprDecl"
+data NotStartAction_ShapeExprDecl =
+  NotStartAction_ShapeExprDecl {
+    notStartAction_ShapeExprDeclShapeExprLabel :: ShapeExprLabel,
+    notStartAction_ShapeExprDeclAlts :: NotStartAction_ShapeExprDecl_Alts}
+  deriving (Eq, Ord, Read, Show)
+_NotStartAction_ShapeExprDecl = Core.Name "hydra.shex.syntax.NotStartAction_ShapeExprDecl"
+_NotStartAction_ShapeExprDecl_ShapeExprLabel = Core.Name "ShapeExprLabel"
+_NotStartAction_ShapeExprDecl_alts = Core.Name "alts"
+data NotStartAction_ShapeExprDecl_Alts =
+  NotStartAction_ShapeExprDecl_AltsShapeExpression ShapeExpression |
+  NotStartAction_ShapeExprDecl_AltsEXTERNAL
+  deriving (Eq, Ord, Read, Show)
+_NotStartAction_ShapeExprDecl_Alts = Core.Name "hydra.shex.syntax.NotStartAction_ShapeExprDecl_Alts"
+_NotStartAction_ShapeExprDecl_Alts_ShapeExpression = Core.Name "ShapeExpression"
+_NotStartAction_ShapeExprDecl_Alts_EXTERNAL = Core.Name "EXTERNAL"
+newtype StartActions =
+  StartActions {
+    unStartActions :: [CodeDecl]}
+  deriving (Eq, Ord, Read, Show)
+_StartActions = Core.Name "hydra.shex.syntax.StartActions"
+data Statement =
+  StatementDirective Directive |
+  StatementNotStartAction NotStartAction
+  deriving (Eq, Ord, Read, Show)
+_Statement = Core.Name "hydra.shex.syntax.Statement"
+_Statement_Directive = Core.Name "Directive"
+_Statement_NotStartAction = Core.Name "NotStartAction"
+newtype ShapeExpression =
+  ShapeExpression {
+    unShapeExpression :: ShapeOr}
+  deriving (Eq, Ord, Read, Show)
+_ShapeExpression = Core.Name "hydra.shex.syntax.ShapeExpression"
+newtype InlineShapeExpression =
+  InlineShapeExpression {
+    unInlineShapeExpression :: InlineShapeOr}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeExpression = Core.Name "hydra.shex.syntax.InlineShapeExpression"
+data ShapeOr =
+  ShapeOr {
+    shapeOrShapeAnd :: ShapeAnd,
+    shapeOrListOfSequence :: [ShapeAnd]}
+  deriving (Eq, Ord, Read, Show)
+_ShapeOr = Core.Name "hydra.shex.syntax.ShapeOr"
+_ShapeOr_ShapeAnd = Core.Name "ShapeAnd"
+_ShapeOr_listOfSequence = Core.Name "listOfSequence"
+data InlineShapeOr =
+  InlineShapeOr {
+    inlineShapeOrShapeAnd :: ShapeAnd,
+    inlineShapeOrListOfSequence :: [InlineShapeAnd]}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeOr = Core.Name "hydra.shex.syntax.InlineShapeOr"
+_InlineShapeOr_ShapeAnd = Core.Name "ShapeAnd"
+_InlineShapeOr_listOfSequence = Core.Name "listOfSequence"
+data ShapeAnd =
+  ShapeAnd {
+    shapeAndShapeNot :: ShapeNot,
+    shapeAndListOfSequence :: [ShapeNot]}
+  deriving (Eq, Ord, Read, Show)
+_ShapeAnd = Core.Name "hydra.shex.syntax.ShapeAnd"
+_ShapeAnd_ShapeNot = Core.Name "ShapeNot"
+_ShapeAnd_listOfSequence = Core.Name "listOfSequence"
+data InlineShapeAnd =
+  InlineShapeAnd {
+    inlineShapeAndInlineShapeNot :: InlineShapeNot,
+    inlineShapeAndListOfSequence :: [InlineShapeNot]}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeAnd = Core.Name "hydra.shex.syntax.InlineShapeAnd"
+_InlineShapeAnd_InlineShapeNot = Core.Name "InlineShapeNot"
+_InlineShapeAnd_listOfSequence = Core.Name "listOfSequence"
+data ShapeNot =
+  ShapeNot {
+    shapeNotNOT :: (Maybe ()),
+    shapeNotShapeAtom :: ShapeAtom}
+  deriving (Eq, Ord, Read, Show)
+_ShapeNot = Core.Name "hydra.shex.syntax.ShapeNot"
+_ShapeNot_NOT = Core.Name "NOT"
+_ShapeNot_ShapeAtom = Core.Name "ShapeAtom"
+data InlineShapeNot =
+  InlineShapeNot {
+    inlineShapeNotNOT :: (Maybe ()),
+    inlineShapeNotInlineShapeAtom :: InlineShapeAtom}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeNot = Core.Name "hydra.shex.syntax.InlineShapeNot"
+_InlineShapeNot_NOT = Core.Name "NOT"
+_InlineShapeNot_InlineShapeAtom = Core.Name "InlineShapeAtom"
+data ShapeAtom =
+  ShapeAtomSequence ShapeAtom_Sequence |
+  ShapeAtomShapeOrRef ShapeOrRef |
+  ShapeAtomSequence2 ShapeExpression |
+  ShapeAtomPeriod
+  deriving (Eq, Ord, Read, Show)
+_ShapeAtom = Core.Name "hydra.shex.syntax.ShapeAtom"
+_ShapeAtom_sequence = Core.Name "sequence"
+_ShapeAtom_ShapeOrRef = Core.Name "ShapeOrRef"
+_ShapeAtom_sequence2 = Core.Name "sequence2"
+_ShapeAtom_Period = Core.Name "Period"
+data ShapeAtom_Sequence =
+  ShapeAtom_Sequence {
+    shapeAtom_SequenceNodeConstraint :: NodeConstraint,
+    shapeAtom_SequenceShapeOrRef :: (Maybe ShapeOrRef)}
+  deriving (Eq, Ord, Read, Show)
+_ShapeAtom_Sequence = Core.Name "hydra.shex.syntax.ShapeAtom_Sequence"
+_ShapeAtom_Sequence_NodeConstraint = Core.Name "NodeConstraint"
+_ShapeAtom_Sequence_ShapeOrRef = Core.Name "ShapeOrRef"
+data InlineShapeAtom =
+  InlineShapeAtomSequence InlineShapeAtom_Sequence |
+  InlineShapeAtomSequence2 InlineShapeAtom_Sequence2 |
+  InlineShapeAtomSequence3 ShapeExpression |
+  InlineShapeAtomPeriod
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeAtom = Core.Name "hydra.shex.syntax.InlineShapeAtom"
+_InlineShapeAtom_sequence = Core.Name "sequence"
+_InlineShapeAtom_sequence2 = Core.Name "sequence2"
+_InlineShapeAtom_sequence3 = Core.Name "sequence3"
+_InlineShapeAtom_Period = Core.Name "Period"
+data InlineShapeAtom_Sequence =
+  InlineShapeAtom_Sequence {
+    inlineShapeAtom_SequenceNodeConstraint :: NodeConstraint,
+    inlineShapeAtom_SequenceInlineShapeOrRef :: (Maybe InlineShapeOrRef)}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeAtom_Sequence = Core.Name "hydra.shex.syntax.InlineShapeAtom_Sequence"
+_InlineShapeAtom_Sequence_NodeConstraint = Core.Name "NodeConstraint"
+_InlineShapeAtom_Sequence_InlineShapeOrRef = Core.Name "InlineShapeOrRef"
+data InlineShapeAtom_Sequence2 =
+  InlineShapeAtom_Sequence2 {
+    inlineShapeAtom_Sequence2InlineShapeOrRef :: InlineShapeOrRef,
+    inlineShapeAtom_Sequence2NodeConstraint :: (Maybe NodeConstraint)}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeAtom_Sequence2 = Core.Name "hydra.shex.syntax.InlineShapeAtom_Sequence2"
+_InlineShapeAtom_Sequence2_InlineShapeOrRef = Core.Name "InlineShapeOrRef"
+_InlineShapeAtom_Sequence2_NodeConstraint = Core.Name "NodeConstraint"
+data ShapeOrRef =
+  ShapeOrRefShapeDefinition ShapeDefinition |
+  ShapeOrRefAtpNameLn AtpNameLn |
+  ShapeOrRefAtpNameNs AtpNameNs |
+  ShapeOrRefSequence ShapeExprLabel
+  deriving (Eq, Ord, Read, Show)
+_ShapeOrRef = Core.Name "hydra.shex.syntax.ShapeOrRef"
+_ShapeOrRef_ShapeDefinition = Core.Name "ShapeDefinition"
+_ShapeOrRef_AtpNameLn = Core.Name "AtpNameLn"
+_ShapeOrRef_AtpNameNs = Core.Name "AtpNameNs"
+_ShapeOrRef_sequence = Core.Name "sequence"
+data InlineShapeOrRef =
+  InlineShapeOrRefInlineShapeDefinition InlineShapeDefinition |
+  InlineShapeOrRefAtpNameLn AtpNameLn |
+  InlineShapeOrRefAtpNameNs AtpNameNs |
+  InlineShapeOrRefSequence ShapeExprLabel
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeOrRef = Core.Name "hydra.shex.syntax.InlineShapeOrRef"
+_InlineShapeOrRef_InlineShapeDefinition = Core.Name "InlineShapeDefinition"
+_InlineShapeOrRef_AtpNameLn = Core.Name "AtpNameLn"
+_InlineShapeOrRef_AtpNameNs = Core.Name "AtpNameNs"
+_InlineShapeOrRef_sequence = Core.Name "sequence"
+data NodeConstraint =
+  NodeConstraintSequence [XsFacet] |
+  NodeConstraintSequence2 NodeConstraint_Sequence2 |
+  NodeConstraintSequence3 NodeConstraint_Sequence3 |
+  NodeConstraintSequence4 NodeConstraint_Sequence4 |
+  NodeConstraintSequence5 NodeConstraint_Sequence5 |
+  NodeConstraintListOfXsFacet [XsFacet]
+  deriving (Eq, Ord, Read, Show)
+_NodeConstraint = Core.Name "hydra.shex.syntax.NodeConstraint"
+_NodeConstraint_sequence = Core.Name "sequence"
+_NodeConstraint_sequence2 = Core.Name "sequence2"
+_NodeConstraint_sequence3 = Core.Name "sequence3"
+_NodeConstraint_sequence4 = Core.Name "sequence4"
+_NodeConstraint_sequence5 = Core.Name "sequence5"
+_NodeConstraint_listOfXsFacet = Core.Name "listOfXsFacet"
+data NodeConstraint_Sequence2 =
+  NodeConstraint_Sequence2 {
+    nodeConstraint_Sequence2NonLiteralKind :: NonLiteralKind,
+    nodeConstraint_Sequence2ListOfStringFacet :: [StringFacet]}
+  deriving (Eq, Ord, Read, Show)
+_NodeConstraint_Sequence2 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence2"
+_NodeConstraint_Sequence2_NonLiteralKind = Core.Name "NonLiteralKind"
+_NodeConstraint_Sequence2_listOfStringFacet = Core.Name "listOfStringFacet"
+data NodeConstraint_Sequence3 =
+  NodeConstraint_Sequence3 {
+    nodeConstraint_Sequence3Datatype :: Datatype,
+    nodeConstraint_Sequence3ListOfXsFacet :: [XsFacet]}
+  deriving (Eq, Ord, Read, Show)
+_NodeConstraint_Sequence3 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence3"
+_NodeConstraint_Sequence3_Datatype = Core.Name "Datatype"
+_NodeConstraint_Sequence3_listOfXsFacet = Core.Name "listOfXsFacet"
+data NodeConstraint_Sequence4 =
+  NodeConstraint_Sequence4 {
+    nodeConstraint_Sequence4ValueSet :: ValueSet,
+    nodeConstraint_Sequence4ListOfXsFacet :: [XsFacet]}
+  deriving (Eq, Ord, Read, Show)
+_NodeConstraint_Sequence4 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence4"
+_NodeConstraint_Sequence4_ValueSet = Core.Name "ValueSet"
+_NodeConstraint_Sequence4_listOfXsFacet = Core.Name "listOfXsFacet"
+data NodeConstraint_Sequence5 =
+  NodeConstraint_Sequence5 {
+    nodeConstraint_Sequence5ValueSet :: ValueSet,
+    nodeConstraint_Sequence5ListOfXsFacet :: [XsFacet]}
+  deriving (Eq, Ord, Read, Show)
+_NodeConstraint_Sequence5 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence5"
+_NodeConstraint_Sequence5_ValueSet = Core.Name "ValueSet"
+_NodeConstraint_Sequence5_listOfXsFacet = Core.Name "listOfXsFacet"
+data NonLiteralKind =
+  NonLiteralKindIRI |
+  NonLiteralKindBNODE |
+  NonLiteralKindNONLITERAL
+  deriving (Eq, Ord, Read, Show)
+_NonLiteralKind = Core.Name "hydra.shex.syntax.NonLiteralKind"
+_NonLiteralKind_IRI = Core.Name "IRI"
+_NonLiteralKind_BNODE = Core.Name "BNODE"
+_NonLiteralKind_NONLITERAL = Core.Name "NONLITERAL"
+data XsFacet =
+  XsFacetStringFacet StringFacet |
+  XsFacetNumericFacet NumericFacet
+  deriving (Eq, Ord, Read, Show)
+_XsFacet = Core.Name "hydra.shex.syntax.XsFacet"
+_XsFacet_StringFacet = Core.Name "StringFacet"
+_XsFacet_NumericFacet = Core.Name "NumericFacet"
+data StringFacet =
+  StringFacetSequence StringFacet_Sequence |
+  StringFacetRegexp Regexp
+  deriving (Eq, Ord, Read, Show)
+_StringFacet = Core.Name "hydra.shex.syntax.StringFacet"
+_StringFacet_sequence = Core.Name "sequence"
+_StringFacet_Regexp = Core.Name "Regexp"
+data StringFacet_Sequence =
+  StringFacet_Sequence {
+    stringFacet_SequenceStringLength :: StringLength,
+    stringFacet_SequenceInteger :: Integer_}
+  deriving (Eq, Ord, Read, Show)
+_StringFacet_Sequence = Core.Name "hydra.shex.syntax.StringFacet_Sequence"
+_StringFacet_Sequence_StringLength = Core.Name "StringLength"
+_StringFacet_Sequence_Integer = Core.Name "Integer"
+data StringLength =
+  StringLengthLENGTH |
+  StringLengthMINLENGTH |
+  StringLengthMAXLENGTH
+  deriving (Eq, Ord, Read, Show)
+_StringLength = Core.Name "hydra.shex.syntax.StringLength"
+_StringLength_LENGTH = Core.Name "LENGTH"
+_StringLength_MINLENGTH = Core.Name "MINLENGTH"
+_StringLength_MAXLENGTH = Core.Name "MAXLENGTH"
+data NumericFacet =
+  NumericFacetSequence NumericFacet_Sequence |
+  NumericFacetSequence2 NumericFacet_Sequence2
+  deriving (Eq, Ord, Read, Show)
+_NumericFacet = Core.Name "hydra.shex.syntax.NumericFacet"
+_NumericFacet_sequence = Core.Name "sequence"
+_NumericFacet_sequence2 = Core.Name "sequence2"
+data NumericFacet_Sequence =
+  NumericFacet_Sequence {
+    numericFacet_SequenceNumericRange :: NumericRange,
+    numericFacet_SequenceNumericLiteral :: NumericLiteral}
+  deriving (Eq, Ord, Read, Show)
+_NumericFacet_Sequence = Core.Name "hydra.shex.syntax.NumericFacet_Sequence"
+_NumericFacet_Sequence_NumericRange = Core.Name "NumericRange"
+_NumericFacet_Sequence_NumericLiteral = Core.Name "NumericLiteral"
+data NumericFacet_Sequence2 =
+  NumericFacet_Sequence2 {
+    numericFacet_Sequence2NumericLength :: NumericLength,
+    numericFacet_Sequence2Integer :: Integer_}
+  deriving (Eq, Ord, Read, Show)
+_NumericFacet_Sequence2 = Core.Name "hydra.shex.syntax.NumericFacet_Sequence2"
+_NumericFacet_Sequence2_NumericLength = Core.Name "NumericLength"
+_NumericFacet_Sequence2_Integer = Core.Name "Integer"
+data NumericRange =
+  NumericRangeMININCLUSIVE |
+  NumericRangeMINEXCLUSIVE |
+  NumericRangeMAXINCLUSIVE |
+  NumericRangeMAXEXCLUSIVE
+  deriving (Eq, Ord, Read, Show)
+_NumericRange = Core.Name "hydra.shex.syntax.NumericRange"
+_NumericRange_MININCLUSIVE = Core.Name "MININCLUSIVE"
+_NumericRange_MINEXCLUSIVE = Core.Name "MINEXCLUSIVE"
+_NumericRange_MAXINCLUSIVE = Core.Name "MAXINCLUSIVE"
+_NumericRange_MAXEXCLUSIVE = Core.Name "MAXEXCLUSIVE"
+data NumericLength =
+  NumericLengthTOTALDIGITS |
+  NumericLengthFRACTIONDIGITS
+  deriving (Eq, Ord, Read, Show)
+_NumericLength = Core.Name "hydra.shex.syntax.NumericLength"
+_NumericLength_TOTALDIGITS = Core.Name "TOTALDIGITS"
+_NumericLength_FRACTIONDIGITS = Core.Name "FRACTIONDIGITS"
+data ShapeDefinition =
+  ShapeDefinition {
+    shapeDefinitionListOfAlts :: [ShapeDefinition_ListOfAlts_Elmt],
+    shapeDefinitionTripleExpression :: (Maybe TripleExpression),
+    shapeDefinitionListOfAnnotation :: [Annotation],
+    shapeDefinitionSemanticActions :: SemanticActions}
+  deriving (Eq, Ord, Read, Show)
+_ShapeDefinition = Core.Name "hydra.shex.syntax.ShapeDefinition"
+_ShapeDefinition_listOfAlts = Core.Name "listOfAlts"
+_ShapeDefinition_TripleExpression = Core.Name "TripleExpression"
+_ShapeDefinition_listOfAnnotation = Core.Name "listOfAnnotation"
+_ShapeDefinition_SemanticActions = Core.Name "SemanticActions"
+data ShapeDefinition_ListOfAlts_Elmt =
+  ShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |
+  ShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |
+  ShapeDefinition_ListOfAlts_ElmtCLOSED
+  deriving (Eq, Ord, Read, Show)
+_ShapeDefinition_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.ShapeDefinition_ListOfAlts_Elmt"
+_ShapeDefinition_ListOfAlts_Elmt_IncludeSet = Core.Name "IncludeSet"
+_ShapeDefinition_ListOfAlts_Elmt_ExtraPropertySet = Core.Name "ExtraPropertySet"
+_ShapeDefinition_ListOfAlts_Elmt_CLOSED = Core.Name "CLOSED"
+data InlineShapeDefinition =
+  InlineShapeDefinition {
+    inlineShapeDefinitionListOfAlts :: [InlineShapeDefinition_ListOfAlts_Elmt],
+    inlineShapeDefinitionTripleExpression :: (Maybe TripleExpression)}
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeDefinition = Core.Name "hydra.shex.syntax.InlineShapeDefinition"
+_InlineShapeDefinition_listOfAlts = Core.Name "listOfAlts"
+_InlineShapeDefinition_TripleExpression = Core.Name "TripleExpression"
+data InlineShapeDefinition_ListOfAlts_Elmt =
+  InlineShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |
+  InlineShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |
+  InlineShapeDefinition_ListOfAlts_ElmtCLOSED
+  deriving (Eq, Ord, Read, Show)
+_InlineShapeDefinition_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.InlineShapeDefinition_ListOfAlts_Elmt"
+_InlineShapeDefinition_ListOfAlts_Elmt_IncludeSet = Core.Name "IncludeSet"
+_InlineShapeDefinition_ListOfAlts_Elmt_ExtraPropertySet = Core.Name "ExtraPropertySet"
+_InlineShapeDefinition_ListOfAlts_Elmt_CLOSED = Core.Name "CLOSED"
+newtype ExtraPropertySet =
+  ExtraPropertySet {
+    unExtraPropertySet :: [Predicate]}
+  deriving (Eq, Ord, Read, Show)
+_ExtraPropertySet = Core.Name "hydra.shex.syntax.ExtraPropertySet"
+newtype TripleExpression =
+  TripleExpression {
+    unTripleExpression :: OneOfTripleExpr}
+  deriving (Eq, Ord, Read, Show)
+_TripleExpression = Core.Name "hydra.shex.syntax.TripleExpression"
+data OneOfTripleExpr =
+  OneOfTripleExprGroupTripleExpr GroupTripleExpr |
+  OneOfTripleExprMultiElementOneOf MultiElementOneOf
+  deriving (Eq, Ord, Read, Show)
+_OneOfTripleExpr = Core.Name "hydra.shex.syntax.OneOfTripleExpr"
+_OneOfTripleExpr_GroupTripleExpr = Core.Name "GroupTripleExpr"
+_OneOfTripleExpr_MultiElementOneOf = Core.Name "MultiElementOneOf"
+data MultiElementOneOf =
+  MultiElementOneOf {
+    multiElementOneOfGroupTripleExpr :: GroupTripleExpr,
+    multiElementOneOfListOfSequence :: [GroupTripleExpr]}
+  deriving (Eq, Ord, Read, Show)
+_MultiElementOneOf = Core.Name "hydra.shex.syntax.MultiElementOneOf"
+_MultiElementOneOf_GroupTripleExpr = Core.Name "GroupTripleExpr"
+_MultiElementOneOf_listOfSequence = Core.Name "listOfSequence"
+data InnerTripleExpr =
+  InnerTripleExprMultiElementGroup MultiElementGroup |
+  InnerTripleExprMultiElementOneOf MultiElementOneOf
+  deriving (Eq, Ord, Read, Show)
+_InnerTripleExpr = Core.Name "hydra.shex.syntax.InnerTripleExpr"
+_InnerTripleExpr_MultiElementGroup = Core.Name "MultiElementGroup"
+_InnerTripleExpr_MultiElementOneOf = Core.Name "MultiElementOneOf"
+data GroupTripleExpr =
+  GroupTripleExprSingleElementGroup SingleElementGroup |
+  GroupTripleExprMultiElementGroup MultiElementGroup
+  deriving (Eq, Ord, Read, Show)
+_GroupTripleExpr = Core.Name "hydra.shex.syntax.GroupTripleExpr"
+_GroupTripleExpr_SingleElementGroup = Core.Name "SingleElementGroup"
+_GroupTripleExpr_MultiElementGroup = Core.Name "MultiElementGroup"
+data SingleElementGroup =
+  SingleElementGroup {
+    singleElementGroupUnaryTripleExpr :: UnaryTripleExpr,
+    singleElementGroupSemi :: (Maybe ())}
+  deriving (Eq, Ord, Read, Show)
+_SingleElementGroup = Core.Name "hydra.shex.syntax.SingleElementGroup"
+_SingleElementGroup_UnaryTripleExpr = Core.Name "UnaryTripleExpr"
+_SingleElementGroup_Semi = Core.Name "Semi"
+data MultiElementGroup =
+  MultiElementGroup {
+    multiElementGroupUnaryTripleExpr :: UnaryTripleExpr,
+    multiElementGroupListOfSequence :: [UnaryTripleExpr],
+    multiElementGroupSemi :: (Maybe ())}
+  deriving (Eq, Ord, Read, Show)
+_MultiElementGroup = Core.Name "hydra.shex.syntax.MultiElementGroup"
+_MultiElementGroup_UnaryTripleExpr = Core.Name "UnaryTripleExpr"
+_MultiElementGroup_listOfSequence = Core.Name "listOfSequence"
+_MultiElementGroup_Semi = Core.Name "Semi"
+data UnaryTripleExpr =
+  UnaryTripleExprSequence UnaryTripleExpr_Sequence |
+  UnaryTripleExprInclude Include
+  deriving (Eq, Ord, Read, Show)
+_UnaryTripleExpr = Core.Name "hydra.shex.syntax.UnaryTripleExpr"
+_UnaryTripleExpr_sequence = Core.Name "sequence"
+_UnaryTripleExpr_Include = Core.Name "Include"
+data UnaryTripleExpr_Sequence =
+  UnaryTripleExpr_Sequence {
+    unaryTripleExpr_SequenceSequence :: (Maybe TripleExprLabel),
+    unaryTripleExpr_SequenceAlts :: UnaryTripleExpr_Sequence_Alts}
+  deriving (Eq, Ord, Read, Show)
+_UnaryTripleExpr_Sequence = Core.Name "hydra.shex.syntax.UnaryTripleExpr_Sequence"
+_UnaryTripleExpr_Sequence_Sequence = Core.Name "Sequence"
+_UnaryTripleExpr_Sequence_alts = Core.Name "alts"
+data UnaryTripleExpr_Sequence_Alts =
+  UnaryTripleExpr_Sequence_AltsTripleConstraint TripleConstraint |
+  UnaryTripleExpr_Sequence_AltsBracketedTripleExpr BracketedTripleExpr
+  deriving (Eq, Ord, Read, Show)
+_UnaryTripleExpr_Sequence_Alts = Core.Name "hydra.shex.syntax.UnaryTripleExpr_Sequence_Alts"
+_UnaryTripleExpr_Sequence_Alts_TripleConstraint = Core.Name "TripleConstraint"
+_UnaryTripleExpr_Sequence_Alts_BracketedTripleExpr = Core.Name "BracketedTripleExpr"
+data BracketedTripleExpr =
+  BracketedTripleExpr {
+    bracketedTripleExprInnerTripleExpr :: InnerTripleExpr,
+    bracketedTripleExprCardinality :: (Maybe Cardinality),
+    bracketedTripleExprListOfAnnotation :: [Annotation],
+    bracketedTripleExprSemanticActions :: SemanticActions}
+  deriving (Eq, Ord, Read, Show)
+_BracketedTripleExpr = Core.Name "hydra.shex.syntax.BracketedTripleExpr"
+_BracketedTripleExpr_InnerTripleExpr = Core.Name "InnerTripleExpr"
+_BracketedTripleExpr_Cardinality = Core.Name "Cardinality"
+_BracketedTripleExpr_listOfAnnotation = Core.Name "listOfAnnotation"
+_BracketedTripleExpr_SemanticActions = Core.Name "SemanticActions"
+data TripleConstraint =
+  TripleConstraint {
+    tripleConstraintSenseFlags :: (Maybe SenseFlags),
+    tripleConstraintPredicate :: Predicate,
+    tripleConstraintInlineShapeExpression :: InlineShapeExpression,
+    tripleConstraintCardinality :: (Maybe Cardinality),
+    tripleConstraintListOfAnnotation :: [Annotation],
+    tripleConstraintSemanticActions :: SemanticActions}
+  deriving (Eq, Ord, Read, Show)
+_TripleConstraint = Core.Name "hydra.shex.syntax.TripleConstraint"
+_TripleConstraint_SenseFlags = Core.Name "SenseFlags"
+_TripleConstraint_Predicate = Core.Name "Predicate"
+_TripleConstraint_InlineShapeExpression = Core.Name "InlineShapeExpression"
+_TripleConstraint_Cardinality = Core.Name "Cardinality"
+_TripleConstraint_listOfAnnotation = Core.Name "listOfAnnotation"
+_TripleConstraint_SemanticActions = Core.Name "SemanticActions"
+data Cardinality =
+  CardinalityAst |
+  CardinalityPlus |
+  CardinalityQuest |
+  CardinalityRepeatRange RepeatRange
+  deriving (Eq, Ord, Read, Show)
+_Cardinality = Core.Name "hydra.shex.syntax.Cardinality"
+_Cardinality_Ast = Core.Name "Ast"
+_Cardinality_Plus = Core.Name "Plus"
+_Cardinality_Quest = Core.Name "Quest"
+_Cardinality_RepeatRange = Core.Name "RepeatRange"
+newtype SenseFlags =
+  SenseFlags {
+    unSenseFlags :: ()}
+  deriving (Eq, Ord, Read, Show)
+_SenseFlags = Core.Name "hydra.shex.syntax.SenseFlags"
+newtype ValueSet =
+  ValueSet {
+    unValueSet :: [ValueSetValue]}
+  deriving (Eq, Ord, Read, Show)
+_ValueSet = Core.Name "hydra.shex.syntax.ValueSet"
+data ValueSetValue =
+  ValueSetValueIriRange IriRange |
+  ValueSetValueLiteral Literal
+  deriving (Eq, Ord, Read, Show)
+_ValueSetValue = Core.Name "hydra.shex.syntax.ValueSetValue"
+_ValueSetValue_IriRange = Core.Name "IriRange"
+_ValueSetValue_Literal = Core.Name "Literal"
+data IriRange =
+  IriRangeSequence IriRange_Sequence |
+  IriRangeSequence2 [Exclusion]
+  deriving (Eq, Ord, Read, Show)
+_IriRange = Core.Name "hydra.shex.syntax.IriRange"
+_IriRange_sequence = Core.Name "sequence"
+_IriRange_sequence2 = Core.Name "sequence2"
+data IriRange_Sequence =
+  IriRange_Sequence {
+    iriRange_SequenceIri :: Iri,
+    iriRange_SequenceSequence :: (Maybe [Exclusion])}
+  deriving (Eq, Ord, Read, Show)
+_IriRange_Sequence = Core.Name "hydra.shex.syntax.IriRange_Sequence"
+_IriRange_Sequence_Iri = Core.Name "Iri"
+_IriRange_Sequence_Sequence = Core.Name "Sequence"
+newtype Exclusion =
+  Exclusion {
+    unExclusion :: Iri}
+  deriving (Eq, Ord, Read, Show)
+_Exclusion = Core.Name "hydra.shex.syntax.Exclusion"
+newtype Include =
+  Include {
+    unInclude :: TripleExprLabel}
+  deriving (Eq, Ord, Read, Show)
+_Include = Core.Name "hydra.shex.syntax.Include"
+data Annotation =
+  Annotation {
+    annotationPredicate :: Predicate,
+    annotationAlts :: Annotation_Alts}
+  deriving (Eq, Ord, Read, Show)
+_Annotation = Core.Name "hydra.shex.syntax.Annotation"
+_Annotation_Predicate = Core.Name "Predicate"
+_Annotation_alts = Core.Name "alts"
+data Annotation_Alts =
+  Annotation_AltsIri Iri |
+  Annotation_AltsLiteral Literal
+  deriving (Eq, Ord, Read, Show)
+_Annotation_Alts = Core.Name "hydra.shex.syntax.Annotation_Alts"
+_Annotation_Alts_Iri = Core.Name "Iri"
+_Annotation_Alts_Literal = Core.Name "Literal"
+newtype SemanticActions =
+  SemanticActions {
+    unSemanticActions :: [CodeDecl]}
+  deriving (Eq, Ord, Read, Show)
+_SemanticActions = Core.Name "hydra.shex.syntax.SemanticActions"
+data CodeDecl =
+  CodeDecl {
+    codeDeclIri :: Iri,
+    codeDeclAlts :: CodeDecl_Alts}
+  deriving (Eq, Ord, Read, Show)
+_CodeDecl = Core.Name "hydra.shex.syntax.CodeDecl"
+_CodeDecl_Iri = Core.Name "Iri"
+_CodeDecl_alts = Core.Name "alts"
+data CodeDecl_Alts =
+  CodeDecl_AltsCode Code |
+  CodeDecl_AltsPercnt
+  deriving (Eq, Ord, Read, Show)
+_CodeDecl_Alts = Core.Name "hydra.shex.syntax.CodeDecl_Alts"
+_CodeDecl_Alts_Code = Core.Name "Code"
+_CodeDecl_Alts_Percnt = Core.Name "Percnt"
+data Literal =
+  LiteralRdfLiteral RdfLiteral |
+  LiteralNumericLiteral NumericLiteral |
+  LiteralBooleanLiteral BooleanLiteral
+  deriving (Eq, Ord, Read, Show)
+_Literal = Core.Name "hydra.shex.syntax.Literal"
+_Literal_RdfLiteral = Core.Name "RdfLiteral"
+_Literal_NumericLiteral = Core.Name "NumericLiteral"
+_Literal_BooleanLiteral = Core.Name "BooleanLiteral"
+data Predicate =
+  PredicateIri Iri |
+  PredicateRdfType RdfType
+  deriving (Eq, Ord, Read, Show)
+_Predicate = Core.Name "hydra.shex.syntax.Predicate"
+_Predicate_Iri = Core.Name "Iri"
+_Predicate_RdfType = Core.Name "RdfType"
+newtype Datatype =
+  Datatype {
+    unDatatype :: Iri}
+  deriving (Eq, Ord, Read, Show)
+_Datatype = Core.Name "hydra.shex.syntax.Datatype"
+data ShapeExprLabel =
+  ShapeExprLabelIri Iri |
+  ShapeExprLabelBlankNode BlankNode
+  deriving (Eq, Ord, Read, Show)
+_ShapeExprLabel = Core.Name "hydra.shex.syntax.ShapeExprLabel"
+_ShapeExprLabel_Iri = Core.Name "Iri"
+_ShapeExprLabel_BlankNode = Core.Name "BlankNode"
+data TripleExprLabel =
+  TripleExprLabelIri Iri |
+  TripleExprLabelBlankNode BlankNode
+  deriving (Eq, Ord, Read, Show)
+_TripleExprLabel = Core.Name "hydra.shex.syntax.TripleExprLabel"
+_TripleExprLabel_Iri = Core.Name "Iri"
+_TripleExprLabel_BlankNode = Core.Name "BlankNode"
+data NumericLiteral =
+  NumericLiteralInteger Integer_ |
+  NumericLiteralDecimal Decimal |
+  NumericLiteralDouble Double_
+  deriving (Eq, Ord, Read, Show)
+_NumericLiteral = Core.Name "hydra.shex.syntax.NumericLiteral"
+_NumericLiteral_Integer = Core.Name "Integer"
+_NumericLiteral_Decimal = Core.Name "Decimal"
+_NumericLiteral_Double = Core.Name "Double"
+data RdfLiteral =
+  RdfLiteral {
+    rdfLiteralString :: String_,
+    rdfLiteralAlts :: (Maybe RdfLiteral_Alts_Option)}
+  deriving (Eq, Ord, Read, Show)
+_RdfLiteral = Core.Name "hydra.shex.syntax.RdfLiteral"
+_RdfLiteral_String = Core.Name "String"
+_RdfLiteral_Alts = Core.Name "Alts"
+data RdfLiteral_Alts_Option =
+  RdfLiteral_Alts_OptionLangTag LangTag |
+  RdfLiteral_Alts_OptionSequence Datatype
+  deriving (Eq, Ord, Read, Show)
+_RdfLiteral_Alts_Option = Core.Name "hydra.shex.syntax.RdfLiteral_Alts_Option"
+_RdfLiteral_Alts_Option_LangTag = Core.Name "LangTag"
+_RdfLiteral_Alts_Option_sequence = Core.Name "sequence"
+data BooleanLiteral =
+  BooleanLiteralTrue |
+  BooleanLiteralFalse
+  deriving (Eq, Ord, Read, Show)
+_BooleanLiteral = Core.Name "hydra.shex.syntax.BooleanLiteral"
+_BooleanLiteral_True = Core.Name "True"
+_BooleanLiteral_False = Core.Name "False"
+data String_ =
+  StringStringLiteral1 StringLiteral1 |
+  StringStringLiteralLong1 StringLiteralLong1 |
+  StringStringLiteral2 StringLiteral2 |
+  StringStringLiteralLong2 StringLiteralLong2
+  deriving (Eq, Ord, Read, Show)
+_String = Core.Name "hydra.shex.syntax.String"
+_String_StringLiteral1 = Core.Name "StringLiteral1"
+_String_StringLiteralLong1 = Core.Name "StringLiteralLong1"
+_String_StringLiteral2 = Core.Name "StringLiteral2"
+_String_StringLiteralLong2 = Core.Name "StringLiteralLong2"
+data Iri =
+  IriIriRef IriRef |
+  IriPrefixedName PrefixedName
+  deriving (Eq, Ord, Read, Show)
+_Iri = Core.Name "hydra.shex.syntax.Iri"
+_Iri_IriRef = Core.Name "IriRef"
+_Iri_PrefixedName = Core.Name "PrefixedName"
+data PrefixedName =
+  PrefixedNamePnameLn PnameLn |
+  PrefixedNamePnameNs PnameNs
+  deriving (Eq, Ord, Read, Show)
+_PrefixedName = Core.Name "hydra.shex.syntax.PrefixedName"
+_PrefixedName_PnameLn = Core.Name "PnameLn"
+_PrefixedName_PnameNs = Core.Name "PnameNs"
+newtype BlankNode =
+  BlankNode {
+    unBlankNode :: BlankNodeLabel}
+  deriving (Eq, Ord, Read, Show)
+_BlankNode = Core.Name "hydra.shex.syntax.BlankNode"
+newtype IncludeSet =
+  IncludeSet {
+    unIncludeSet :: [ShapeExprLabel]}
+  deriving (Eq, Ord, Read, Show)
+_IncludeSet = Core.Name "hydra.shex.syntax.IncludeSet"
+newtype Code =
+  Code {
+    unCode :: [Code_Elmt]}
+  deriving (Eq, Ord, Read, Show)
+_Code = Core.Name "hydra.shex.syntax.Code"
+data Code_Elmt =
+  Code_ElmtRegex String |
+  Code_ElmtSequence String |
+  Code_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_Code_Elmt = Core.Name "hydra.shex.syntax.Code_Elmt"
+_Code_Elmt_regex = Core.Name "regex"
+_Code_Elmt_sequence = Core.Name "sequence"
+_Code_Elmt_Uchar = Core.Name "Uchar"
+data RepeatRange =
+  RepeatRange {
+    repeatRangeInteger :: Integer_,
+    repeatRangeSequence :: (Maybe (Maybe (Maybe RepeatRange_Sequence_Option_Option_Option)))}
+  deriving (Eq, Ord, Read, Show)
+_RepeatRange = Core.Name "hydra.shex.syntax.RepeatRange"
+_RepeatRange_Integer = Core.Name "Integer"
+_RepeatRange_Sequence = Core.Name "Sequence"
+data RepeatRange_Sequence_Option_Option_Option =
+  RepeatRange_Sequence_Option_Option_OptionInteger Integer_ |
+  RepeatRange_Sequence_Option_Option_OptionAst
+  deriving (Eq, Ord, Read, Show)
+_RepeatRange_Sequence_Option_Option_Option = Core.Name "hydra.shex.syntax.RepeatRange_Sequence_Option_Option_Option"
+_RepeatRange_Sequence_Option_Option_Option_Integer = Core.Name "Integer"
+_RepeatRange_Sequence_Option_Option_Option_Ast = Core.Name "Ast"
+newtype RdfType =
+  RdfType {
+    unRdfType :: ()}
+  deriving (Eq, Ord, Read, Show)
+_RdfType = Core.Name "hydra.shex.syntax.RdfType"
+newtype IriRef =
+  IriRef {
+    unIriRef :: [IriRef_Elmt]}
+  deriving (Eq, Ord, Read, Show)
+_IriRef = Core.Name "hydra.shex.syntax.IriRef"
+data IriRef_Elmt =
+  IriRef_ElmtRegex String |
+  IriRef_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_IriRef_Elmt = Core.Name "hydra.shex.syntax.IriRef_Elmt"
+_IriRef_Elmt_regex = Core.Name "regex"
+_IriRef_Elmt_Uchar = Core.Name "Uchar"
+newtype PnameNs =
+  PnameNs {
+    unPnameNs :: (Maybe PnPrefix)}
+  deriving (Eq, Ord, Read, Show)
+_PnameNs = Core.Name "hydra.shex.syntax.PnameNs"
+data PnameLn =
+  PnameLn {
+    pnameLnPnameNs :: PnameNs,
+    pnameLnPnLocal :: PnLocal}
+  deriving (Eq, Ord, Read, Show)
+_PnameLn = Core.Name "hydra.shex.syntax.PnameLn"
+_PnameLn_PnameNs = Core.Name "PnameNs"
+_PnameLn_PnLocal = Core.Name "PnLocal"
+newtype AtpNameNs =
+  AtpNameNs {
+    unAtpNameNs :: (Maybe PnPrefix)}
+  deriving (Eq, Ord, Read, Show)
+_AtpNameNs = Core.Name "hydra.shex.syntax.AtpNameNs"
+data AtpNameLn =
+  AtpNameLn {
+    atpNameLnPnameNs :: PnameNs,
+    atpNameLnPnLocal :: PnLocal}
+  deriving (Eq, Ord, Read, Show)
+_AtpNameLn = Core.Name "hydra.shex.syntax.AtpNameLn"
+_AtpNameLn_PnameNs = Core.Name "PnameNs"
+_AtpNameLn_PnLocal = Core.Name "PnLocal"
+data Regexp =
+  Regexp {
+    regexpListOfAlts :: [Regexp_ListOfAlts_Elmt],
+    regexpListOfRegex :: [String]}
+  deriving (Eq, Ord, Read, Show)
+_Regexp = Core.Name "hydra.shex.syntax.Regexp"
+_Regexp_listOfAlts = Core.Name "listOfAlts"
+_Regexp_listOfRegex = Core.Name "listOfRegex"
+data Regexp_ListOfAlts_Elmt =
+  Regexp_ListOfAlts_ElmtRegex String |
+  Regexp_ListOfAlts_ElmtSequence String |
+  Regexp_ListOfAlts_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_Regexp_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.Regexp_ListOfAlts_Elmt"
+_Regexp_ListOfAlts_Elmt_regex = Core.Name "regex"
+_Regexp_ListOfAlts_Elmt_sequence = Core.Name "sequence"
+_Regexp_ListOfAlts_Elmt_Uchar = Core.Name "Uchar"
+data BlankNodeLabel =
+  BlankNodeLabel {
+    blankNodeLabelAlts :: BlankNodeLabel_Alts,
+    blankNodeLabelListOfAlts :: (Maybe [BlankNodeLabel_ListOfAlts_Option_Elmt]),
+    blankNodeLabelPnChars :: PnChars}
+  deriving (Eq, Ord, Read, Show)
+_BlankNodeLabel = Core.Name "hydra.shex.syntax.BlankNodeLabel"
+_BlankNodeLabel_alts = Core.Name "alts"
+_BlankNodeLabel_ListOfAlts = Core.Name "ListOfAlts"
+_BlankNodeLabel_PnChars = Core.Name "PnChars"
+data BlankNodeLabel_Alts =
+  BlankNodeLabel_AltsPnCharsU PnCharsU |
+  BlankNodeLabel_AltsRegex String
+  deriving (Eq, Ord, Read, Show)
+_BlankNodeLabel_Alts = Core.Name "hydra.shex.syntax.BlankNodeLabel_Alts"
+_BlankNodeLabel_Alts_PnCharsU = Core.Name "PnCharsU"
+_BlankNodeLabel_Alts_regex = Core.Name "regex"
+data BlankNodeLabel_ListOfAlts_Option_Elmt =
+  BlankNodeLabel_ListOfAlts_Option_ElmtPnChars PnChars |
+  BlankNodeLabel_ListOfAlts_Option_ElmtPeriod
+  deriving (Eq, Ord, Read, Show)
+_BlankNodeLabel_ListOfAlts_Option_Elmt = Core.Name "hydra.shex.syntax.BlankNodeLabel_ListOfAlts_Option_Elmt"
+_BlankNodeLabel_ListOfAlts_Option_Elmt_PnChars = Core.Name "PnChars"
+_BlankNodeLabel_ListOfAlts_Option_Elmt_Period = Core.Name "Period"
+newtype LangTag =
+  LangTag {
+    unLangTag :: String}
+  deriving (Eq, Ord, Read, Show)
+_LangTag = Core.Name "hydra.shex.syntax.LangTag"
+newtype Integer_ =
+  Integer_ {
+    unInteger :: String}
+  deriving (Eq, Ord, Read, Show)
+_Integer = Core.Name "hydra.shex.syntax.Integer"
+newtype Decimal =
+  Decimal {
+    unDecimal :: String}
+  deriving (Eq, Ord, Read, Show)
+_Decimal = Core.Name "hydra.shex.syntax.Decimal"
+newtype Double_ =
+  Double_ {
+    unDouble :: String}
+  deriving (Eq, Ord, Read, Show)
+_Double = Core.Name "hydra.shex.syntax.Double"
+newtype StringLiteral1 =
+  StringLiteral1 {
+    unStringLiteral1 :: [StringLiteral1_Elmt]}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteral1 = Core.Name "hydra.shex.syntax.StringLiteral1"
+data StringLiteral1_Elmt =
+  StringLiteral1_ElmtRegex String |
+  StringLiteral1_ElmtEchar Echar |
+  StringLiteral1_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_StringLiteral1_Elmt = Core.Name "hydra.shex.syntax.StringLiteral1_Elmt"
+_StringLiteral1_Elmt_regex = Core.Name "regex"
+_StringLiteral1_Elmt_Echar = Core.Name "Echar"
+_StringLiteral1_Elmt_Uchar = Core.Name "Uchar"
+newtype StringLiteral2 =
+  StringLiteral2 {
+    unStringLiteral2 :: [StringLiteral2_Elmt]}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteral2 = Core.Name "hydra.shex.syntax.StringLiteral2"
+data StringLiteral2_Elmt =
+  StringLiteral2_ElmtRegex String |
+  StringLiteral2_ElmtEchar Echar |
+  StringLiteral2_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_StringLiteral2_Elmt = Core.Name "hydra.shex.syntax.StringLiteral2_Elmt"
+_StringLiteral2_Elmt_regex = Core.Name "regex"
+_StringLiteral2_Elmt_Echar = Core.Name "Echar"
+_StringLiteral2_Elmt_Uchar = Core.Name "Uchar"
+newtype StringLiteralLong1 =
+  StringLiteralLong1 {
+    unStringLiteralLong1 :: [StringLiteralLong1_Elmt]}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong1 = Core.Name "hydra.shex.syntax.StringLiteralLong1"
+data StringLiteralLong1_Elmt =
+  StringLiteralLong1_ElmtSequence StringLiteralLong1_Elmt_Sequence |
+  StringLiteralLong1_ElmtEchar Echar |
+  StringLiteralLong1_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong1_Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt"
+_StringLiteralLong1_Elmt_sequence = Core.Name "sequence"
+_StringLiteralLong1_Elmt_Echar = Core.Name "Echar"
+_StringLiteralLong1_Elmt_Uchar = Core.Name "Uchar"
+data StringLiteralLong1_Elmt_Sequence =
+  StringLiteralLong1_Elmt_Sequence {
+    stringLiteralLong1_Elmt_SequenceAlts :: (Maybe StringLiteralLong1_Elmt_Sequence_Alts_Option),
+    stringLiteralLong1_Elmt_SequenceRegex :: String}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong1_Elmt_Sequence = Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence"
+_StringLiteralLong1_Elmt_Sequence_Alts = Core.Name "Alts"
+_StringLiteralLong1_Elmt_Sequence_regex = Core.Name "regex"
+data StringLiteralLong1_Elmt_Sequence_Alts_Option =
+  StringLiteralLong1_Elmt_Sequence_Alts_OptionApos |
+  StringLiteralLong1_Elmt_Sequence_Alts_OptionSequence StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong1_Elmt_Sequence_Alts_Option =
+    Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence_Alts_Option"
+_StringLiteralLong1_Elmt_Sequence_Alts_Option_Apos = Core.Name "Apos"
+_StringLiteralLong1_Elmt_Sequence_Alts_Option_sequence = Core.Name "sequence"
+data StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence =
+  StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence {}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence =
+    Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence"
+newtype StringLiteralLong2 =
+  StringLiteralLong2 {
+    unStringLiteralLong2 :: [StringLiteralLong2_Elmt]}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong2 = Core.Name "hydra.shex.syntax.StringLiteralLong2"
+data StringLiteralLong2_Elmt =
+  StringLiteralLong2_ElmtSequence StringLiteralLong2_Elmt_Sequence |
+  StringLiteralLong2_ElmtEchar Echar |
+  StringLiteralLong2_ElmtUchar Uchar
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong2_Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt"
+_StringLiteralLong2_Elmt_sequence = Core.Name "sequence"
+_StringLiteralLong2_Elmt_Echar = Core.Name "Echar"
+_StringLiteralLong2_Elmt_Uchar = Core.Name "Uchar"
+data StringLiteralLong2_Elmt_Sequence =
+  StringLiteralLong2_Elmt_Sequence {
+    stringLiteralLong2_Elmt_SequenceAlts :: (Maybe StringLiteralLong2_Elmt_Sequence_Alts_Option),
+    stringLiteralLong2_Elmt_SequenceRegex :: String}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong2_Elmt_Sequence = Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence"
+_StringLiteralLong2_Elmt_Sequence_Alts = Core.Name "Alts"
+_StringLiteralLong2_Elmt_Sequence_regex = Core.Name "regex"
+data StringLiteralLong2_Elmt_Sequence_Alts_Option =
+  StringLiteralLong2_Elmt_Sequence_Alts_OptionQuot |
+  StringLiteralLong2_Elmt_Sequence_Alts_OptionSequence StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong2_Elmt_Sequence_Alts_Option =
+    Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence_Alts_Option"
+_StringLiteralLong2_Elmt_Sequence_Alts_Option_Quot = Core.Name "Quot"
+_StringLiteralLong2_Elmt_Sequence_Alts_Option_sequence = Core.Name "sequence"
+data StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence =
+  StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence {}
+  deriving (Eq, Ord, Read, Show)
+_StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence =
+    Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence"
+data Uchar =
+  UcharSequence Uchar_Sequence |
+  UcharSequence2 Uchar_Sequence2
+  deriving (Eq, Ord, Read, Show)
+_Uchar = Core.Name "hydra.shex.syntax.Uchar"
+_Uchar_sequence = Core.Name "sequence"
+_Uchar_sequence2 = Core.Name "sequence2"
+data Uchar_Sequence =
+  Uchar_Sequence {
+    uchar_SequenceHex :: Hex,
+    uchar_SequenceHex2 :: Hex,
+    uchar_SequenceHex3 :: Hex,
+    uchar_SequenceHex4 :: Hex}
+  deriving (Eq, Ord, Read, Show)
+_Uchar_Sequence = Core.Name "hydra.shex.syntax.Uchar_Sequence"
+_Uchar_Sequence_Hex = Core.Name "Hex"
+_Uchar_Sequence_Hex2 = Core.Name "Hex2"
+_Uchar_Sequence_Hex3 = Core.Name "Hex3"
+_Uchar_Sequence_Hex4 = Core.Name "Hex4"
+data Uchar_Sequence2 =
+  Uchar_Sequence2 {
+    uchar_Sequence2Hex :: Hex,
+    uchar_Sequence2Hex2 :: Hex,
+    uchar_Sequence2Hex3 :: Hex,
+    uchar_Sequence2Hex4 :: Hex,
+    uchar_Sequence2Hex5 :: Hex,
+    uchar_Sequence2Hex6 :: Hex,
+    uchar_Sequence2Hex7 :: Hex,
+    uchar_Sequence2Hex8 :: Hex}
+  deriving (Eq, Ord, Read, Show)
+_Uchar_Sequence2 = Core.Name "hydra.shex.syntax.Uchar_Sequence2"
+_Uchar_Sequence2_Hex = Core.Name "Hex"
+_Uchar_Sequence2_Hex2 = Core.Name "Hex2"
+_Uchar_Sequence2_Hex3 = Core.Name "Hex3"
+_Uchar_Sequence2_Hex4 = Core.Name "Hex4"
+_Uchar_Sequence2_Hex5 = Core.Name "Hex5"
+_Uchar_Sequence2_Hex6 = Core.Name "Hex6"
+_Uchar_Sequence2_Hex7 = Core.Name "Hex7"
+_Uchar_Sequence2_Hex8 = Core.Name "Hex8"
+newtype Echar =
+  Echar {
+    unEchar :: String}
+  deriving (Eq, Ord, Read, Show)
+_Echar = Core.Name "hydra.shex.syntax.Echar"
+data PnCharsBase =
+  PnCharsBaseRegex String |
+  PnCharsBaseRegex2 String
+  deriving (Eq, Ord, Read, Show)
+_PnCharsBase = Core.Name "hydra.shex.syntax.PnCharsBase"
+_PnCharsBase_regex = Core.Name "regex"
+_PnCharsBase_regex2 = Core.Name "regex2"
+data PnCharsU =
+  PnCharsUPnCharsBase PnCharsBase |
+  PnCharsULowbar
+  deriving (Eq, Ord, Read, Show)
+_PnCharsU = Core.Name "hydra.shex.syntax.PnCharsU"
+_PnCharsU_PnCharsBase = Core.Name "PnCharsBase"
+_PnCharsU_Lowbar = Core.Name "Lowbar"
+data PnChars =
+  PnCharsPnCharsU PnCharsU |
+  PnCharsMinus |
+  PnCharsRegex String
+  deriving (Eq, Ord, Read, Show)
+_PnChars = Core.Name "hydra.shex.syntax.PnChars"
+_PnChars_PnCharsU = Core.Name "PnCharsU"
+_PnChars_Minus = Core.Name "Minus"
+_PnChars_regex = Core.Name "regex"
+data PnPrefix =
+  PnPrefix {
+    pnPrefixPnCharsBase :: PnCharsBase,
+    pnPrefixSequence :: (Maybe PnPrefix_Sequence_Option)}
+  deriving (Eq, Ord, Read, Show)
+_PnPrefix = Core.Name "hydra.shex.syntax.PnPrefix"
+_PnPrefix_PnCharsBase = Core.Name "PnCharsBase"
+_PnPrefix_Sequence = Core.Name "Sequence"
+data PnPrefix_Sequence_Option =
+  PnPrefix_Sequence_Option {
+    pnPrefix_Sequence_OptionAlts :: PnPrefix_Sequence_Option_Alts,
+    pnPrefix_Sequence_OptionPnChars :: PnChars}
+  deriving (Eq, Ord, Read, Show)
+_PnPrefix_Sequence_Option = Core.Name "hydra.shex.syntax.PnPrefix_Sequence_Option"
+_PnPrefix_Sequence_Option_alts = Core.Name "alts"
+_PnPrefix_Sequence_Option_PnChars = Core.Name "PnChars"
+data PnPrefix_Sequence_Option_Alts =
+  PnPrefix_Sequence_Option_AltsPnChars PnChars |
+  PnPrefix_Sequence_Option_AltsPeriod
+  deriving (Eq, Ord, Read, Show)
+_PnPrefix_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.PnPrefix_Sequence_Option_Alts"
+_PnPrefix_Sequence_Option_Alts_PnChars = Core.Name "PnChars"
+_PnPrefix_Sequence_Option_Alts_Period = Core.Name "Period"
+data PnLocal =
+  PnLocal {
+    pnLocalAlts :: PnLocal_Alts,
+    pnLocalSequence :: (Maybe PnLocal_Sequence_Option)}
+  deriving (Eq, Ord, Read, Show)
+_PnLocal = Core.Name "hydra.shex.syntax.PnLocal"
+_PnLocal_alts = Core.Name "alts"
+_PnLocal_Sequence = Core.Name "Sequence"
+data PnLocal_Alts =
+  PnLocal_AltsPnCharsU PnCharsU |
+  PnLocal_AltsColon |
+  PnLocal_AltsRegex String |
+  PnLocal_AltsPlx Plx
+  deriving (Eq, Ord, Read, Show)
+_PnLocal_Alts = Core.Name "hydra.shex.syntax.PnLocal_Alts"
+_PnLocal_Alts_PnCharsU = Core.Name "PnCharsU"
+_PnLocal_Alts_Colon = Core.Name "Colon"
+_PnLocal_Alts_regex = Core.Name "regex"
+_PnLocal_Alts_Plx = Core.Name "Plx"
+data PnLocal_Sequence_Option =
+  PnLocal_Sequence_Option {
+    pnLocal_Sequence_OptionListOfAlts :: [PnLocal_Sequence_Option_ListOfAlts_Elmt],
+    pnLocal_Sequence_OptionAlts :: PnLocal_Sequence_Option_Alts}
+  deriving (Eq, Ord, Read, Show)
+_PnLocal_Sequence_Option = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option"
+_PnLocal_Sequence_Option_listOfAlts = Core.Name "listOfAlts"
+_PnLocal_Sequence_Option_alts = Core.Name "alts"
+data PnLocal_Sequence_Option_ListOfAlts_Elmt =
+  PnLocal_Sequence_Option_ListOfAlts_ElmtPnChars PnChars |
+  PnLocal_Sequence_Option_ListOfAlts_ElmtPeriod |
+  PnLocal_Sequence_Option_ListOfAlts_ElmtColon |
+  PnLocal_Sequence_Option_ListOfAlts_ElmtPlx Plx
+  deriving (Eq, Ord, Read, Show)
+_PnLocal_Sequence_Option_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option_ListOfAlts_Elmt"
+_PnLocal_Sequence_Option_ListOfAlts_Elmt_PnChars = Core.Name "PnChars"
+_PnLocal_Sequence_Option_ListOfAlts_Elmt_Period = Core.Name "Period"
+_PnLocal_Sequence_Option_ListOfAlts_Elmt_Colon = Core.Name "Colon"
+_PnLocal_Sequence_Option_ListOfAlts_Elmt_Plx = Core.Name "Plx"
+data PnLocal_Sequence_Option_Alts =
+  PnLocal_Sequence_Option_AltsPnChars PnChars |
+  PnLocal_Sequence_Option_AltsColon |
+  PnLocal_Sequence_Option_AltsPlx Plx
+  deriving (Eq, Ord, Read, Show)
+_PnLocal_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option_Alts"
+_PnLocal_Sequence_Option_Alts_PnChars = Core.Name "PnChars"
+_PnLocal_Sequence_Option_Alts_Colon = Core.Name "Colon"
+_PnLocal_Sequence_Option_Alts_Plx = Core.Name "Plx"
+data Plx =
+  PlxPercent Percent |
+  PlxPnLocalEsc PnLocalEsc
+  deriving (Eq, Ord, Read, Show)
+_Plx = Core.Name "hydra.shex.syntax.Plx"
+_Plx_Percent = Core.Name "Percent"
+_Plx_PnLocalEsc = Core.Name "PnLocalEsc"
+data Percent =
+  Percent {
+    percentHex :: Hex,
+    percentHex2 :: Hex}
+  deriving (Eq, Ord, Read, Show)
+_Percent = Core.Name "hydra.shex.syntax.Percent"
+_Percent_Hex = Core.Name "Hex"
+_Percent_Hex2 = Core.Name "Hex2"
+newtype Hex =
+  Hex {
+    unHex :: String}
+  deriving (Eq, Ord, Read, Show)
+_Hex = Core.Name "hydra.shex.syntax.Hex"
+newtype PnLocalEsc =
+  PnLocalEsc {
+    unPnLocalEsc :: String}
+  deriving (Eq, Ord, Read, Show)
+_PnLocalEsc = Core.Name "hydra.shex.syntax.PnLocalEsc"
diff --git a/src/main/haskell/Hydra/Xml/Schema.hs b/src/main/haskell/Hydra/Xml/Schema.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Xml/Schema.hs
@@ -0,0 +1,329 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | A partial XML Schema model, focusing on datatypes. All simple datatypes (i.e. xsd:anySimpleType and below) are included.
+-- | See: https://www.w3.org/TR/xmlschema-2
+-- | Note: for most of the XML Schema datatype definitions included here, the associated Hydra type is simply
+-- |       the string type. Exceptions are made for xsd:boolean and most of the numeric types, where there is a clearly
+-- |       corresponding Hydra literal type.
+
+module Hydra.Xml.Schema where
+import qualified Hydra.Core as Core
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Int as I
+newtype AnySimpleType =
+  AnySimpleType {
+    unAnySimpleType :: String}
+  deriving (Eq, Ord, Read, Show)
+_AnySimpleType = Core.Name "hydra.xml.schema.AnySimpleType"
+newtype AnyType =
+  AnyType {
+    unAnyType :: String}
+  deriving (Eq, Ord, Read, Show)
+_AnyType = Core.Name "hydra.xml.schema.AnyType"
+newtype AnyURI =
+  AnyURI {
+    unAnyURI :: String}
+  deriving (Eq, Ord, Read, Show)
+_AnyURI = Core.Name "hydra.xml.schema.AnyURI"
+newtype Base64Binary =
+  Base64Binary {
+    unBase64Binary :: String}
+  deriving (Eq, Ord, Read, Show)
+_Base64Binary = Core.Name "hydra.xml.schema.Base64Binary"
+newtype Boolean =
+  Boolean {
+    unBoolean :: Bool}
+  deriving (Eq, Ord, Read, Show)
+_Boolean = Core.Name "hydra.xml.schema.Boolean"
+newtype Byte =
+  Byte {
+    unByte :: I.Int8}
+  deriving (Eq, Ord, Read, Show)
+_Byte = Core.Name "hydra.xml.schema.Byte"
+newtype Date =
+  Date {
+    unDate :: String}
+  deriving (Eq, Ord, Read, Show)
+_Date = Core.Name "hydra.xml.schema.Date"
+newtype DateTime =
+  DateTime {
+    unDateTime :: String}
+  deriving (Eq, Ord, Read, Show)
+_DateTime = Core.Name "hydra.xml.schema.DateTime"
+newtype Decimal =
+  Decimal {
+    unDecimal :: String}
+  deriving (Eq, Ord, Read, Show)
+_Decimal = Core.Name "hydra.xml.schema.Decimal"
+newtype Double_ =
+  Double_ {
+    unDouble :: Double}
+  deriving (Eq, Ord, Read, Show)
+_Double = Core.Name "hydra.xml.schema.Double"
+newtype Duration =
+  Duration {
+    unDuration :: String}
+  deriving (Eq, Ord, Read, Show)
+_Duration = Core.Name "hydra.xml.schema.Duration"
+newtype ENTITIES =
+  ENTITIES {
+    unENTITIES :: String}
+  deriving (Eq, Ord, Read, Show)
+_ENTITIES = Core.Name "hydra.xml.schema.ENTITIES"
+newtype ENTITY =
+  ENTITY {
+    unENTITY :: String}
+  deriving (Eq, Ord, Read, Show)
+_ENTITY = Core.Name "hydra.xml.schema.ENTITY"
+newtype Float_ =
+  Float_ {
+    unFloat :: Float}
+  deriving (Eq, Ord, Read, Show)
+_Float = Core.Name "hydra.xml.schema.Float"
+newtype GDay =
+  GDay {
+    unGDay :: String}
+  deriving (Eq, Ord, Read, Show)
+_GDay = Core.Name "hydra.xml.schema.GDay"
+newtype GMonth =
+  GMonth {
+    unGMonth :: String}
+  deriving (Eq, Ord, Read, Show)
+_GMonth = Core.Name "hydra.xml.schema.GMonth"
+newtype GMonthDay =
+  GMonthDay {
+    unGMonthDay :: String}
+  deriving (Eq, Ord, Read, Show)
+_GMonthDay = Core.Name "hydra.xml.schema.GMonthDay"
+newtype GYear =
+  GYear {
+    unGYear :: String}
+  deriving (Eq, Ord, Read, Show)
+_GYear = Core.Name "hydra.xml.schema.GYear"
+newtype GYearMonth =
+  GYearMonth {
+    unGYearMonth :: String}
+  deriving (Eq, Ord, Read, Show)
+_GYearMonth = Core.Name "hydra.xml.schema.GYearMonth"
+newtype HexBinary =
+  HexBinary {
+    unHexBinary :: String}
+  deriving (Eq, Ord, Read, Show)
+_HexBinary = Core.Name "hydra.xml.schema.HexBinary"
+newtype ID =
+  ID {
+    unID :: String}
+  deriving (Eq, Ord, Read, Show)
+_ID = Core.Name "hydra.xml.schema.ID"
+newtype IDREF =
+  IDREF {
+    unIDREF :: String}
+  deriving (Eq, Ord, Read, Show)
+_IDREF = Core.Name "hydra.xml.schema.IDREF"
+newtype IDREFS =
+  IDREFS {
+    unIDREFS :: String}
+  deriving (Eq, Ord, Read, Show)
+_IDREFS = Core.Name "hydra.xml.schema.IDREFS"
+newtype Int_ =
+  Int_ {
+    unInt :: Int}
+  deriving (Eq, Ord, Read, Show)
+_Int = Core.Name "hydra.xml.schema.Int"
+newtype Integer_ =
+  Integer_ {
+    unInteger :: Integer}
+  deriving (Eq, Ord, Read, Show)
+_Integer = Core.Name "hydra.xml.schema.Integer"
+newtype Language =
+  Language {
+    unLanguage :: String}
+  deriving (Eq, Ord, Read, Show)
+_Language = Core.Name "hydra.xml.schema.Language"
+newtype Long =
+  Long {
+    unLong :: I.Int64}
+  deriving (Eq, Ord, Read, Show)
+_Long = Core.Name "hydra.xml.schema.Long"
+newtype NMTOKEN =
+  NMTOKEN {
+    unNMTOKEN :: String}
+  deriving (Eq, Ord, Read, Show)
+_NMTOKEN = Core.Name "hydra.xml.schema.NMTOKEN"
+newtype NOTATION =
+  NOTATION {
+    unNOTATION :: String}
+  deriving (Eq, Ord, Read, Show)
+_NOTATION = Core.Name "hydra.xml.schema.NOTATION"
+newtype Name =
+  Name {
+    unName :: String}
+  deriving (Eq, Ord, Read, Show)
+_Name = Core.Name "hydra.xml.schema.Name"
+newtype NegativeInteger =
+  NegativeInteger {
+    unNegativeInteger :: Integer}
+  deriving (Eq, Ord, Read, Show)
+_NegativeInteger = Core.Name "hydra.xml.schema.NegativeInteger"
+newtype NonNegativeInteger =
+  NonNegativeInteger {
+    unNonNegativeInteger :: Integer}
+  deriving (Eq, Ord, Read, Show)
+_NonNegativeInteger = Core.Name "hydra.xml.schema.NonNegativeInteger"
+newtype NonPositiveInteger =
+  NonPositiveInteger {
+    unNonPositiveInteger :: Integer}
+  deriving (Eq, Ord, Read, Show)
+_NonPositiveInteger = Core.Name "hydra.xml.schema.NonPositiveInteger"
+newtype NormalizedString =
+  NormalizedString {
+    unNormalizedString :: String}
+  deriving (Eq, Ord, Read, Show)
+_NormalizedString = Core.Name "hydra.xml.schema.NormalizedString"
+newtype PositiveInteger =
+  PositiveInteger {
+    unPositiveInteger :: Integer}
+  deriving (Eq, Ord, Read, Show)
+_PositiveInteger = Core.Name "hydra.xml.schema.PositiveInteger"
+newtype QName =
+  QName {
+    unQName :: String}
+  deriving (Eq, Ord, Read, Show)
+_QName = Core.Name "hydra.xml.schema.QName"
+newtype Short =
+  Short {
+    unShort :: I.Int16}
+  deriving (Eq, Ord, Read, Show)
+_Short = Core.Name "hydra.xml.schema.Short"
+newtype String_ =
+  String_ {
+    unString :: String}
+  deriving (Eq, Ord, Read, Show)
+_String = Core.Name "hydra.xml.schema.String"
+newtype Time =
+  Time {
+    unTime :: String}
+  deriving (Eq, Ord, Read, Show)
+_Time = Core.Name "hydra.xml.schema.Time"
+newtype Token =
+  Token {
+    unToken :: String}
+  deriving (Eq, Ord, Read, Show)
+_Token = Core.Name "hydra.xml.schema.Token"
+newtype UnsignedByte =
+  UnsignedByte {
+    unUnsignedByte :: I.Int16}
+  deriving (Eq, Ord, Read, Show)
+_UnsignedByte = Core.Name "hydra.xml.schema.UnsignedByte"
+newtype UnsignedInt =
+  UnsignedInt {
+    unUnsignedInt :: I.Int64}
+  deriving (Eq, Ord, Read, Show)
+_UnsignedInt = Core.Name "hydra.xml.schema.UnsignedInt"
+newtype UnsignedLong =
+  UnsignedLong {
+    unUnsignedLong :: Integer}
+  deriving (Eq, Ord, Read, Show)
+_UnsignedLong = Core.Name "hydra.xml.schema.UnsignedLong"
+newtype UnsignedShort =
+  UnsignedShort {
+    unUnsignedShort :: Int}
+  deriving (Eq, Ord, Read, Show)
+_UnsignedShort = Core.Name "hydra.xml.schema.UnsignedShort"
+-- | See https://www.w3.org/TR/xmlschema-2/#non-fundamental
+newtype ConstrainingFacet =
+  ConstrainingFacet {
+    unConstrainingFacet :: ()}
+  deriving (Eq, Ord, Read, Show)
+_ConstrainingFacet = Core.Name "hydra.xml.schema.ConstrainingFacet"
+data Datatype =
+  DatatypeAnySimpleType |
+  DatatypeAnyType |
+  DatatypeAnyURI |
+  DatatypeBase64Binary |
+  DatatypeBoolean |
+  DatatypeByte |
+  DatatypeDate |
+  DatatypeDateTime |
+  DatatypeDecimal |
+  DatatypeDouble |
+  DatatypeDuration |
+  DatatypeENTITIES |
+  DatatypeENTITY |
+  DatatypeFloat |
+  DatatypeGDay |
+  DatatypeGMonth |
+  DatatypeGMonthDay |
+  DatatypeGYear |
+  DatatypeGYearMonth |
+  DatatypeHexBinary |
+  DatatypeID |
+  DatatypeIDREF |
+  DatatypeIDREFS |
+  DatatypeInt |
+  DatatypeInteger |
+  DatatypeLanguage |
+  DatatypeLong |
+  DatatypeNMTOKEN |
+  DatatypeNOTATION |
+  DatatypeName |
+  DatatypeNegativeInteger |
+  DatatypeNonNegativeInteger |
+  DatatypeNonPositiveInteger |
+  DatatypeNormalizedString |
+  DatatypePositiveInteger |
+  DatatypeQName |
+  DatatypeShort |
+  DatatypeString |
+  DatatypeTime |
+  DatatypeToken |
+  DatatypeUnsignedByte |
+  DatatypeUnsignedInt |
+  DatatypeUnsignedLong |
+  DatatypeUnsignedShort
+  deriving (Eq, Ord, Read, Show)
+_Datatype = Core.Name "hydra.xml.schema.Datatype"
+_Datatype_anySimpleType = Core.Name "anySimpleType"
+_Datatype_anyType = Core.Name "anyType"
+_Datatype_anyURI = Core.Name "anyURI"
+_Datatype_base64Binary = Core.Name "base64Binary"
+_Datatype_boolean = Core.Name "boolean"
+_Datatype_byte = Core.Name "byte"
+_Datatype_date = Core.Name "date"
+_Datatype_dateTime = Core.Name "dateTime"
+_Datatype_decimal = Core.Name "decimal"
+_Datatype_double = Core.Name "double"
+_Datatype_duration = Core.Name "duration"
+_Datatype_ENTITIES = Core.Name "ENTITIES"
+_Datatype_ENTITY = Core.Name "ENTITY"
+_Datatype_float = Core.Name "float"
+_Datatype_gDay = Core.Name "gDay"
+_Datatype_gMonth = Core.Name "gMonth"
+_Datatype_gMonthDay = Core.Name "gMonthDay"
+_Datatype_gYear = Core.Name "gYear"
+_Datatype_gYearMonth = Core.Name "gYearMonth"
+_Datatype_hexBinary = Core.Name "hexBinary"
+_Datatype_ID = Core.Name "ID"
+_Datatype_IDREF = Core.Name "IDREF"
+_Datatype_IDREFS = Core.Name "IDREFS"
+_Datatype_int = Core.Name "int"
+_Datatype_integer = Core.Name "integer"
+_Datatype_language = Core.Name "language"
+_Datatype_long = Core.Name "long"
+_Datatype_NMTOKEN = Core.Name "NMTOKEN"
+_Datatype_NOTATION = Core.Name "NOTATION"
+_Datatype_name = Core.Name "name"
+_Datatype_negativeInteger = Core.Name "negativeInteger"
+_Datatype_nonNegativeInteger = Core.Name "nonNegativeInteger"
+_Datatype_nonPositiveInteger = Core.Name "nonPositiveInteger"
+_Datatype_normalizedString = Core.Name "normalizedString"
+_Datatype_positiveInteger = Core.Name "positiveInteger"
+_Datatype_qName = Core.Name "qName"
+_Datatype_short = Core.Name "short"
+_Datatype_string = Core.Name "string"
+_Datatype_time = Core.Name "time"
+_Datatype_token = Core.Name "token"
+_Datatype_unsignedByte = Core.Name "unsignedByte"
+_Datatype_unsignedInt = Core.Name "unsignedInt"
+_Datatype_unsignedLong = Core.Name "unsignedLong"
+_Datatype_unsignedShort = Core.Name "unsignedShort"