oapi-profile-builder 3.4.1__tar.gz → 3.5.0__tar.gz

{oapi_profile_builder-3.4.1/src/oapi_profile_builder.egg-info → oapi_profile_builder-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oapi-profile-builder
-Version: 3.4.1
+Version: 3.5.0
 Summary: Authoritative tooling for creating OGC API Service Profiles (EDR, Features)
 Author-email: Shane Mill <shane.mill@noaa.gov>
 License: Apache License
@@ -342,6 +342,13 @@ abstract_tests: []
 | `spec_uri_base` | string | no | Base URI for the requirements/conformance class identifiers. Defaults to the OGC EDR Part 3 namespace; override to publish under another SDO namespace (e.g. DGIWG) |
 | `parameter_name_pattern` | string | no | Regex all `parameter_names` keys must match |
 | `parameter_schema` | object | no | JSON Schema for parameter objects — replaces the default schema in the generated OpenAPI (see below) |
+| `collection_title_max_length` | int | no | When set, every collection title must be present and within this many characters (MetOcean `/req/core/collection_title`) |
+| `require_license_link` | bool | no | When `true`, every collection must declare a `rel='license'` link (MetOcean `/req/core/collection_license`). Defaults to `false` |
+| `license_link_type` | string | no | Expected media type of the `rel='license'` link when `require_license_link` is set. Defaults to `text/html`; set to null to accept any type |
+| `required_data_queries` | list | no | Data-query types every collection must define (e.g. `[locations, area, radius]`) — enforces the mandatory data-query sets |
+| `radius_within_units_required` | list | no | Unit tokens each radius query's `within_units` must contain (e.g. `[m]`) (MetOcean `/req/core/collection_radius_data_query`) |
+| `locations_feature_required_properties` | list | no | Feature properties (e.g. `[name]`) marked required in the generated `/locations` GeoJSON response schema, in addition to the always-required string `id` |
+| `conformance_class_requirements` | object | no | Map of conformance-class short name → constraints (`required_data_queries`, `radius_within_units_required`) applied only to collections that declare the class. Lets one profile document model several EDR Part 3 requirements classes (see below) |
 | `processes` | list | no | OGC API Processes to expose in the OpenAPI |
 | `requirements` | list | no | Normative requirements for the AsciiDoc/PDF |
 | `abstract_tests` | list | no | Conformance tests — each must reference a valid requirement `id` |
@@ -381,6 +388,8 @@ Uses the [edr-pydantic](https://github.com/KNMI/edr-pydantic) `Collection` model
 | `output_formats` | no | Format names this collection supports (e.g. `[CoverageJSON, GeoJSON]`) |
 | `data_queries` | no | EDR query types: `position`, `area`, `radius`, `cube`, `trajectory`, `corridor`, `locations`, `items`, `instances` |
 | `parameter_names` | no | Map of parameter id → Parameter object. All parameters must have `unit` and `observedProperty` |
+| `conformance_classes` | no | Profile conformance-class short names this collection implements (e.g. `[core, insitu-observations]`). Selects which `conformance_class_requirements` are enforced; surfaced as `x-conformance-classes` in the OpenAPI |
+| `parameter_schema` | no | Per-collection JSON Schema for parameter objects, overriding the profile-level `parameter_schema` for this collection only (precedence: collection → profile → default) |
 
 #### `data_queries` example
 
@@ -513,6 +522,38 @@ extent_requirements:
 
 ---
 
+### Multiple conformance classes in one profile
+
+OGC API - EDR Part 3 profiles are modular: a single profile document can define several requirements/conformance classes, and different collections in the same service may implement different classes. The MetOcean EDR Profile is a good example — Core applies everywhere, but only in-situ collections must offer `locations`/`area`/`radius` while NWP collections must offer `position`/`cube`.
+
+Model this with `conformance_class_requirements` (profile level) plus `conformance_classes` (per collection):
+
+```yaml
+# Core-level rules apply to every collection:
+collection_title_max_length: 50
+require_license_link: true
+
+# Class-scoped rules apply only where a collection opts in:
+conformance_class_requirements:
+  insitu-observations:
+    required_data_queries: [locations, area, radius]
+    radius_within_units_required: [m]
+  nwp:
+    required_data_queries: [position, cube]
+
+collections:
+  - id: insitu-observations
+    conformance_classes: [core, insitu-observations]   # must have locations/area/radius
+    # ...
+  - id: nwp-forecast
+    conformance_classes: [core, nwp]                    # must have position/cube
+    # ...
+```
+
+The flat `required_data_queries` / `radius_within_units_required` fields still apply to *every* collection (the Core-applies-to-all shorthand); class-scoped rules are additive. See `examples/metocean_profile.yaml` for a full worked profile spanning all four MetOcean classes.
+
+---
+
 ### `output_formats`
 
 Maps format names (referenced by `collections[].output_formats` and `data_queries.*.variables.output_formats`) to a media type and, optionally, a schema reference. The `schema_ref` flows into the generated OpenAPI response `content` for that format — use it to point a format at a specific schema (e.g. a DGIWG-published schema for GeoTIFF or CoverageJSON) instead of the tool's built-in default.
@@ -898,6 +939,12 @@ The tool enforces these rules at build time. Violations produce clear error mess
 | Parameters need `unit` + `observedProperty` | Required by OGC API - EDR Part 3 |
 | `parameter_name_pattern` enforced | All `parameter_names` keys must match if set |
 | `collection_id_pattern` enforced | All collection IDs must match if set |
+| `collection_title_max_length` enforced | If set, every collection title must be present and within the limit |
+| `require_license_link` enforced | If set, every collection must have a `rel='license'` link (of `license_link_type` when specified) |
+| `required_data_queries` enforced | If set, every collection with `data_queries` must define each listed query type |
+| `radius_within_units_required` enforced | If set, each radius query's `within_units` must contain every listed unit token |
+| `conformance_class_requirements` enforced | Class-scoped `required_data_queries` / `radius_within_units_required` applied to collections whose `conformance_classes` include the class key |
+| `conformance_classes` references known class | When `conformance_class_requirements` is set, a collection's `conformance_classes` may only use `core` or a defined class key (catches typos) |
 | Abstract test IDs match requirements | `requirement_id` must reference an existing requirement |
 | Requirement IDs | Must match `^[a-z0-9][a-z0-9\-]*$`, no trailing hyphen |
 

{oapi_profile_builder-3.4.1 → oapi_profile_builder-3.5.0}/README.md

@@ -295,6 +295,13 @@ abstract_tests: []
 | `spec_uri_base` | string | no | Base URI for the requirements/conformance class identifiers. Defaults to the OGC EDR Part 3 namespace; override to publish under another SDO namespace (e.g. DGIWG) |
 | `parameter_name_pattern` | string | no | Regex all `parameter_names` keys must match |
 | `parameter_schema` | object | no | JSON Schema for parameter objects — replaces the default schema in the generated OpenAPI (see below) |
+| `collection_title_max_length` | int | no | When set, every collection title must be present and within this many characters (MetOcean `/req/core/collection_title`) |
+| `require_license_link` | bool | no | When `true`, every collection must declare a `rel='license'` link (MetOcean `/req/core/collection_license`). Defaults to `false` |
+| `license_link_type` | string | no | Expected media type of the `rel='license'` link when `require_license_link` is set. Defaults to `text/html`; set to null to accept any type |
+| `required_data_queries` | list | no | Data-query types every collection must define (e.g. `[locations, area, radius]`) — enforces the mandatory data-query sets |
+| `radius_within_units_required` | list | no | Unit tokens each radius query's `within_units` must contain (e.g. `[m]`) (MetOcean `/req/core/collection_radius_data_query`) |
+| `locations_feature_required_properties` | list | no | Feature properties (e.g. `[name]`) marked required in the generated `/locations` GeoJSON response schema, in addition to the always-required string `id` |
+| `conformance_class_requirements` | object | no | Map of conformance-class short name → constraints (`required_data_queries`, `radius_within_units_required`) applied only to collections that declare the class. Lets one profile document model several EDR Part 3 requirements classes (see below) |
 | `processes` | list | no | OGC API Processes to expose in the OpenAPI |
 | `requirements` | list | no | Normative requirements for the AsciiDoc/PDF |
 | `abstract_tests` | list | no | Conformance tests — each must reference a valid requirement `id` |
@@ -334,6 +341,8 @@ Uses the [edr-pydantic](https://github.com/KNMI/edr-pydantic) `Collection` model
 | `output_formats` | no | Format names this collection supports (e.g. `[CoverageJSON, GeoJSON]`) |
 | `data_queries` | no | EDR query types: `position`, `area`, `radius`, `cube`, `trajectory`, `corridor`, `locations`, `items`, `instances` |
 | `parameter_names` | no | Map of parameter id → Parameter object. All parameters must have `unit` and `observedProperty` |
+| `conformance_classes` | no | Profile conformance-class short names this collection implements (e.g. `[core, insitu-observations]`). Selects which `conformance_class_requirements` are enforced; surfaced as `x-conformance-classes` in the OpenAPI |
+| `parameter_schema` | no | Per-collection JSON Schema for parameter objects, overriding the profile-level `parameter_schema` for this collection only (precedence: collection → profile → default) |
 
 #### `data_queries` example
 
@@ -466,6 +475,38 @@ extent_requirements:
 
 ---
 
+### Multiple conformance classes in one profile
+
+OGC API - EDR Part 3 profiles are modular: a single profile document can define several requirements/conformance classes, and different collections in the same service may implement different classes. The MetOcean EDR Profile is a good example — Core applies everywhere, but only in-situ collections must offer `locations`/`area`/`radius` while NWP collections must offer `position`/`cube`.
+
+Model this with `conformance_class_requirements` (profile level) plus `conformance_classes` (per collection):
+
+```yaml
+# Core-level rules apply to every collection:
+collection_title_max_length: 50
+require_license_link: true
+
+# Class-scoped rules apply only where a collection opts in:
+conformance_class_requirements:
+  insitu-observations:
+    required_data_queries: [locations, area, radius]
+    radius_within_units_required: [m]
+  nwp:
+    required_data_queries: [position, cube]
+
+collections:
+  - id: insitu-observations
+    conformance_classes: [core, insitu-observations]   # must have locations/area/radius
+    # ...
+  - id: nwp-forecast
+    conformance_classes: [core, nwp]                    # must have position/cube
+    # ...
+```
+
+The flat `required_data_queries` / `radius_within_units_required` fields still apply to *every* collection (the Core-applies-to-all shorthand); class-scoped rules are additive. See `examples/metocean_profile.yaml` for a full worked profile spanning all four MetOcean classes.
+
+---
+
 ### `output_formats`
 
 Maps format names (referenced by `collections[].output_formats` and `data_queries.*.variables.output_formats`) to a media type and, optionally, a schema reference. The `schema_ref` flows into the generated OpenAPI response `content` for that format — use it to point a format at a specific schema (e.g. a DGIWG-published schema for GeoTIFF or CoverageJSON) instead of the tool's built-in default.
@@ -851,6 +892,12 @@ The tool enforces these rules at build time. Violations produce clear error mess
 | Parameters need `unit` + `observedProperty` | Required by OGC API - EDR Part 3 |
 | `parameter_name_pattern` enforced | All `parameter_names` keys must match if set |
 | `collection_id_pattern` enforced | All collection IDs must match if set |
+| `collection_title_max_length` enforced | If set, every collection title must be present and within the limit |
+| `require_license_link` enforced | If set, every collection must have a `rel='license'` link (of `license_link_type` when specified) |
+| `required_data_queries` enforced | If set, every collection with `data_queries` must define each listed query type |
+| `radius_within_units_required` enforced | If set, each radius query's `within_units` must contain every listed unit token |
+| `conformance_class_requirements` enforced | Class-scoped `required_data_queries` / `radius_within_units_required` applied to collections whose `conformance_classes` include the class key |
+| `conformance_classes` references known class | When `conformance_class_requirements` is set, a collection's `conformance_classes` may only use `core` or a defined class key (catches typos) |
 | Abstract test IDs match requirements | `requirement_id` must reference an existing requirement |
 | Requirement IDs | Must match `^[a-z0-9][a-z0-9\-]*$`, no trailing hyphen |
 

{oapi_profile_builder-3.4.1 → oapi_profile_builder-3.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oapi-profile-builder"
-version = "3.4.1"
+version = "3.5.0"
 description = "Authoritative tooling for creating OGC API Service Profiles (EDR, Features)"
 readme = "README.md"
 license = { file = "LICENSE" }

{oapi_profile_builder-3.4.1 → oapi_profile_builder-3.5.0}/src/oapi_profile_builder/generate.py

@@ -70,10 +70,46 @@ _DATETIME = {"$ref": f"{_FEATURES}#/components/parameters/datetime"}
 _PARAM_NAME = {"$ref": f"{_EDR}/parameters/parameter-name.yaml"}
 _Z = {"$ref": f"{_EDR}/parameters/z.yaml"}
 
-_ERR_SCHEMA = {"type": "object", "properties": {"code": {"type": "string"}, "description": {"type": "string"}}}
-_ERR_400 = {"description": "Invalid or missing parameter", "content": {"application/json": {"schema": _ERR_SCHEMA}}}
-_ERR_404 = {"description": "Not found", "content": {"application/json": {"schema": _ERR_SCHEMA}}}
-_ERR_500 = {"description": "Server error", "content": {"application/json": {"schema": _ERR_SCHEMA}}}
+# Error responses follow RFC 9457 (Problem Details for HTTP APIs), served as
+# application/problem+json, per OGC API - EDR Part 3 error-handling requirement
+# (and the MetOcean EDR Profile /req/core/error_handling). ``type`` and ``title``
+# are the two members RFC 9457 always defines; the rest are optional but modelled
+# so downstream tooling (Swagger UI, schemathesis, CITE) sees the full shape.
+_PROBLEM_MEDIA_TYPE = "application/problem+json"
+_PROBLEM_SCHEMA = {
+    "type": "object",
+    "required": ["type", "title"],
+    "properties": {
+        "type": {
+            "type": "string",
+            "format": "uri-reference",
+            "default": "about:blank",
+            "description": "A URI reference that identifies the problem type (RFC 9457).",
+        },
+        "title": {
+            "type": "string",
+            "description": "A short, human-readable summary of the problem type.",
+        },
+        "status": {
+            "type": "integer",
+            "description": "The HTTP status code generated by the origin server.",
+        },
+        "detail": {
+            "type": "string",
+            "description": "A human-readable explanation specific to this occurrence of the problem.",
+        },
+        "instance": {
+            "type": "string",
+            "format": "uri-reference",
+            "description": "A URI reference that identifies the specific occurrence of the problem.",
+        },
+    },
+}
+# Backwards-compatible alias; the error schema is now RFC 9457 Problem Details.
+_ERR_SCHEMA = _PROBLEM_SCHEMA
+_ERR_400 = {"description": "Invalid or missing parameter", "content": {_PROBLEM_MEDIA_TYPE: {"schema": _PROBLEM_SCHEMA}}}
+_ERR_404 = {"description": "Not found", "content": {_PROBLEM_MEDIA_TYPE: {"schema": _PROBLEM_SCHEMA}}}
+_ERR_500 = {"description": "Server error", "content": {_PROBLEM_MEDIA_TYPE: {"schema": _PROBLEM_SCHEMA}}}
 _ERR_DEFAULT = {"$ref": "#/components/responses/default"}
 
 _LINK_SCHEMA = {
@@ -164,6 +200,52 @@ _R200_FEATURES = {
     },
 }
 
+def _locations_response_schema(profile: "ServiceProfile | None") -> dict:
+    """Build the 200 response for a /locations query.
+
+    Per the EDR locations-response requirement (and the MetOcean profile's
+    /req/core/locations_query_response_format), the response is a GeoJSON
+    FeatureCollection where every feature carries a string ``id`` and a
+    ``properties`` object. ``properties.name`` is always documented; any
+    properties named in ``profile.locations_feature_required_properties`` are
+    marked required so the generated OpenAPI enforces them.
+    """
+    required_props = list(getattr(profile, "locations_feature_required_properties", None) or [])
+    properties_schema: dict = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string", "description": "Human-readable name of the location"},
+        },
+    }
+    if required_props:
+        properties_schema["required"] = required_props
+    feature_schema = {
+        "type": "object",
+        "required": ["type", "id", "properties"],
+        "properties": {
+            "type": {"type": "string", "const": "Feature"},
+            "id": {"type": "string", "description": "Location identifier usable at /locations/{locId}"},
+            "geometry": {"type": "object", "description": "GeoJSON geometry of the location"},
+            "properties": properties_schema,
+        },
+    }
+    return {
+        "description": "GeoJSON FeatureCollection of locations",
+        "content": {
+            "application/geo+json": {
+                "schema": {
+                    "type": "object",
+                    "required": ["type", "features"],
+                    "properties": {
+                        "type": {"type": "string", "const": "FeatureCollection"},
+                        "features": {"type": "array", "items": feature_schema},
+                    },
+                }
+            }
+        },
+    }
+
+
 def _coverage_response(coll: Collection, profile: "ServiceProfile | None") -> dict:
     """Build a coverage response dict reflecting the collection's actual output formats."""
     # Collect media_type → schema_ref from profile-level output_formats
@@ -212,7 +294,15 @@ def _coverage_response(coll: Collection, profile: "ServiceProfile | None") -> di
             "schema": {"$ref": f"{_EDR}/schemas/coverageJSON.yaml"}
         }
 
-    return {"200": {"description": "Coverage data response", "content": content}}
+    # Per the EDR error-handling requirement, a query whose spatio-temporal
+    # selection falls inside the collection extent but matches no data returns
+    # HTTP 204 (No Content); 4xx/5xx use RFC 9457 problem+json.
+    return {
+        "200": {"description": "Coverage data response", "content": content},
+        "204": {"description": "No data available for the requested query (empty result inside the extent)"},
+        "400": _ERR_400,
+        "500": _ERR_500,
+    }
 
 # ---------------------------------------------------------------------------
 # POST request body schemas — one per EDR query type.
@@ -448,9 +538,13 @@ def _collection_response_schema(coll: Collection,
         _apply(vrs_schema, er.extent_vrs)
         _apply(supported_crs_schema, er.supported_crs)
 
-    # Build parameter_names schema — use profile-supplied schema if present,
-    # otherwise fall back to the default EDR Parameter schema.
-    if profile and profile.parameter_schema:
+    # Build parameter_names schema. Precedence: per-collection parameter_schema
+    # override → profile-level parameter_schema → default EDR Parameter schema.
+    coll_param_schema = getattr(coll, "parameter_schema", None)
+    if coll_param_schema:
+        import copy
+        param_item_schema = copy.deepcopy(coll_param_schema)
+    elif profile and profile.parameter_schema:
         # Deep-copy so we don't mutate the profile model
         import copy
         param_item_schema = copy.deepcopy(profile.parameter_schema)
@@ -809,7 +903,7 @@ def _collection_paths(coll: Collection, examples: dict | None = None,
     # Build coverage response reflecting this collection's actual output formats
     cov_resp = _coverage_response(coll, profile)
 
-    paths[base] = {"get": {
+    describe_op = {
         "summary": f"Get {coll.title or coll.id} metadata",
         "description": desc,
         "operationId": _operation_id("describe", coll.id, "Collection"),
@@ -819,7 +913,12 @@ def _collection_paths(coll: Collection, examples: dict | None = None,
             "200": coll_schema,
             "400": _ERR_400, "404": _ERR_404, "500": _ERR_500,
         },
-    }}
+    }
+    # Surface the profile conformance classes this collection implements so the
+    # OpenAPI records which EDR Part 3 requirements classes apply to it.
+    if getattr(coll, "conformance_classes", None):
+        describe_op["x-conformance-classes"] = list(coll.conformance_classes)
+    paths[base] = {"get": describe_op}
 
     # Always generate Features paths (items, queryables, schema)
     items_params = _with_paging_limit([_F, _LANG], profile)
@@ -925,20 +1024,22 @@ def _collection_paths(coll: Collection, examples: dict | None = None,
             paths[f"{base}/items"] = path_ops
 
         elif qt == "locations":
+            loc_resp = _locations_response_schema(profile)
+            locations_responses = {
+                "200": loc_resp,
+                "400": _ERR_400, "500": _ERR_500,
+            }
             get_locations_op = {
                 "summary": f"Get pre-defined locations of {coll.id}",
                 "description": desc,
                 "operationId": _operation_id("getLocations", coll.id),
                 "tags": [tag],
                 "parameters": params,
-                "responses": {
-                    "200": _R200_FEATURES,
-                    "400": _ERR_400, "500": _ERR_500,
-                },
+                "responses": locations_responses,
             }
             path_ops = {"get": get_locations_op}
             if include_post:
-                path_ops["post"] = _post_operation(get_locations_op, "locations", coll.id, {"200": _R200_FEATURES, "400": _ERR_400, "500": _ERR_500})
+                path_ops["post"] = _post_operation(get_locations_op, "locations", coll.id, locations_responses)
             paths[f"{base}/locations"] = path_ops
 
             get_location_op = {
@@ -1236,7 +1337,7 @@ def build_openapi(profile: ServiceProfile) -> dict:
                 },
             },
             "responses": {
-                "default": {"description": "Unexpected error", "content": {"application/json": {"schema": {"type": "object"}}}},
+                "default": {"description": "Unexpected error", "content": {_PROBLEM_MEDIA_TYPE: {"schema": _PROBLEM_SCHEMA}}},
             },
         },
     }
@@ -1404,6 +1505,109 @@ def _individual_test_adoc(profile: ServiceProfile, test_id: str) -> str:
     return "\n".join(lines) + "\n"
 
 
+# ---------------------------------------------------------------------------
+# Multi-class requirements/conformance grouping
+#
+# When one or more requirements declare a `conformance_class`, the generated
+# AsciiDoc/PDF is organised into one requirements class (and matching
+# conformance class) per key, mirroring how a multi-class profile document
+# (e.g. the MetOcean profile) is structured. When no requirement declares a
+# class, `_requirement_class_groups` returns None and the single-class code
+# path is used unchanged (backward compatible).
+# ---------------------------------------------------------------------------
+
+def _requirement_class_groups(profile: ServiceProfile):
+    """Return an ordered dict {class_key: {"reqs": [...], "tests": [...]}} or None.
+
+    None signals "no per-class grouping requested" — use the legacy single class.
+    """
+    if not any(getattr(r, "conformance_class", None) for r in profile.requirements):
+        return None
+    from collections import OrderedDict
+    groups: "OrderedDict[str, dict]" = OrderedDict()
+    req_class: dict[str, str] = {}
+    for r in profile.requirements:
+        cls = getattr(r, "conformance_class", None) or "core"
+        req_class[r.id] = cls
+        groups.setdefault(cls, {"reqs": [], "tests": []})["reqs"].append(r)
+    for t in profile.abstract_tests:
+        cls = req_class.get(t.requirement_id, "core")
+        groups.setdefault(cls, {"reqs": [], "tests": []})["tests"].append(t)
+    return groups
+
+
+def _class_req_uri(profile: ServiceProfile, cls: str) -> str:
+    return f"{profile.spec_uri_base.rstrip('/')}/req/{cls}"
+
+
+def _class_conf_uri(profile: ServiceProfile, cls: str) -> str:
+    return f"{profile.spec_uri_base.rstrip('/')}/conf/{cls}"
+
+
+def _req_class_adoc_for(profile: ServiceProfile, cls: str, reqs: list) -> str:
+    lines = [
+        f"[[req_class_{cls}]]".replace("-", "_"),
+        "[requirements_class]",
+        "====",
+        "[%metadata]",
+        f"identifier:: {_class_req_uri(profile, cls)}",
+        f"target-type:: {profile.title} Profile Standard",
+    ]
+    for req in reqs:
+        lines.append(f"requirement:: /req/{cls}/{req.id}")
+    lines.append("====")
+    return "\n".join(lines) + "\n"
+
+
+def _conf_class_adoc_for(profile: ServiceProfile, cls: str, tests: list) -> str:
+    lines = [
+        f"[[ats_class_{cls}]]".replace("-", "_"),
+        "[conformance_class]",
+        "====",
+        "[%metadata]",
+        f"identifier:: {_class_conf_uri(profile, cls)}",
+        f"target:: {_class_req_uri(profile, cls)}",
+    ]
+    for test in tests:
+        lines.append(f"abstract-test:: /conf/{cls}/{test.id}")
+    lines.append("====")
+    return "\n".join(lines) + "\n"
+
+
+def _individual_req_adoc_for(profile: ServiceProfile, cls: str, req) -> str:
+    anchor = f"req_{cls}_{req.id}".replace("/", "_").replace("-", "_")
+    lines = [
+        f"[[{anchor}]]",
+        "[requirement]",
+        "====",
+        "[%metadata]",
+        f"identifier:: /req/{cls}/{req.id}",
+        f"statement:: {req.statement}",
+    ]
+    for part in req.parts:
+        lines.append(f"part:: {part}")
+    lines.append("====")
+    return "\n".join(lines) + "\n"
+
+
+def _individual_test_adoc_for(profile: ServiceProfile, cls: str, test) -> str:
+    anchor = f"ats_{cls}_{test.id}".replace("/", "_").replace("-", "_")
+    lines = [
+        f"[[{anchor}]]",
+        "[abstract_test]",
+        "====",
+        "[%metadata]",
+        f"identifier:: /conf/{cls}/{test.id}",
+        f"target:: /req/{cls}/{test.requirement_id}",
+        f"test-purpose:: Validate that {test.id.replace('-', ' ')} is correctly implemented.",
+        "test-method::",
+    ]
+    for step in test.steps:
+        lines.append(f"step:: {step}")
+    lines.append("====")
+    return "\n".join(lines) + "\n"
+
+
 # ---------------------------------------------------------------------------
 # Metanorma root document
 # ---------------------------------------------------------------------------
@@ -2018,13 +2222,44 @@ def _terms_adoc(profile: ServiceProfile) -> str:
 def _build_sections(profile: ServiceProfile) -> dict[str, str]:
     """Return the minimal boilerplate sections required by Metanorma OGC."""
     m = profile.document_metadata
-    conf_uris = [profile.conf_uri]
-    req_includes = "\n".join(
-        f"include::../requirements/core/REQ_{r.id}.adoc[]" for r in profile.requirements
-    )
-    ats_includes = "\n".join(
-        f"include::../abstract_tests/core/ATS_{t.id}.adoc[]" for t in profile.abstract_tests
+    groups = _requirement_class_groups(profile)
+    conf_uris = (
+        [_class_conf_uri(profile, cls) for cls in groups]
+        if groups is not None
+        else [profile.conf_uri]
     )
+    if groups is None:
+        req_includes = "\n".join(
+            f"include::../requirements/core/REQ_{r.id}.adoc[]" for r in profile.requirements
+        )
+        ats_includes = "\n".join(
+            f"include::../abstract_tests/core/ATS_{t.id}.adoc[]" for t in profile.abstract_tests
+        )
+        req_class_includes = "include::../requirements/requirements_class_core.adoc[]"
+        ats_class_includes = "include::../abstract_tests/ATS_class_core.adoc[]"
+    else:
+        # One requirements class block + its requirement includes, per class.
+        req_blocks: list[str] = []
+        ats_blocks: list[str] = []
+        for cls, members in groups.items():
+            req_blocks.append(
+                f"include::../requirements/requirements_class_{cls}.adoc[]\n\n"
+                + "\n".join(
+                    f"include::../requirements/{cls}/REQ_{r.id}.adoc[]"
+                    for r in members["reqs"]
+                )
+            )
+            ats_blocks.append(
+                f"include::../abstract_tests/ATS_class_{cls}.adoc[]\n\n"
+                + "\n".join(
+                    f"include::../abstract_tests/{cls}/ATS_{t.id}.adoc[]"
+                    for t in members["tests"]
+                )
+            )
+        req_includes = "\n\n".join(req_blocks)
+        ats_includes = "\n\n".join(ats_blocks)
+        req_class_includes = ""
+        ats_class_includes = ""
 
     # --- Submitters table rows (page iv) ---
     # Prefer the structured `submitters` list (each with its own affiliation).
@@ -2147,12 +2382,12 @@ def _build_sections(profile: ServiceProfile) -> dict[str, str]:
         ),
         "sections/06-requirements.adoc": (
             "== Requirements\n\n"
-            "include::../requirements/requirements_class_core.adoc[]\n\n"
+            + (req_class_includes + "\n\n" if req_class_includes else "")
             + req_includes + "\n"
         ),
         "sections/07-abstract-tests.adoc": (
             "[appendix,obligation=normative]\n== Abstract Test Suite\n\n"
-            "include::../abstract_tests/ATS_class_core.adoc[]\n\n"
+            + (ats_class_includes + "\n\n" if ats_class_includes else "")
             + ats_includes + "\n"
         ),
     }
@@ -2189,19 +2424,37 @@ def generate(profile: ServiceProfile, output_dir: Path) -> None:
     if profile.pubsub:
         safe_write("asyncapi.yaml", yaml.dump(build_asyncapi(profile), sort_keys=False, allow_unicode=True))
 
-    # Requirements class
-    safe_write("requirements/requirements_class_core.adoc", _req_adoc(profile))
-
-    # Individual requirements
-    for req in profile.requirements:
-        safe_write(f"requirements/core/REQ_{req.id}.adoc", _individual_req_adoc(profile, req.id))
-
-    # Conformance class
-    safe_write("abstract_tests/ATS_class_core.adoc", _conf_adoc(profile))
-
-    # Individual abstract tests
-    for test in profile.abstract_tests:
-        safe_write(f"abstract_tests/core/ATS_{test.id}.adoc", _individual_test_adoc(profile, test.id))
+    _req_groups = _requirement_class_groups(profile)
+    if _req_groups is None:
+        # Single-class (legacy) layout — one 'core' requirements/conformance class.
+        safe_write("requirements/requirements_class_core.adoc", _req_adoc(profile))
+        for req in profile.requirements:
+            safe_write(f"requirements/core/REQ_{req.id}.adoc", _individual_req_adoc(profile, req.id))
+        safe_write("abstract_tests/ATS_class_core.adoc", _conf_adoc(profile))
+        for test in profile.abstract_tests:
+            safe_write(f"abstract_tests/core/ATS_{test.id}.adoc", _individual_test_adoc(profile, test.id))
+    else:
+        # Multi-class layout — one requirements/conformance class per key, with
+        # requirement and abstract-test files grouped under class subdirectories.
+        for cls, members in _req_groups.items():
+            safe_write(
+                f"requirements/requirements_class_{cls}.adoc",
+                _req_class_adoc_for(profile, cls, members["reqs"]),
+            )
+            for req in members["reqs"]:
+                safe_write(
+                    f"requirements/{cls}/REQ_{req.id}.adoc",
+                    _individual_req_adoc_for(profile, cls, req),
+                )
+            safe_write(
+                f"abstract_tests/ATS_class_{cls}.adoc",
+                _conf_class_adoc_for(profile, cls, members["tests"]),
+            )
+            for test in members["tests"]:
+                safe_write(
+                    f"abstract_tests/{cls}/ATS_{test.id}.adoc",
+                    _individual_test_adoc_for(profile, cls, test),
+                )
 
     # Profile config (round-trip)
     safe_write(

{oapi_profile_builder-3.4.1 → oapi_profile_builder-3.5.0}/src/oapi_profile_builder/models.py

@@ -177,6 +177,45 @@ class Collection(EDRCollection):
     metadata_date: Optional[str] = None
     resource_service_publish_date: Optional[str] = None
     resource_default_locale: Optional[str] = None
+    conformance_classes: List[str] = Field(
+        default_factory=list,
+        description=(
+            "Short keys of the profile's conformance classes this collection "
+            "implements (e.g. ['core', 'insitu-observations']). Drives which "
+            "entries in ServiceProfile.conformance_class_requirements are enforced "
+            "for this collection, so a single profile document can hold collections "
+            "of different EDR Part 3 requirements classes. Round-tripped into "
+            "profile_config.json and surfaced as x-conformance-classes in the "
+            "generated OpenAPI."
+        ),
+    )
+    parameter_schema: Optional[dict] = Field(
+        default=None,
+        description=(
+            "Per-collection JSON Schema fragment used as the additionalProperties "
+            "definition for this collection's parameter_names in the generated "
+            "OpenAPI. Overrides the profile-level parameter_schema for this "
+            "collection only. Use this when collections in one profile need "
+            "different parameter constraints — e.g. an insitu collection requiring "
+            "metocean:standard_name / metocean:level / measurementType while an NWP "
+            "collection uses ECMWF short-name conventions. Must be a valid JSON "
+            "Schema object."
+        ),
+    )
+
+    @field_validator("parameter_schema")
+    @classmethod
+    def _valid_parameter_schema(cls, v: dict | None) -> dict | None:
+        if v is None:
+            return v
+        if not isinstance(v, dict):
+            raise ValueError("parameter_schema must be a JSON Schema object (dict)")
+        if not any(k in v for k in ("type", "properties", "$ref", "allOf", "anyOf", "oneOf")):
+            raise ValueError(
+                "parameter_schema must contain at least one of: "
+                "type, properties, $ref, allOf, anyOf, oneOf"
+            )
+        return v
 
 
 # ---------------------------------------------------------------------------
@@ -198,6 +237,17 @@ class Requirement(BaseModel):
     id: Annotated[str, Field(pattern=r"^[a-z0-9][a-z0-9\-]*$")]
     statement: str
     parts: list[str] = Field(min_length=1)
+    conformance_class: str | None = Field(
+        default=None,
+        description=(
+            "Short key of the requirements/conformance class this requirement "
+            "belongs to (e.g. 'core', 'insitu-observations', 'nwp'). When any "
+            "requirement sets this, the generated AsciiDoc/PDF groups requirements "
+            "and abstract tests into one requirements class per key (each with its "
+            "own class URI under spec_uri_base). When unset on all requirements, "
+            "the generator keeps its single-class behaviour."
+        ),
+    )
 
     @field_validator("id")
     @classmethod
@@ -729,6 +779,38 @@ class PagingConfig(BaseModel):
     max_limit: int = Field(default=10000, description="Maximum allowed limit for features returned", ge=1)
 
 
+class ConformanceClassConstraints(BaseModel):
+    """Constraints scoped to a single OGC API - EDR Part 3 conformance class.
+
+    A profile document (e.g. the MetOcean EDR Profile) defines several
+    requirements/conformance classes — Core, Insitu observations, NWP, Data
+    query response format — and different collections in the same service may
+    implement different classes. These per-class constraints are applied only
+    to collections whose ``conformance_classes`` list includes the matching
+    class key, so one profile can enforce, say, ``[locations, area, radius]``
+    on its insitu collections and ``[position, cube]`` on its NWP collections.
+
+    The equivalent profile-level fields (``required_data_queries``,
+    ``radius_within_units_required``) remain a shorthand that applies to *every*
+    collection; class-scoped constraints are additive on top of them.
+    """
+    required_data_queries: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Data query types every collection implementing this conformance class "
+            "must define (e.g. ['locations', 'area', 'radius'] for insitu, "
+            "['position', 'cube'] for NWP)."
+        ),
+    )
+    radius_within_units_required: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Unit tokens each radius query's within_units array must contain for "
+            "collections implementing this conformance class (e.g. ['m'])."
+        ),
+    )
+
+
 # ---------------------------------------------------------------------------
 # Root model — the authoritative profile definition
 # ---------------------------------------------------------------------------
@@ -852,6 +934,75 @@ class ServiceProfile(BaseModel):
         ),
     )
 
+    # --- Collection-level conformance constraints ---------------------------
+    # Optional profile-level rules that mirror MetOcean EDR Profile core
+    # requirements. Each is off by default so existing profiles are unaffected;
+    # set them to opt a profile into the corresponding validation.
+
+    collection_title_max_length: int | None = Field(
+        default=None,
+        ge=1,
+        description=(
+            "When set, every collection title must be present and no longer than this "
+            "many characters. Implements the MetOcean /req/core/collection_title rule "
+            "(title required, <= 50 characters)."
+        ),
+    )
+    require_license_link: bool = Field(
+        default=False,
+        description=(
+            "When true, every collection must declare a link with rel='license'. "
+            "The link's type must equal license_link_type when that field is set. "
+            "Implements the MetOcean /req/core/collection_license rule."
+        ),
+    )
+    license_link_type: str | None = Field(
+        default="text/html",
+        description=(
+            "Expected media type of the rel='license' link when require_license_link "
+            "is true. Set to null to accept any type. Defaults to 'text/html' per the "
+            "MetOcean profile."
+        ),
+    )
+    required_data_queries: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Data query types (e.g. 'locations', 'area', 'radius', 'position', 'cube') "
+            "that every collection with data_queries must define. Implements the "
+            "'array must contain value' rule for the mandatory data-query sets "
+            "(MetOcean /req/*/collection_data_queries)."
+        ),
+    )
+    radius_within_units_required: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Unit tokens that every radius query's within_units array must contain "
+            "(e.g. ['m']). Implements the MetOcean /req/core/collection_radius_data_query "
+            "rule that within_units SHALL contain 'm'."
+        ),
+    )
+    locations_feature_required_properties: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Feature properties (e.g. ['name']) that the generated /locations response "
+            "schema marks as required on each GeoJSON feature, in addition to the always-"
+            "required string 'id'. Implements the MetOcean "
+            "/req/core/locations_query_response_format rule."
+        ),
+    )
+    conformance_class_requirements: dict[str, ConformanceClassConstraints] = Field(
+        default_factory=dict,
+        description=(
+            "Per-conformance-class constraints keyed by class short name (e.g. "
+            "'insitu-observations', 'nwp'). Applied only to collections whose "
+            "conformance_classes list includes the key. Lets one profile document "
+            "model several EDR Part 3 requirements classes with different mandatory "
+            "data-query sets. The flat required_data_queries / "
+            "radius_within_units_required fields still apply to every collection; "
+            "class-scoped constraints are additive on top of them."
+        ),
+    )
+
     # OGC identifiers derived from name and spec_uri_base — not user-supplied directly
     @property
     def req_uri(self) -> str:
@@ -1078,6 +1229,160 @@ class ServiceProfile(BaseModel):
                 )
         return self
 
+    @model_validator(mode="after")
+    def validate_collection_title_length(self) -> ServiceProfile:
+        """Enforce collection_title_max_length (MetOcean /req/core/collection_title)."""
+        if self.collection_title_max_length is None:
+            return self
+        limit = self.collection_title_max_length
+        for coll in self.collections:
+            title = getattr(coll, "title", None)
+            if not title:
+                raise ValueError(
+                    f"Collection '{coll.id}' must declare a title "
+                    f"(collection_title_max_length is set to {limit})"
+                )
+            if len(title) > limit:
+                raise ValueError(
+                    f"Collection '{coll.id}' title is {len(title)} characters; "
+                    f"exceeds the maximum of {limit} "
+                    f"(collection_title_max_length)"
+                )
+        return self
+
+    @model_validator(mode="after")
+    def validate_license_link(self) -> ServiceProfile:
+        """Require a rel='license' link per MetOcean /req/core/collection_license."""
+        if not self.require_license_link:
+            return self
+        for coll in self.collections:
+            links = getattr(coll, "links", None) or []
+            license_links = [
+                lk for lk in links if getattr(lk, "rel", None) == "license"
+            ]
+            if not license_links:
+                raise ValueError(
+                    f"Collection '{coll.id}' must declare a link with rel='license' "
+                    f"(require_license_link is set)"
+                )
+            if self.license_link_type is not None:
+                if not any(
+                    getattr(lk, "type", None) == self.license_link_type
+                    for lk in license_links
+                ):
+                    raise ValueError(
+                        f"Collection '{coll.id}' rel='license' link must have "
+                        f"type='{self.license_link_type}' "
+                        f"(license_link_type)"
+                    )
+        return self
+
+    def _effective_required_data_queries(self, coll: "Collection") -> set[str]:
+        """Mandatory data-query types for a collection.
+
+        Combines the profile-wide required_data_queries (applies to every
+        collection) with the required_data_queries of every conformance class
+        the collection declares via conformance_classes.
+        """
+        required: set[str] = set(self.required_data_queries)
+        for cls_name in getattr(coll, "conformance_classes", []) or []:
+            cls = self.conformance_class_requirements.get(cls_name)
+            if cls:
+                required.update(cls.required_data_queries)
+        return required
+
+    def _effective_radius_within_units(self, coll: "Collection") -> set[str]:
+        """Required radius within_units tokens for a collection (flat + class-scoped)."""
+        required: set[str] = set(self.radius_within_units_required)
+        for cls_name in getattr(coll, "conformance_classes", []) or []:
+            cls = self.conformance_class_requirements.get(cls_name)
+            if cls:
+                required.update(cls.radius_within_units_required)
+        return required
+
+    @model_validator(mode="after")
+    def validate_required_data_queries(self) -> ServiceProfile:
+        """Ensure each collection defines its mandatory data query types.
+
+        Mandatory sets come from the profile-wide required_data_queries plus any
+        conformance-class-scoped requirements the collection opts into.
+        """
+        for coll in self.collections:
+            required = self._effective_required_data_queries(coll)
+            if not required:
+                continue
+            if not coll.data_queries:
+                raise ValueError(
+                    f"Collection '{coll.id}' must define data_queries including "
+                    f"{sorted(required)} (required_data_queries)"
+                )
+            present = {
+                name for name, val in coll.data_queries if val is not None
+            }
+            missing = required - present
+            if missing:
+                raise ValueError(
+                    f"Collection '{coll.id}' data_queries is missing required "
+                    f"query type(s) {sorted(missing)} (required by "
+                    f"required_data_queries / conformance_class_requirements)"
+                )
+        return self
+
+    @model_validator(mode="after")
+    def validate_radius_within_units(self) -> ServiceProfile:
+        """Ensure each radius query's within_units contains the required unit tokens."""
+        for coll in self.collections:
+            required = self._effective_radius_within_units(coll)
+            if not required or not coll.data_queries:
+                continue
+            for qt_name, qt_val in coll.data_queries:
+                if qt_name != "radius" or qt_val is None:
+                    continue
+                variables = qt_val.link.variables if qt_val.link else None
+                extra = (
+                    variables.model_extra
+                    if variables is not None and hasattr(variables, "model_extra")
+                    else {}
+                ) or {}
+                within_units = (
+                    getattr(variables, "within_units", None)
+                    or extra.get("within_units")
+                    or []
+                )
+                missing = [u for u in sorted(required) if u not in within_units]
+                if missing:
+                    raise ValueError(
+                        f"Collection '{coll.id}' radius data query within_units "
+                        f"{list(within_units)} must contain {missing} "
+                        f"(radius_within_units_required / conformance_class_requirements)"
+                    )
+        return self
+
+    @model_validator(mode="after")
+    def validate_collection_conformance_classes(self) -> ServiceProfile:
+        """Flag conformance_classes keys that have no matching requirements entry.
+
+        A collection may legitimately declare a pure conformance class (e.g.
+        'core') that carries no extra constraints, so this only errors when a
+        class key looks like a typo: it is referenced by a collection, is not a
+        key in conformance_class_requirements, AND conformance_class_requirements
+        is non-empty (i.e. the profile author is using the class-scoped model).
+        """
+        if not self.conformance_class_requirements:
+            return self
+        known = set(self.conformance_class_requirements)
+        # 'core' is always acceptable as a bare class even without constraints.
+        known.add("core")
+        for coll in self.collections:
+            for cls_name in getattr(coll, "conformance_classes", []) or []:
+                if cls_name not in known:
+                    raise ValueError(
+                        f"Collection '{coll.id}' declares conformance class "
+                        f"'{cls_name}' which is not defined in "
+                        f"conformance_class_requirements {sorted(self.conformance_class_requirements)}"
+                    )
+        return self
+
 
 def _compile_optional_pattern(label: str, pattern: str | None) -> re.Pattern | None:
     """Compile a regex pattern string, raising ValueError on invalid syntax."""

{oapi_profile_builder-3.4.1 → oapi_profile_builder-3.5.0/src/oapi_profile_builder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oapi-profile-builder
-Version: 3.4.1
+Version: 3.5.0
 Summary: Authoritative tooling for creating OGC API Service Profiles (EDR, Features)
 Author-email: Shane Mill <shane.mill@noaa.gov>
 License: Apache License
@@ -342,6 +342,13 @@ abstract_tests: []
 | `spec_uri_base` | string | no | Base URI for the requirements/conformance class identifiers. Defaults to the OGC EDR Part 3 namespace; override to publish under another SDO namespace (e.g. DGIWG) |
 | `parameter_name_pattern` | string | no | Regex all `parameter_names` keys must match |
 | `parameter_schema` | object | no | JSON Schema for parameter objects — replaces the default schema in the generated OpenAPI (see below) |
+| `collection_title_max_length` | int | no | When set, every collection title must be present and within this many characters (MetOcean `/req/core/collection_title`) |
+| `require_license_link` | bool | no | When `true`, every collection must declare a `rel='license'` link (MetOcean `/req/core/collection_license`). Defaults to `false` |
+| `license_link_type` | string | no | Expected media type of the `rel='license'` link when `require_license_link` is set. Defaults to `text/html`; set to null to accept any type |
+| `required_data_queries` | list | no | Data-query types every collection must define (e.g. `[locations, area, radius]`) — enforces the mandatory data-query sets |
+| `radius_within_units_required` | list | no | Unit tokens each radius query's `within_units` must contain (e.g. `[m]`) (MetOcean `/req/core/collection_radius_data_query`) |
+| `locations_feature_required_properties` | list | no | Feature properties (e.g. `[name]`) marked required in the generated `/locations` GeoJSON response schema, in addition to the always-required string `id` |
+| `conformance_class_requirements` | object | no | Map of conformance-class short name → constraints (`required_data_queries`, `radius_within_units_required`) applied only to collections that declare the class. Lets one profile document model several EDR Part 3 requirements classes (see below) |
 | `processes` | list | no | OGC API Processes to expose in the OpenAPI |
 | `requirements` | list | no | Normative requirements for the AsciiDoc/PDF |
 | `abstract_tests` | list | no | Conformance tests — each must reference a valid requirement `id` |
@@ -381,6 +388,8 @@ Uses the [edr-pydantic](https://github.com/KNMI/edr-pydantic) `Collection` model
 | `output_formats` | no | Format names this collection supports (e.g. `[CoverageJSON, GeoJSON]`) |
 | `data_queries` | no | EDR query types: `position`, `area`, `radius`, `cube`, `trajectory`, `corridor`, `locations`, `items`, `instances` |
 | `parameter_names` | no | Map of parameter id → Parameter object. All parameters must have `unit` and `observedProperty` |
+| `conformance_classes` | no | Profile conformance-class short names this collection implements (e.g. `[core, insitu-observations]`). Selects which `conformance_class_requirements` are enforced; surfaced as `x-conformance-classes` in the OpenAPI |
+| `parameter_schema` | no | Per-collection JSON Schema for parameter objects, overriding the profile-level `parameter_schema` for this collection only (precedence: collection → profile → default) |
 
 #### `data_queries` example
 
@@ -513,6 +522,38 @@ extent_requirements:
 
 ---
 
+### Multiple conformance classes in one profile
+
+OGC API - EDR Part 3 profiles are modular: a single profile document can define several requirements/conformance classes, and different collections in the same service may implement different classes. The MetOcean EDR Profile is a good example — Core applies everywhere, but only in-situ collections must offer `locations`/`area`/`radius` while NWP collections must offer `position`/`cube`.
+
+Model this with `conformance_class_requirements` (profile level) plus `conformance_classes` (per collection):
+
+```yaml
+# Core-level rules apply to every collection:
+collection_title_max_length: 50
+require_license_link: true
+
+# Class-scoped rules apply only where a collection opts in:
+conformance_class_requirements:
+  insitu-observations:
+    required_data_queries: [locations, area, radius]
+    radius_within_units_required: [m]
+  nwp:
+    required_data_queries: [position, cube]
+
+collections:
+  - id: insitu-observations
+    conformance_classes: [core, insitu-observations]   # must have locations/area/radius
+    # ...
+  - id: nwp-forecast
+    conformance_classes: [core, nwp]                    # must have position/cube
+    # ...
+```
+
+The flat `required_data_queries` / `radius_within_units_required` fields still apply to *every* collection (the Core-applies-to-all shorthand); class-scoped rules are additive. See `examples/metocean_profile.yaml` for a full worked profile spanning all four MetOcean classes.
+
+---
+
 ### `output_formats`
 
 Maps format names (referenced by `collections[].output_formats` and `data_queries.*.variables.output_formats`) to a media type and, optionally, a schema reference. The `schema_ref` flows into the generated OpenAPI response `content` for that format — use it to point a format at a specific schema (e.g. a DGIWG-published schema for GeoTIFF or CoverageJSON) instead of the tool's built-in default.
@@ -898,6 +939,12 @@ The tool enforces these rules at build time. Violations produce clear error mess
 | Parameters need `unit` + `observedProperty` | Required by OGC API - EDR Part 3 |
 | `parameter_name_pattern` enforced | All `parameter_names` keys must match if set |
 | `collection_id_pattern` enforced | All collection IDs must match if set |
+| `collection_title_max_length` enforced | If set, every collection title must be present and within the limit |
+| `require_license_link` enforced | If set, every collection must have a `rel='license'` link (of `license_link_type` when specified) |
+| `required_data_queries` enforced | If set, every collection with `data_queries` must define each listed query type |
+| `radius_within_units_required` enforced | If set, each radius query's `within_units` must contain every listed unit token |
+| `conformance_class_requirements` enforced | Class-scoped `required_data_queries` / `radius_within_units_required` applied to collections whose `conformance_classes` include the class key |
+| `conformance_classes` references known class | When `conformance_class_requirements` is set, a collection's `conformance_classes` may only use `core` or a defined class key (catches typos) |
 | Abstract test IDs match requirements | `requirement_id` must reference an existing requirement |
 | Requirement IDs | Must match `^[a-z0-9][a-z0-9\-]*$`, no trailing hyphen |