diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,35 @@ ## [Unreleased] +## [0.7.0.0] - 2026-08-18 + +### Added + +- `RegistryLoadError`, `ProfileSourceLoadError`, `loadRegistryDetailed`, + `loadProfileSourceDetailed`, and `loadProfileSourcesDetailed` add stable typed + failure categories while the existing text-returning APIs preserve their + signatures. `looksLikeRegistryPath` lets callers distinguish actionable + filesystem intent from remote URLs and raw Dhall expressions. +- `Okf.Profile.Discovery` finds `.dhall` files that decode as profiles using a + bounded, failure-tolerant walk and a loader that rejects fresh remote + imports. `ProfileSource` now includes one-file `DescriptorSource` values so + local descriptors participate in provenance-aware enumeration. +- `ProfileSource`, `SourcedProfile`, and `SourceFailure` add provenance-aware, + ordered multi-source registry enumeration without changing `RegistryEntry` or + the existing single-registry functions. Partial failures are returned beside + successful profiles, collisions remain visible, and exact duplicate sources + are normalized in first-occurrence order. +- An offline snapshot of the built-in profile catalogue and a registry + conformance test prove that every pinned export decodes under the current + `ProfileSpec` compatibility chain. The exact ten export paths are asserted so + a partial or unintended catalogue refresh fails loudly. + +### Changed + +- `defaultRegistryReference` now pins `mori://shinzui/okf-profiles` v0.10.0 and + its normalized sha256 hash, replacing v0.4.2. The public registry API is + unchanged. + ## [0.6.0.1] - 2026-08-16 No library changes. Released to keep the version in step with `okf-cli` diff --git a/okf-core.cabal b/okf-core.cabal --- a/okf-core.cabal +++ b/okf-core.cabal @@ -1,6 +1,6 @@ cabal-version: 3.4 name: okf-core -version: 0.6.0.1 +version: 0.7.0.0 synopsis: Read, validate, index, and traverse Open Knowledge Format bundles @@ -31,6 +31,7 @@ test/fixtures/**/*.md test/fixtures/**/*.py test/fixtures/**/*.sql + test/fixtures/**/*.txt common common-options ghc-options: @@ -62,6 +63,7 @@ Okf.Path Okf.Prelude Okf.Profile + Okf.Profile.Discovery Okf.Profile.Documentation Okf.Profile.Registry Okf.Query diff --git a/src/Okf/Discovery.hs b/src/Okf/Discovery.hs --- a/src/Okf/Discovery.hs +++ b/src/Okf/Discovery.hs @@ -15,6 +15,8 @@ defaultDiscoveryOptions, discoverBundleRoots, directoryQualifiesAsBundleRoot, + isSearchableDirectory, + listDirectorySafe, ) where diff --git a/src/Okf/Profile/Discovery.hs b/src/Okf/Profile/Discovery.hs new file mode 100644 --- /dev/null +++ b/src/Okf/Profile/Discovery.hs @@ -0,0 +1,139 @@ +-- | Network-silent discovery of local Dhall profile descriptors. +-- +-- A descriptor qualifies by behavior: it is a non-symlink @.dhall@ file that +-- evaluates and decodes as a 'ProfileSpec'. Discovery is a convenience rather +-- than validation, so unreadable, malformed, and non-profile files are skipped. +-- Remote import callbacks always reject before doing I/O; explicit profile and +-- registry loading retains its ordinary Dhall behavior elsewhere. +module Okf.Profile.Discovery + ( ProfileDiscoveryOptions (..), + defaultProfileDiscoveryOptions, + discoverProfileDescriptors, + fileQualifiesAsProfileDescriptor, + loadProfileDescriptorWithoutNetwork, + ) +where + +import Control.Exception (Exception, SomeException, catch, throw) +import Control.Monad (filterM) +import Data.List qualified as List +import Data.Text qualified as Text +import Data.Text.IO qualified as Text.IO +import Dhall.Core qualified +import Dhall.Import qualified +import Dhall.Parser qualified +import Dhall.TypeCheck qualified +import Okf.Discovery (isSearchableDirectory, listDirectorySafe) +import Okf.Prelude +import Okf.Profile (ProfileSpec, decodeProfileExpr) +import System.Directory (doesFileExist, pathIsSymbolicLink) +import System.FilePath (()) +import System.FilePath qualified as FilePath + +-- | How far and where 'discoverProfileDescriptors' may look. +data ProfileDiscoveryOptions = ProfileDiscoveryOptions + { -- | How many directory levels below the search root to inspect. The search + -- root itself is depth 0, so @maxDepth = 4@ inspects four levels beneath it. + maxDepth :: !Int, + -- | Directory names never entered, regardless of depth. Directories whose + -- name begins with @.@ are always skipped and need no entry here. + skipDirectories :: ![FilePath] + } + deriving stock (Generic, Eq, Show) + +-- | The same depth and build-output exclusions as bundle discovery. Keeping +-- both discovery mechanisms aligned makes their filesystem reach predictable. +defaultProfileDiscoveryOptions :: ProfileDiscoveryOptions +defaultProfileDiscoveryOptions = + ProfileDiscoveryOptions + { maxDepth = 4, + skipDirectories = + [ "dist-newstyle", + "dist", + "node_modules", + "target", + "vendor", + "_build" + ] + } + +-- | Discover every qualifying descriptor below a search root. Unlike bundle +-- discovery, finding one file does not prune the subtree: sibling and nested +-- descriptors are independent sources. Results are sorted and normalized. +discoverProfileDescriptors :: ProfileDiscoveryOptions -> FilePath -> IO [FilePath] +discoverProfileDescriptors ProfileDiscoveryOptions {maxDepth, skipDirectories} searchRoot = + List.sort <$> walk 0 searchRoot + where + walk depth directory = do + entries <- listDirectorySafe directory + let visible = [entry | entry <- List.sort entries, not (isHidden entry)] + descriptors <- + filterM + fileQualifiesAsProfileDescriptor + [directory entry | entry <- visible, FilePath.takeExtension entry == ".dhall"] + nested <- + if depth >= maxDepth + then pure [] + else do + subdirectories <- + filterM + (isSearchableDirectory skipDirectories) + [directory entry | entry <- visible] + concat <$> traverse (walk (depth + 1)) subdirectories + pure (map FilePath.normalise descriptors <> nested) + + isHidden entry = case entry of + ('.' : _) -> True + _ -> False + +-- | Whether one filesystem path is a discoverable descriptor. Symlinks are +-- excluded because following them would make the bounded walk cyclic or allow +-- it to escape its roots. Every load or decode failure becomes @False@. +fileQualifiesAsProfileDescriptor :: FilePath -> IO Bool +fileQualifiesAsProfileDescriptor path + | FilePath.takeExtension path /= ".dhall" = pure False + | otherwise = do + exists <- safelyFalse (doesFileExist path) + isSymlink <- safelyFalse (pathIsSymbolicLink path) + if exists && not isSymlink + then either (const False) (const True) <$> loadProfileDescriptorWithoutNetwork path + else pure False + +-- | Load one descriptor with local imports and the semantic cache enabled, but +-- with both fresh remote import paths disabled. A cached integrity-protected +-- remote may therefore resolve; an uncached text or bytes import cannot make a +-- network request. The file is parsed exactly once before import resolution. +loadProfileDescriptorWithoutNetwork :: FilePath -> IO (Either Text ProfileSpec) +loadProfileDescriptorWithoutNetwork path = + action `catch` \(exception :: SomeException) -> pure (Left (Text.pack (show exception))) + where + action = do + contents <- Text.IO.readFile path + parsed <- either throw pure (Dhall.Parser.exprFromText path contents) + let baseStatus = Dhall.Import.emptyStatus (FilePath.takeDirectory path) + status = + baseStatus + { Dhall.Import._remote = \_ -> throw RemoteImportsDisabled, + Dhall.Import._remoteBytes = \_ -> throw RemoteImportsDisabled + } + resolved <- + Dhall.Import.loadWithStatus + status + Dhall.Import.UseSemanticCache + parsed + _ <- either throw pure (Dhall.TypeCheck.typeOf resolved) + case decodeProfileExpr (Dhall.Core.normalize resolved) of + Just profile -> pure (Right profile) + Nothing -> pure (Left "Dhall value does not decode as an OKF profile descriptor") + +data RemoteImportsDisabled = RemoteImportsDisabled + deriving stock (Eq) + +instance Show RemoteImportsDisabled where + show RemoteImportsDisabled = "Remote imports are disabled during profile discovery" + +instance Exception RemoteImportsDisabled + +safelyFalse :: IO Bool -> IO Bool +safelyFalse action = + action `catch` \(_ :: SomeException) -> pure False diff --git a/src/Okf/Profile/Registry.hs b/src/Okf/Profile/Registry.hs --- a/src/Okf/Profile/Registry.hs +++ b/src/Okf/Profile/Registry.hs @@ -13,32 +13,56 @@ module Okf.Profile.Registry ( -- * References RegistryRef (..), + ProfileSource (..), defaultRegistryReference, resolveRegistryRef, renderRegistryRef, + renderProfileSourceLabel, + renderProfileSourceReference, + looksLikeRegistryPath, -- * Enumeration RegistryEntry (..), + RegistryLoadError (..), + registryLoadErrorCategory, + renderRegistryLoadErrorMessage, + SourceFailure (..), + ProfileSourceLoadError (..), + failedProfileSource, + profileSourceLoadErrorCategory, + renderProfileSourceLoadError, + SourcedProfile (..), loadRegistry, + loadRegistryDetailed, + loadProfileSource, + loadProfileSourceDetailed, + loadProfileSources, + loadProfileSourcesDetailed, + normalizeProfileSources, registryEntries, findRegistryEntry, + findSourcedProfiles, rootExportLabel, ) where -import Control.Exception (SomeException, catch) +import Control.Exception (SomeException, catch, fromException) import Data.List qualified as List import Data.Text qualified as Text import Data.Text.IO qualified as Text.IO import Data.Void (Void) import Dhall qualified import Dhall.Core (Expr (RecordLit), recordFieldValue) +import Dhall.Import qualified as Dhall.Import import Dhall.Map qualified +import Dhall.Parser qualified as Dhall.Parser import Dhall.Src (Src) +import Dhall.TypeCheck qualified as Dhall.TypeCheck import Okf.Prelude import Okf.Profile (ProfileSpec, decodeProfileExpr) +import Okf.Profile.Discovery (loadProfileDescriptorWithoutNetwork) import System.Directory (doesDirectoryExist, doesFileExist) -import System.FilePath (takeDirectory, ()) +import System.FilePath (normalise, takeBaseName, takeDirectory, takeFileName, ()) import "generic-lens" Data.Generics.Labels () -- | How a registry reference is to be evaluated. A file must be evaluated with @@ -51,6 +75,19 @@ RegistryExpression !Text deriving stock (Generic, Eq, Show) +-- | One place profiles can come from. The text is the reference exactly as the +-- user supplied it; the resolved reference records how it will be evaluated. +-- +-- This is deliberately a sum type even though registries are the only source +-- kind today. Other structural discovery mechanisms can add constructors +-- without overloading what a registry reference means. +data ProfileSource + = -- | A registry reference, as the user wrote it, and how it resolved. + RegistrySource !Text !RegistryRef + | -- | One descriptor file found by bounded, network-silent local discovery. + DescriptorSource !FilePath + deriving stock (Generic, Eq, Show) + -- | One profile published by a registry, under the dotted field path at which -- it was found. The export path is empty when the registry reference is itself -- a profile; 'rootExportLabel' is the display form for that case. @@ -60,6 +97,91 @@ } deriving stock (Generic, Eq, Show) +-- | A stable, user-facing classification of registry evaluation failures. +-- Dhall's exception renderers deliberately include source excerpts and ANSI +-- styling; those are useful to a language implementer but are not a suitable +-- command-line contract for a user trying to identify a bad source. +data RegistryLoadError + = RegistryDirectoryMissingPackage !FilePath + | RegistryPathNotFound !FilePath + | RegistryHashMismatch + | RegistryImportFailure + | RegistryInvalidDhall + | RegistryEvaluationFailure + deriving stock (Generic, Eq, Show) + +registryLoadErrorCategory :: RegistryLoadError -> Text +registryLoadErrorCategory = \case + RegistryDirectoryMissingPackage _path -> "directory-missing-package" + RegistryPathNotFound _path -> "path-not-found" + RegistryHashMismatch -> "hash-mismatch" + RegistryImportFailure -> "import-failure" + RegistryInvalidDhall -> "invalid-dhall" + RegistryEvaluationFailure -> "evaluation-failure" + +-- | Render a plain summary with no third-party exception text or terminal +-- escape sequences. The CLI adds the source identity and reference guidance. +renderRegistryLoadErrorMessage :: RegistryLoadError -> Text +renderRegistryLoadErrorMessage = \case + RegistryDirectoryMissingPackage path -> + "directory " + <> Text.pack path + <> " does not contain package.dhall; use `okf profiles` to discover loose descriptors and OKF_PROFILE_ROOTS to choose where it searches" + RegistryPathNotFound path -> + "registry path " <> Text.pack path <> " does not exist; check the spelling" + RegistryHashMismatch -> + "the registry import failed its integrity check; its content does not match the pinned hash" + RegistryImportFailure -> + "one or more registry imports could not be resolved; check local paths and network access" + RegistryInvalidDhall -> + "the registry is not valid, well-typed Dhall" + RegistryEvaluationFailure -> + "registry evaluation failed unexpectedly" + +-- | One source that could not be enumerated, together with the captured load +-- error. Multi-source survey operations report these without hiding entries +-- from sources that did load. +data SourceFailure = SourceFailure + { failedSource :: !ProfileSource, + failureReason :: !Text + } + deriving stock (Generic, Eq, Show) + +-- | A typed failure for one source. Registry errors retain their stable +-- category; descriptor errors remain a separate branch because descriptor +-- discovery uses a deliberately restricted, no-network evaluator. +data ProfileSourceLoadError + = RegistryProfileSourceLoadError !ProfileSource !RegistryLoadError + | DescriptorProfileSourceLoadError !ProfileSource + deriving stock (Generic, Eq, Show) + +failedProfileSource :: ProfileSourceLoadError -> ProfileSource +failedProfileSource = \case + RegistryProfileSourceLoadError profileSource _error -> profileSource + DescriptorProfileSourceLoadError profileSource -> profileSource + +profileSourceLoadErrorCategory :: ProfileSourceLoadError -> Text +profileSourceLoadErrorCategory = \case + RegistryProfileSourceLoadError _profileSource registryError -> + registryLoadErrorCategory registryError + DescriptorProfileSourceLoadError _profileSource -> "descriptor-load-failure" + +renderProfileSourceLoadError :: ProfileSourceLoadError -> Text +renderProfileSourceLoadError = \case + RegistryProfileSourceLoadError _profileSource registryError -> + renderRegistryLoadErrorMessage registryError + DescriptorProfileSourceLoadError _profileSource -> + "the local profile descriptor could not be read or decoded" + +-- | One registry entry paired with the source that published it. Provenance +-- wraps the existing source-agnostic 'RegistryEntry' rather than changing that +-- public type. +data SourcedProfile = SourcedProfile + { source :: !ProfileSource, + entry :: !RegistryEntry + } + deriving stock (Generic, Eq, Show) + -- | The built-in registry: the @okf-profiles@ package, pinned by tag /and/ -- integrity hash. Pinning gives Dhall's content-addressed cache something -- stable to key on, so listing costs one network fetch ever, and a later @@ -67,8 +189,8 @@ -- newer tag means changing the URL and the hash together. defaultRegistryReference :: Text defaultRegistryReference = - "https://raw.githubusercontent.com/shinzui/okf-profiles/v0.4.2/package.dhall\ - \ sha256:39e79b65672439cde9c1271e3d92abf68ba1e2427541598e0d04de23e741f0cb" + "https://raw.githubusercontent.com/shinzui/okf-profiles/v0.10.0/package.dhall\ + \ sha256:c6882a5cb6ece28027f5f9d219d323cff64f131b97ecbf536ed54d77263f5edf" -- | How an entry with an empty export path is displayed. rootExportLabel :: Text @@ -97,19 +219,196 @@ ) else pure (RegistryExpression reference) +-- | Whether text looks intended to name a filesystem path rather than a raw +-- Dhall expression. Remote URLs are excluded before checking path separators, +-- because both @https://@ and a hash-pinned URL contain slashes. +looksLikeRegistryPath :: Text -> Bool +looksLikeRegistryPath raw + | Text.null reference = False + | isRemoteReference lowered = False + | otherwise = + any (`Text.isPrefixOf` reference) ["./", "../", "~/", "/"] + || Text.any (\character -> character == '/' || character == '\\') reference + || ".dhall" `Text.isSuffixOf` Text.toLower reference + where + reference = Text.strip raw + lowered = Text.toLower reference + isRemoteReference value = + "http://" `Text.isPrefixOf` value || "https://" `Text.isPrefixOf` value + -- | Render a reference for display in messages. renderRegistryRef :: RegistryRef -> Text renderRegistryRef (RegistryFile path) = Text.pack path renderRegistryRef (RegistryExpression expression) = expression +-- | Render the complete user-facing identity of a source. Display labels are +-- intentionally not unique, so diagnostics that disambiguate sources use this +-- full reference instead. +renderProfileSourceReference :: ProfileSource -> Text +renderProfileSourceReference (RegistrySource reference _resolved) = reference +renderProfileSourceReference (DescriptorSource path) = Text.pack (normalise path) + +-- | Render a compact source label suitable for a table column. A local package +-- uses its directory name, a direct file uses its basename, and a raw GitHub +-- URL uses the repository name. Other expressions fall back to a bounded form +-- of the original reference. Labels are display text, not source identity. +renderProfileSourceLabel :: ProfileSource -> Text +renderProfileSourceLabel (RegistrySource original resolved) = + case resolved of + RegistryFile path + | takeFileName path == "package.dhall" -> Text.pack (takeFileName (takeDirectory path)) + | otherwise -> Text.pack (takeBaseName path) + RegistryExpression _expression -> + fromMaybe (truncateLabel (Text.strip original)) (rawGitHubRepository original) + where + rawGitHubRepository reference = + case Text.splitOn "/" (Text.strip reference) of + "https:" : "" : "raw.githubusercontent.com" : _owner : repository : _rest -> + nonEmptyText repository + "http:" : "" : "raw.githubusercontent.com" : _owner : repository : _rest -> + nonEmptyText repository + _ -> Nothing + + nonEmptyText value + | Text.null value = Nothing + | otherwise = Just value + + truncateLabel value + | Text.length value <= 32 = value + | otherwise = Text.take 31 value <> "…" +renderProfileSourceLabel (DescriptorSource _path) = "local" + -- | Evaluate a registry and enumerate the profiles it publishes. Any parse, -- import, type, or IO failure is captured as a human-readable 'Left', matching -- how 'Okf.Profile.loadProfileFile' behaves. loadRegistry :: RegistryRef -> IO (Either Text [RegistryEntry]) -loadRegistry reference = - (Right . registryEntries <$> evaluateRef reference) - `catch` \(e :: SomeException) -> pure (Left (Text.pack (show e))) +loadRegistry reference = first renderRegistryLoadErrorMessage <$> loadRegistryDetailed reference +-- | Evaluate a registry while preserving a stable error category. Path-like +-- expressions are checked before Dhall sees them so a missing file or a loose +-- descriptor directory produces an actionable message instead of an "unbound +-- variable" diagnostic. +loadRegistryDetailed :: RegistryRef -> IO (Either RegistryLoadError [RegistryEntry]) +loadRegistryDetailed reference = do + preflight <- registryReferencePreflight reference + case preflight of + Just registryError -> pure (Left registryError) + Nothing -> + (Right . registryEntries <$> evaluateRef reference) + `catch` \(exception :: SomeException) -> + pure (Left (classifyRegistryException exception)) + +registryReferencePreflight :: RegistryRef -> IO (Maybe RegistryLoadError) +registryReferencePreflight (RegistryFile path) = do + exists <- doesFileExist path + pure (if exists then Nothing else Just (RegistryPathNotFound path)) +registryReferencePreflight (RegistryExpression expression) = do + let pathExpression = fst (Text.breakOn " sha256:" (Text.strip expression)) + path = Text.unpack pathExpression + isDirectory <- doesDirectoryExist path + if isDirectory + then pure (Just (RegistryDirectoryMissingPackage path)) + else do + isFile <- doesFileExist path + pure + ( if looksLikeRegistryPath pathExpression && not isFile + then Just (RegistryPathNotFound path) + else Nothing + ) + +classifyRegistryException :: SomeException -> RegistryLoadError +classifyRegistryException exception + | isHashMismatch exception = RegistryHashMismatch + | isInvalidDhall exception = RegistryInvalidDhall + | Just (Dhall.Parser.SourcedException _source (Dhall.Import.MissingImports nested)) <- + fromException exception = + classifyMissingImports nested + | otherwise = RegistryEvaluationFailure + where + isHashMismatch caught = + isJust (fromException caught :: Maybe Dhall.Import.HashMismatch) + || isJust (fromException caught :: Maybe (Dhall.Import.Imported Dhall.Import.HashMismatch)) + + isInvalidDhall caught = + isJust (fromException caught :: Maybe Dhall.Parser.ParseError) + || isJust (fromException caught :: Maybe (Dhall.TypeCheck.TypeError Src Void)) + || isJust (fromException caught :: Maybe (Dhall.Import.Imported Dhall.Parser.ParseError)) + || isJust (fromException caught :: Maybe (Dhall.Import.Imported (Dhall.TypeCheck.TypeError Src Void))) + + classifyMissingImports nested + | any isHashMismatch nested = RegistryHashMismatch + | any isInvalidDhall nested = RegistryInvalidDhall + | otherwise = RegistryImportFailure + +-- | Load one profile source and attach it to every enumerated registry entry. +-- Pattern matches are exhaustive so adding another source kind requires its +-- loading behavior to be defined explicitly. +loadProfileSource :: ProfileSource -> IO (Either Text [SourcedProfile]) +loadProfileSource profileSource = + first renderProfileSourceLoadError <$> loadProfileSourceDetailed profileSource + +loadProfileSourceDetailed :: ProfileSource -> IO (Either ProfileSourceLoadError [SourcedProfile]) +loadProfileSourceDetailed profileSource@(RegistrySource _reference resolved) = + first (RegistryProfileSourceLoadError profileSource) + . fmap (map (SourcedProfile profileSource)) + <$> loadRegistryDetailed resolved +loadProfileSourceDetailed (DescriptorSource path) = do + loaded <- loadProfileDescriptorWithoutNetwork normalizedPath + pure $ + first (const (DescriptorProfileSourceLoadError normalizedSource)) $ + fmap + ( \profile -> + [ SourcedProfile + normalizedSource + RegistryEntry + { export = Text.pack (takeBaseName normalizedPath), + spec = profile + } + ] + ) + loaded + where + normalizedPath = normalise path + normalizedSource = DescriptorSource normalizedPath + +-- | Drop exact duplicate sources while preserving first-occurrence order. +-- Distinct sources are never deduplicated merely because their display labels +-- or export paths happen to collide. +normalizeProfileSources :: [ProfileSource] -> [ProfileSource] +normalizeProfileSources = List.nub . map normalizeSource + where + normalizeSource source@(RegistrySource _reference _resolved) = source + normalizeSource (DescriptorSource path) = DescriptorSource (normalise path) + +-- | Enumerate several sources in the order given. Results remain grouped by +-- source position, while 'registryEntries' keeps each source internally sorted +-- by export path. A failure from one source is returned alongside successful +-- entries from every other source rather than hiding them. +loadProfileSources :: [ProfileSource] -> IO ([SourceFailure], [SourcedProfile]) +loadProfileSources sources = do + (failures, profiles) <- loadProfileSourcesDetailed sources + pure + ( [ SourceFailure + { failedSource = failedProfileSource profileSourceError, + failureReason = renderProfileSourceLoadError profileSourceError + } + | profileSourceError <- failures + ], + profiles + ) + +loadProfileSourcesDetailed :: [ProfileSource] -> IO ([ProfileSourceLoadError], [SourcedProfile]) +loadProfileSourcesDetailed sources = go (normalizeProfileSources sources) [] [] + where + go [] failures profiles = pure (reverse failures, reverse profiles) + go (profileSource : rest) failures profiles = do + loaded <- loadProfileSourceDetailed profileSource + case loaded of + Left reason -> + go rest (reason : failures) profiles + Right sourceProfiles -> + go rest failures (reverse sourceProfiles <> profiles) + -- | Parse, resolve imports, type check, and normalize a registry reference. evaluateRef :: RegistryRef -> IO (Expr Src Void) evaluateRef (RegistryFile path) = do @@ -172,3 +471,8 @@ -- | Look up an entry by its exact export path. findRegistryEntry :: Text -> [RegistryEntry] -> Maybe RegistryEntry findRegistryEntry path = List.find ((== path) . (^. #export)) + +-- | Find every source that publishes an exact export path. A list result makes +-- collisions explicit instead of silently choosing the first match. +findSourcedProfiles :: Text -> [SourcedProfile] -> [SourcedProfile] +findSourcedProfiles path = List.filter ((== path) . (^. #entry . #export)) diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -29,6 +29,7 @@ -- reached as 'Profile.HumanActor'. import Okf.Profile hiding (HumanActor) import Okf.Profile qualified as Profile +import Okf.Profile.Discovery qualified as ProfileDiscovery import Okf.Profile.Documentation import Okf.Profile.Registry import Okf.Query @@ -36,9 +37,11 @@ import Okf.Validation import System.Directory ( createDirectoryIfMissing, + createFileLink, doesDirectoryExist, doesFileExist, getTemporaryDirectory, + makeAbsolute, removeDirectoryRecursive, ) import System.Exit (exitFailure) @@ -169,9 +172,27 @@ test "handle reference JSON encoding is stable" testHandleReferenceJsonShape, test "field format JSON encoding is stable" testFieldFormatJsonShape, testIO "loadRegistry enumerates nested profiles and skips non-profiles" testRegistryEnumeratesProfiles, + testIO "loadRegistry decodes every profile in the pinned catalogue snapshot" testPinnedCatalogueDecodes, testIO "loadRegistry reports a bare profile as a root entry" testRegistryRootProfile, testIO "resolveRegistryRef prefers package.dhall inside a directory" testResolveRegistryRef, testIO "loadRegistry reports a missing registry as Left" testRegistryLoadFailure, + test "registry path intent is classified without mistaking remote URLs for paths" testLooksLikeRegistryPath, + testIO "loadRegistryDetailed classifies actionable failures without rendered Dhall text" testRegistryDetailedFailures, + testIO "profile discovery finds valid descriptors without pruning" testDiscoverProfileDescriptors, + testIO "profile discovery excludes every non-descriptor fixture" testProfileDescriptorQualification, + testIO "profile discovery treats a missing root as empty" testProfileDiscoveryMissingRoot, + testIO "profile discovery skips symbolic links" testProfileDiscoverySkipsSymlink, + testIO "profile discovery honours maxDepth" testProfileDiscoveryHonoursMaxDepth, + testIO "profile discovery rejects remote text and bytes before I/O" testProfileDiscoveryRejectsRemote, + test "profile source labels are compact and readable" testProfileSourceLabels, + testIO "loadProfileSource attaches source provenance" testProfileSourceWrapper, + testIO "DescriptorSource enumerates one basename export" testDescriptorSourceWrapper, + testIO "DescriptorSource reports a non-profile as a source failure" testDescriptorSourceFailure, + testIO "loadProfileSources merges registries in source order" testProfileSourcesMergeInOrder, + testIO "loadProfileSources merges registry and descriptor sources in order" testMixedProfileSourcesMergeInOrder, + testIO "loadProfileSources retains entries after a partial failure" testProfileSourcesPartialFailure, + testIO "findSourcedProfiles exposes cross-source collisions" testProfileSourcesExposeCollisions, + testIO "loadProfileSources drops exact duplicate references" testProfileSourcesDropDuplicates, test "parseDocumentId accepts only canonical handles" testParseDocumentId, testIO "documentIdsInBundle sorts handles by prefix and number" testDocumentIdsInBundle, test "nextDocumentId skips gaps and starts unused prefixes at one" testNextDocumentId, @@ -3032,6 +3053,36 @@ "expected findRegistryEntry to resolve the nested export" (isJust (findRegistryEntry "nested.decisions" entries)) +-- | The built-in registry pin and this offline snapshot move together. Loading +-- the snapshot catches a catalogue descriptor that the current decoder cannot +-- read without making the test suite depend on GitHub or Dhall's cache. +testPinnedCatalogueDecodes :: IO (Either Text ()) +testPinnedCatalogueDecodes = do + path <- fixtureFilePath "catalogue/package.dhall" + loaded <- loadRegistry (RegistryFile path) + pure $ case loaded of + Left err -> Left ("failed to load pinned catalogue snapshot: " <> err) + Right entries -> do + assertEqual + [ "coordination.bugReports", + "coordination.capabilities", + "coordination.improvementRequests", + "coordination.useCases", + "documentation.architectureDecisions", + "documentation.patternCatalog", + "documentation.researchDocuments", + "okfV02", + "postgresql", + "tanPostgresql" + ] + (List.sort (map (^. #export) entries)) + assertBool + "expected every pinned catalogue profile to have a non-empty name" + (all (not . Text.null . (^. #spec . #name)) entries) + assertBool + "expected every pinned catalogue profile to have a non-empty okfVersion" + (all (not . Text.null . (^. #spec . #okfVersion)) entries) + -- | A registry reference that is itself a profile yields one entry whose export -- path is empty. testRegistryRootProfile :: IO (Either Text ()) @@ -3065,6 +3116,258 @@ pure $ case loaded of Right entries -> Left ("expected a load failure, got " <> Text.pack (show (length entries)) <> " entries") Left message -> assertBool "expected a non-empty error message" (not (Text.null message)) + +testLooksLikeRegistryPath :: Either Text () +testLooksLikeRegistryPath = do + assertEqual + [True, True, True, True, True, True, False, False, False] + ( map + looksLikeRegistryPath + [ "./profiles/package.dhall", + "../profiles/package.dhall", + "/profiles/package.dhall", + "~/profiles/package.dhall", + "profiles/package.dhall", + "profile.dhall", + "https://example.test/package.dhall sha256:abc", + "http://example.test/package.dhall", + "{ profile = 1 }" + ] + ) + +testRegistryDetailedFailures :: IO (Either Text ()) +testRegistryDetailedFailures = + withDiscoveryTree "okf-registry-errors" [] $ \root -> do + profilePath <- fixtureFilePath "profiles/decisions.dhall" + absoluteProfilePath <- makeAbsolute profilePath + directoryResult <- loadRegistryDetailed (RegistryExpression (Text.pack root)) + missingResult <- loadRegistryDetailed (RegistryExpression (Text.pack (root "missing" "package.dhall"))) + invalidResult <- loadRegistryDetailed (RegistryExpression "{ profile =") + hashResult <- + loadRegistryDetailed + ( RegistryExpression + ( Text.pack absoluteProfilePath + <> " sha256:0000000000000000000000000000000000000000000000000000000000000000" + ) + ) + pure $ do + assertEqual (Left (RegistryDirectoryMissingPackage root)) directoryResult + assertEqual (Left (RegistryPathNotFound (root "missing" "package.dhall"))) missingResult + assertEqual (Left RegistryInvalidDhall) invalidResult + assertEqual (Left RegistryHashMismatch) hashResult + assertBool + "typed summaries must not contain ANSI escape bytes" + ( all + (not . Text.isInfixOf "\ESC[") + [ renderRegistryLoadErrorMessage (RegistryDirectoryMissingPackage root), + renderRegistryLoadErrorMessage RegistryHashMismatch, + renderRegistryLoadErrorMessage RegistryInvalidDhall + ] + ) + +testDiscoverProfileDescriptors :: IO (Either Text ()) +testDiscoverProfileDescriptors = do + root <- fixturePath "profile-discovery" + found <- + ProfileDiscovery.discoverProfileDescriptors + ProfileDiscovery.defaultProfileDiscoveryOptions + root + pure $ + assertEqual + [ normalise (root "nested" "valid-nested.dhall"), + normalise (root "valid.dhall") + ] + found + +testProfileDescriptorQualification :: IO (Either Text ()) +testProfileDescriptorQualification = do + valid <- fixtureFilePath "profile-discovery/valid.dhall" + registry <- fixtureFilePath "profile-discovery/registry.dhall" + notProfile <- fixtureFilePath "profile-discovery/not-a-profile.dhall" + invalid <- fixtureFilePath "profile-discovery/invalid.dhall" + ignoredFile <- fixtureFilePath "profile-discovery/ignored.txt" + results <- + traverse + ProfileDiscovery.fileQualifiesAsProfileDescriptor + [valid, registry, notProfile, invalid, ignoredFile] + pure (assertEqual [True, False, False, False, False] results) + +testProfileDiscoveryMissingRoot :: IO (Either Text ()) +testProfileDiscoveryMissingRoot = do + found <- + ProfileDiscovery.discoverProfileDescriptors + ProfileDiscovery.defaultProfileDiscoveryOptions + "/nonexistent/okf-profile-discovery-root" + pure (assertEqual [] found) + +testProfileDiscoverySkipsSymlink :: IO (Either Text ()) +testProfileDiscoverySkipsSymlink = + withDiscoveryTree "okf-profile-discovery-symlink" [] $ \root -> do + target <- fixtureFilePath "profile-discovery/valid.dhall" >>= makeAbsolute + createFileLink target (root "linked.dhall") + found <- + ProfileDiscovery.discoverProfileDescriptors + ProfileDiscovery.defaultProfileDiscoveryOptions + root + pure (assertEqual [] found) + +testProfileDiscoveryHonoursMaxDepth :: IO (Either Text ()) +testProfileDiscoveryHonoursMaxDepth = do + root <- fixturePath "profile-discovery" + shallow <- + ProfileDiscovery.discoverProfileDescriptors + ProfileDiscovery.defaultProfileDiscoveryOptions + root + deeper <- + ProfileDiscovery.discoverProfileDescriptors + ProfileDiscovery.defaultProfileDiscoveryOptions {ProfileDiscovery.maxDepth = 6} + root + let deepest = normalise (root "deep" "a" "b" "c" "d" "e" "valid-too-deep.dhall") + pure $ do + assertBool "default depth should exclude the deep descriptor" (deepest `notElem` shallow) + assertBool "expanded depth should include the deep descriptor" (deepest `elem` deeper) + +testProfileDiscoveryRejectsRemote :: IO (Either Text ()) +testProfileDiscoveryRejectsRemote = do + textRemote <- fixtureFilePath "profile-discovery/remote.dhall" + bytesRemote <- fixtureFilePath "profile-discovery/remote-bytes.dhall" + loaded <- traverse ProfileDiscovery.loadProfileDescriptorWithoutNetwork [textRemote, bytesRemote] + qualifies <- traverse ProfileDiscovery.fileQualifiesAsProfileDescriptor [textRemote, bytesRemote] + pure $ do + for_ loaded $ \case + Right profile -> Left ("expected remote descriptor rejection, decoded " <> profile ^. #name) + Left message -> + assertBool + "expected the dedicated no-network callback to reject the import" + ("Remote imports are disabled during profile discovery" `Text.isInfixOf` message) + assertEqual [False, False] qualifies + +testProfileSourceLabels :: Either Text () +testProfileSourceLabels = do + assertEqual + "okf-profiles" + ( renderProfileSourceLabel + (RegistrySource defaultRegistryReference (RegistryExpression defaultRegistryReference)) + ) + assertEqual + "okf-v0-2" + ( renderProfileSourceLabel + (RegistrySource "docs/profiles/okf-v0-2.dhall" (RegistryFile "docs/profiles/okf-v0-2.dhall")) + ) + assertEqual "local" (renderProfileSourceLabel (DescriptorSource "docs/profiles/okf-v0-2.dhall")) + assertEqual + (Text.pack (normalise "docs/profiles/../profiles/okf-v0-2.dhall")) + (renderProfileSourceReference (DescriptorSource "docs/profiles/../profiles/okf-v0-2.dhall")) + +-- | Loading one source wraps every otherwise unchanged registry entry with its +-- provenance. +testProfileSourceWrapper :: IO (Either Text ()) +testProfileSourceWrapper = do + path <- fixtureFilePath "profiles/decisions.dhall" + let profileSource = RegistrySource (Text.pack path) (RegistryFile path) + loaded <- loadProfileSource profileSource + pure $ case loaded of + Left err -> Left ("failed to load sourced profile fixture: " <> err) + Right profiles -> do + assertEqual [profileSource] (map (^. #source) profiles) + assertEqual [""] (map (^. #entry . #export) profiles) + +testDescriptorSourceWrapper :: IO (Either Text ()) +testDescriptorSourceWrapper = do + path <- fixtureFilePath "profile-discovery/valid.dhall" + let profileSource = DescriptorSource (normalise path) + loaded <- loadProfileSource (DescriptorSource (takeDirectory path "." "valid.dhall")) + pure $ case loaded of + Left err -> Left ("failed to load descriptor source fixture: " <> err) + Right profiles -> do + assertEqual [profileSource] (map (^. #source) profiles) + assertEqual ["valid"] (map (^. #entry . #export) profiles) + +testDescriptorSourceFailure :: IO (Either Text ()) +testDescriptorSourceFailure = do + path <- fixtureFilePath "profile-discovery/not-a-profile.dhall" + let profileSource = DescriptorSource path + (failures, profiles) <- loadProfileSources [profileSource] + pure $ do + assertEqual [] profiles + assertEqual [DescriptorSource (normalise path)] (map (^. #failedSource) failures) + assertBool + "expected the descriptor decode failure to carry a reason" + (all (not . Text.null . (^. #failureReason)) failures) + +-- | Multi-source enumeration preserves source order and each registry's +-- export ordering rather than globally interleaving equal-looking paths. +testProfileSourcesMergeInOrder :: IO (Either Text ()) +testProfileSourcesMergeInOrder = do + (publicSource, houseSource) <- fixtureProfileSources + (failures, profiles) <- loadProfileSources [publicSource, houseSource] + pure $ do + assertEqual [] failures + assertEqual + [ "legacy", + "nested.decisions", + "postgresql", + "postgresql", + "runbooks" + ] + (map (^. #entry . #export) profiles) + assertEqual + (replicate 3 publicSource <> replicate 2 houseSource) + (map (^. #source) profiles) + +testMixedProfileSourcesMergeInOrder :: IO (Either Text ()) +testMixedProfileSourcesMergeInOrder = do + (publicSource, _houseSource) <- fixtureProfileSources + descriptorPath <- fixtureFilePath "profile-discovery/valid.dhall" + let descriptorSource = DescriptorSource (normalise descriptorPath) + (failures, profiles) <- loadProfileSources [publicSource, descriptorSource] + pure $ do + assertEqual [] failures + assertEqual + ["legacy", "nested.decisions", "postgresql", "valid"] + (map (^. #entry . #export) profiles) + assertEqual + (replicate 3 publicSource <> [descriptorSource]) + (map (^. #source) profiles) + +testProfileSourcesPartialFailure :: IO (Either Text ()) +testProfileSourcesPartialFailure = do + (_publicSource, houseSource) <- fixtureProfileSources + let missingSource = RegistrySource "/nonexistent/registry.dhall" (RegistryFile "/nonexistent/registry.dhall") + (failures, profiles) <- loadProfileSources [missingSource, houseSource] + pure $ do + assertEqual [missingSource] (map (^. #failedSource) failures) + assertBool + "expected the captured source failure to include a reason" + (all (not . Text.null . (^. #failureReason)) failures) + assertEqual ["postgresql", "runbooks"] (map (^. #entry . #export) profiles) + +testProfileSourcesExposeCollisions :: IO (Either Text ()) +testProfileSourcesExposeCollisions = do + (publicSource, houseSource) <- fixtureProfileSources + (_failures, profiles) <- loadProfileSources [publicSource, houseSource] + pure $ + assertEqual + [publicSource, houseSource] + (map (^. #source) (findSourcedProfiles "postgresql" profiles)) + +testProfileSourcesDropDuplicates :: IO (Either Text ()) +testProfileSourcesDropDuplicates = do + (_publicSource, houseSource) <- fixtureProfileSources + (failures, profiles) <- loadProfileSources [houseSource, houseSource] + pure $ do + assertEqual [] failures + assertEqual [houseSource] (normalizeProfileSources [houseSource, houseSource]) + assertEqual ["postgresql", "runbooks"] (map (^. #entry . #export) profiles) + +fixtureProfileSources :: IO (ProfileSource, ProfileSource) +fixtureProfileSources = do + publicPath <- fixtureFilePath "registry/package.dhall" + housePath <- fixtureFilePath "registry-house/package.dhall" + pure + ( RegistrySource (Text.pack publicPath) (RegistryFile publicPath), + RegistrySource (Text.pack housePath) (RegistryFile housePath) + ) testParseDocumentId :: Either Text () testParseDocumentId = do diff --git a/test/fixtures/catalogue/Profile/FrontmatterRules.dhall b/test/fixtures/catalogue/Profile/FrontmatterRules.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/Profile/FrontmatterRules.dhall @@ -0,0 +1,5 @@ +--| Schema for a profile's frontmatter expectations. +-- +-- Both the type and its defaults come from okf's pinned canonical schema so this +-- package cannot accidentally drift from the decoder. +let okf = ./okf.dhall in okf.defaults.FrontmatterRules diff --git a/test/fixtures/catalogue/Profile/ReviewRule.dhall b/test/fixtures/catalogue/Profile/ReviewRule.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/Profile/ReviewRule.dhall @@ -0,0 +1,98 @@ +--| Shared rule for optional review provenance used by coordination and research +-- profiles. When `reviews` is present, every element has a bounded record shape; +-- model reviews additionally require provider, model, and effort metadata. +let okf = ./okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let NestedFieldRule = okf.defaults.NestedFieldRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let condition = + \(field : Text) -> \(hasValue : List Text) -> { field, hasValue } + +let modelOnly = Some (condition "kind" [ "model" ]) + +in FieldRule::{ + , field = "reviews" + , description = Some + "Chronological human or model review provenance for this document revision." + , cardinality = Cardinality.List + , elementFields = Some + { required = + [ NestedFieldRule::{ + , field = "kind" + , description = Some "Whether a human or model performed the review." + , allowedValues = [ "human", "model" ] + , cardinality = Cardinality.Scalar + } + , NestedFieldRule::{ + , field = "reviewer" + , description = Some + "Stable identity of the reviewing person or agent." + , cardinality = Cardinality.Scalar + } + , NestedFieldRule::{ + , field = "reviewed_at" + , description = Some "UTC time at which the review completed." + , cardinality = Cardinality.Scalar + , format = Some FieldFormat.Rfc3339Utc + } + , NestedFieldRule::{ + , field = "document_timestamp" + , description = Some + "Document revision timestamp covered by the review." + , cardinality = Cardinality.Scalar + , format = Some FieldFormat.Rfc3339Utc + } + , NestedFieldRule::{ + , field = "scope" + , description = Some "Aspect of the document covered by the review." + , allowedValues = + [ "content" + , "technical-accuracy" + , "editorial" + , "catalog-metadata" + , "content-and-metadata" + ] + , cardinality = Cardinality.Scalar + } + , NestedFieldRule::{ + , field = "outcome" + , description = Some "Result recorded by the reviewer." + , allowedValues = [ "approved", "changes-requested", "commented" ] + , cardinality = Cardinality.Scalar + } + , NestedFieldRule::{ + , field = "context" + , description = Some + "Evidence and repository context used for the review." + , cardinality = Cardinality.Scalar + } + , NestedFieldRule::{ + , field = "provider" + , description = Some "Serving provider for a model review." + , cardinality = Cardinality.Scalar + , when = modelOnly + } + , NestedFieldRule::{ + , field = "model" + , description = Some "Most specific available model identifier." + , cardinality = Cardinality.Scalar + , when = modelOnly + } + , NestedFieldRule::{ + , field = "effort" + , description = Some "Provider-reported reasoning or thinking effort." + , allowedValues = [ "low", "medium", "high", "xhigh", "unspecified" ] + , cardinality = Cardinality.Scalar + , when = modelOnly + } + ] + , recommended = [] : List NestedFieldRule.Type + , optional = [] : List NestedFieldRule.Type + } + } diff --git a/test/fixtures/catalogue/Profile/Type.dhall b/test/fixtures/catalogue/Profile/Type.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/Profile/Type.dhall @@ -0,0 +1,15 @@ +--| Record-completion schema for a complete OKF house profile. +-- +-- A profile is a declarative description of how a team uses the Open Knowledge +-- Format (OKF): which `type:` strings are allowed, which frontmatter keys are +-- required, what `resource:` URI scheme each type needs, where each type's files +-- must live, and what columns a `# Schema` table must have. +-- +-- Profiles are NOT part of the OKF standard. A bundle that deviates from a +-- profile remains fully OKF-conformant; profiles are house conventions layered +-- on top, checked (advisory by default) with `okf validate --profile`. +-- +-- Both the type and its defaults come from okf's pinned canonical schema so this +-- package cannot accidentally drift from the decoder. Values are built with +-- completion: `Profile::{ name = "…", types = [ … ] }`. +let okf = ./okf.dhall in okf.defaults.Profile diff --git a/test/fixtures/catalogue/Profile/TypeRule.dhall b/test/fixtures/catalogue/Profile/TypeRule.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/Profile/TypeRule.dhall @@ -0,0 +1,5 @@ +--| Schema for a single per-`type` rule inside an OKF house profile. +-- +-- Both the type and its defaults come from okf's pinned canonical schema so this +-- package cannot accidentally drift from the decoder. +let okf = ./okf.dhall in okf.defaults.TypeRule diff --git a/test/fixtures/catalogue/Profile/V02.dhall b/test/fixtures/catalogue/Profile/V02.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/Profile/V02.dhall @@ -0,0 +1,265 @@ +--| The six OKF v0.2 frontmatter families, described once for the whole catalog. +-- +-- Every profile in this repository that adopts OKF v0.2 splices its rules from +-- here rather than re-authoring them, so that a correction lands in one place +-- instead of drifting across seven files. Import it and name what you need: +-- +-- let v02 = ../../Profile/V02.dhall +-- +-- in Profile::{ okfVersion = "0.2", frontmatter = FrontmatterRules::{ +-- , required = [ …, v02.generated ] +-- , optional = [ v02.verified, v02.legacyTimestamp ] +-- } } +-- +-- A consuming profile may reword a rule with the `//` operator: +-- +-- v02.generated // { description = Some "How this decision record was produced." } +-- +-- but must not redefine the constraint. If a shared value is wrong for one +-- profile it is wrong for all of them: fix it here and re-verify every consumer. +-- +-- Descriptions are deliberately short. okf echoes a rule's description back +-- inside its missing-field diagnostic, so a paragraph there produces an +-- unreadable error line; explanations belong in comments like this one. They are +-- also worded to make sense in *any* profile in this catalog, since all of them +-- surface the same text. +-- +-- The assembled, standalone form of these values ships as `../profiles/okf-v0-2.dhall` +-- (exported as `okfV02`), a format-level reference profile for a team with no +-- house conventions. +-- +-- +-- ## Policy one: where the house `status` key collides, the house key wins +-- +-- OKF v0.2 §5.4 gives `status` the vocabulary `draft` / `stable` / `deprecated`. +-- Seven profiles in this repository use the same key name for a house lifecycle +-- vocabulary — five that predate v0.2, and two introduced after it that answer a +-- question v0.2's vocabulary cannot: +-- +-- * `documentation.architectureDecisions` — `Accepted`, and siblings +-- * `documentation.patternCatalog` — `current`, `deprecated` +-- * `documentation.researchDocuments` — `active`, `complete`, `superseded` +-- * `coordination.improvementRequests` — `proposed`, `accepted`, `in-progress`, +-- `completed`, `rejected`, `withdrawn`, +-- `superseded` +-- * `coordination.useCases` — `draft`, `validated`, `planned`, +-- `in-progress`, `delivered`, `retired` +-- * `coordination.capabilities` — `shipped`, `deprecated`, `withdrawn` +-- * `coordination.bugReports` — `reported`, `confirmed`, `in-progress`, +-- `fixed`, `wont-fix`, `duplicate`, +-- `not-a-bug`, `cannot-reproduce` +-- +-- Those seven keep their house vocabulary and do **not** splice in `status` or +-- `staleAfter` from this module. This is sanctioned rather than tolerated: a +-- profile key name does not imply the OKF core key of that name, and okf never +-- rejects a profile over it. What okf checks instead is value *formats*, because +-- a format has no house-convention reading. +-- +-- Renaming the house key was considered and rejected — it would break every +-- consumer corpus, every cross-repository citation, and every downstream query, +-- for no conformance gain. The accepted consequence is that `okf trust` prints +-- the house value verbatim as a status it does not recognise. +-- +-- Profiles with no collision — `postgresql`, `tanPostgresql`, and the `okfV02` +-- reference profile — do declare both `status` and `staleAfter`. +-- +-- +-- ## Policy two: the house `reviews` family and OKF `verified` coexist +-- +-- `./ReviewRule.dhall` defines a rich house review record — reviewer identity, +-- review scope, outcome, serving provider, model identifier, reasoning effort, +-- and evidence context — used by `coordination.improvementRequests`, +-- `coordination.useCases`, and `documentation.researchDocuments`. OKF `verified` +-- records only `by` and `at`. +-- +-- Neither is a superset of the other, so neither replaces the other. Dropping +-- `reviews` would destroy information three profiles already collect; omitting +-- `verified` would leave `okf trust` reporting every concept as `unverified` +-- even where a human approved it. Both are declared, and a producer that records +-- an approving `reviews` entry should mirror it into `verified` so the derived +-- trust tier is accurate. +-- +-- +-- ## Do not declare a `trust` key +-- +-- A document's trust tier is computed on every read from `verified` and is never +-- written into a bundle. A document carrying `trust:` is carrying an ordinary +-- extension field that okf ignores. +let okf = ./okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let NestedRules = okf.defaults.NestedRules + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let field = okf.mk.FieldRule + +let nested = okf.mk.NestedFieldRule + +-- §5.2. `by` is REQUIRED within a trust record; `at` is the timestamp. The same +-- member rules describe `generated` and each `verified` entry, so they are +-- written once and shared. +let trustMembers = + NestedRules::{ + , required = + [ -- §7 states that producers MUST use the `human:` prefix for + -- hand-authored content, because §5.3 makes that prefix the sole + -- discriminator between the machine-confirmed and human-reviewed + -- trust tiers. The `actor` format checks the shape; a profile that + -- wants to demand the human tier uses `nested.humanActor` instead. + nested.documented + "by" + "§7. The actor responsible: `/`, `human:`, or `process:`." + // { format = Some FieldFormat.Actor } + ] + , recommended = + [ nested.documented + "at" + "UTC RFC3339 timestamp, ending in `Z`, for when this happened." + // { format = Some FieldFormat.Rfc3339Utc } + ] + } + +-- §5.2. A mapping, not a list: content is produced once. Supersedes the v0.1 +-- `timestamp` key per §13.1 — see `legacyTimestamp` below. +let generated = + field.record "generated" trustMembers + // { description = Some + "§5.2. How this content was produced. Supersedes the v0.1 `timestamp` key." + } + +-- §5.2 permits `verified` as a list of mappings or as one bare mapping, and +-- requires a consumer to treat the bare mapping as a one-element list. +-- `recordOrList` declares both spellings against the same member rules, so +-- either is accepted and both are checked. +-- +-- Place this in a profile's `optional` list, not `recommended`: §11 forbids +-- treating a missing optional family as a deficiency, so demanding it would make +-- `--strict` complain about every unverified concept. +let verified = + field.recordOrList "verified" trustMembers + // { description = Some + "§5.2. Independent confirmations that the content is accurate. A list of mappings, or one bare mapping." + } + +-- §5.4. Absence means `stable`, so this is never demanded. +-- +-- Do NOT splice this into a profile that already uses `status` for a house +-- lifecycle vocabulary — see Policy one in the header. +let status = + FieldRule::{ + , field = "status" + , description = Some + "§5.4. Lifecycle state. Absence means `stable`, so this is never demanded." + , allowedValues = [ "draft", "stable", "deprecated" ] + , cardinality = Cardinality.Scalar + } + +-- §5.5. Advisory: okf records the date but does not compare it against the +-- clock during validation. A concept is stale when `today >= stale_after`, +-- inclusive. +let staleAfter = + FieldRule::{ + , field = "stale_after" + , description = Some + "§5.5. Calendar date after which the content should be re-confirmed." + , cardinality = Cardinality.Scalar + , format = Some FieldFormat.Date + } + +-- §5.1. Only `resource` is required within an entry. +let sourceMembers = + NestedRules::{ + , required = + [ -- Deliberately no path rule. §5.1 says this names either a concrete + -- artifact a consumer can follow or a population or scope descriptor + -- it cannot, so demanding a resolvable path is a house convention + -- rather than a v0.2 rule. A profile that wants one writes + -- `nested.localOrExternalPath "resource" [ "https" ]`. + nested.documented + "resource" + "§5.1. What the source is: a followable artifact, or a scope descriptor." + ] + , optional = + [ nested.documented + "id" + "§5.1. Short label for this entry, used to cite it from a footnote in the body." + , nested.documented "title" "§5.1. Human-readable name for the source." + , nested.documented + "author" + "§5.1. Who or what produced the source, per the §7 actor convention." + // { format = Some FieldFormat.Actor } + , -- A YAML integer, not a quoted string: coercing `"40"` would hide a + -- producer mistake, so okf does not read it. + nested.documented + "usage_count" + "§5.1. How many times the source was drawn on. A count, so never negative." + // { format = Some FieldFormat.NonNegativeInteger } + , nested.documented + "last_modified" + "§5.1. Calendar date the source itself last changed." + // { format = Some FieldFormat.Date } + ] + } + +let sources = + field.recordList "sources" sourceMembers + // { description = Some + "§5.1. What this content was derived from, one entry per source." + } + +-- §5.1. A sibling of `sources`, not a member of it: it frames every entry's +-- usage count. +let usageWindowMembers = + NestedRules::{ + , optional = + [ nested.documented "from" "§5.1. Calendar date the window opens." + // { format = Some FieldFormat.Date } + , nested.documented "to" "§5.1. Calendar date the window closes." + // { format = Some FieldFormat.Date } + ] + } + +let usageWindow = + field.record "usage_window" usageWindowMembers + // { description = Some + "§5.1. The period the sources were observed over, when one applies to the whole concept." + } + +-- The superseded v0.1 key, for placement in a profile's `optional` list ONLY. +-- +-- As of okf 0.5.0.0 a profile's declared `okfVersion` is compile-checked against +-- the rules it declares. Putting this rule in `required` or `recommended` +-- alongside `okfVersion = "0.2"` is a hard profile load failure: +-- +-- Failed to load profile …: invalid profile definition: +-- - profile frontmatter: declared okfVersion 0.2 supersedes the frontmatter +-- key timestamp (OKF 0.2); move it to the optional list or replace it +-- with generated +-- +-- `optional` is the right presence class and is explicitly legal: the key is +-- never reported when absent, in any mode, while its RFC3339-UTC format is still +-- checked whenever it is present. okf reads `timestamp` whenever `generated` is +-- absent, silently and with no removal horizon, so keeping the rule lets a +-- half-migrated corpus keep validating without letting a malformed legacy +-- timestamp through unnoticed. +let legacyTimestamp = + field.rfc3339Utc "timestamp" + // { description = Some + "Superseded v0.1 revision timestamp. Prefer `generated.at`; keep this in `optional` only." + } + +in { trustMembers + , generated + , verified + , status + , staleAfter + , sourceMembers + , sources + , usageWindowMembers + , usageWindow + , legacyTimestamp + } diff --git a/test/fixtures/catalogue/Profile/okf.dhall b/test/fixtures/catalogue/Profile/okf.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/Profile/okf.dhall @@ -0,0 +1,12633 @@ +{ Cardinality = < Any | List | Scalar > +, FieldCondition = { field : Text, hasValue : List Text } +, FieldFormat = + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > +, FieldRule = + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } +, FrontmatterRules = + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } +, HandleReferenceRule = + { allowSelf : Bool, externalUriSchemes : List Text, localPrefix : Text } +, NestedFieldRule = + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } +, NestedRules = + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } +, PathReferenceRule = { allowSelf : Bool, externalUriSchemes : List Text } +, Profile = + { allowUnknownFields : Bool + , allowUnknownTypes : Bool + , description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idField : Optional Text + , name : Text + , okfVersion : Text + , requireBundleVersion : Optional Text + , types : + List + { description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idPrefix : Optional Text + , pathPattern : Optional Text + , requireSchemaSection : Bool + , resourceScheme : Optional Text + , schemaColumns : List Text + , type : Text + } + } +, TypeRule = + { description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idPrefix : Optional Text + , pathPattern : Optional Text + , requireSchemaSection : Bool + , resourceScheme : Optional Text + , schemaColumns : List Text + , type : Text + } +, defaults = + { FieldRule = + { Type = + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , default = + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + } + , FrontmatterRules = + { Type = + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , default = + { optional = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + } + , HandleReferenceRule = + { Type = + { allowSelf : Bool, externalUriSchemes : List Text, localPrefix : Text } + , default = { allowSelf = False, externalUriSchemes = [] : List Text } + } + , NestedFieldRule = + { Type = + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , default = + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + } + , NestedRules = + { Type = + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , default = + { optional = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + } + , PathReferenceRule = + { Type = { allowSelf : Bool, externalUriSchemes : List Text } + , default = { allowSelf = False, externalUriSchemes = [] : List Text } + } + , Profile = + { Type = + { allowUnknownFields : Bool + , allowUnknownTypes : Bool + , description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idField : Optional Text + , name : Text + , okfVersion : Text + , requireBundleVersion : Optional Text + , types : + List + { description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idPrefix : Optional Text + , pathPattern : Optional Text + , requireSchemaSection : Bool + , resourceScheme : Optional Text + , schemaColumns : List Text + , type : Text + } + } + , default = + { allowUnknownFields = True + , allowUnknownTypes = True + , description = None Text + , frontmatter = + { optional = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idField = None Text + , okfVersion = "0.1" + , requireBundleVersion = None Text + , types = + [] : List + { description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + } + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + } + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text + , hasValue : List Text + } + } + } + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : + Optional { field : Text, hasValue : List Text } + } + } + , idPrefix : Optional Text + , pathPattern : Optional Text + , requireSchemaSection : Bool + , resourceScheme : Optional Text + , schemaColumns : List Text + , type : Text + } + } + } + , TypeRule = + { Type = + { description : Optional Text + , frontmatter : + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idPrefix : Optional Text + , pathPattern : Optional Text + , requireSchemaSection : Bool + , resourceScheme : Optional Text + , schemaColumns : List Text + , type : Text + } + , default = + { description = None Text + , frontmatter = + { optional = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required = + [] : List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : + Optional + { field : Text, hasValue : List Text } + } + } + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , idPrefix = None Text + , pathPattern = None Text + , requireSchemaSection = False + , resourceScheme = None Text + , schemaColumns = [] : List Text + } + } + } +, mk = + { FieldRule = + { actor = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Actor + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , boolean = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Boolean + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , bundlePath = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = Some + { allowSelf = False, externalUriSchemes = [] : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , conditional = + \ ( _ + : { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , elementFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields : + Optional + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , reference : + Optional + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when : Optional { field : Text, hasValue : List Text } + } + ) -> + \(_ : { field : Text, hasValue : List Text }) -> + _@1 + with when = Some _ + , date = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Date + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , documentHandle = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = Some + ( < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.DocumentHandle + _ + ) + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , documented = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = Some _ + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , enum = + \(_ : Text) -> + \(_ : List Text) -> + { allowedValues = _ + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , humanActor = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.HumanActor + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , integer = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Integer + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , list = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.List + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , localOrExternalPath = + \(_ : Text) -> + \(_ : List Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = Some { allowSelf = False, externalUriSchemes = _ } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , localOrExternalReference = + \(_ : Text) -> + \(_ : Text) -> + \(_ : List Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@2 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = Some + { allowSelf = False, externalUriSchemes = _, localPrefix = _@1 } + , when = None { field : Text, hasValue : List Text } + } + , localReference = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = Some + { allowSelf = False + , externalUriSchemes = [] : List Text + , localPrefix = _ + } + , when = None { field : Text, hasValue : List Text } + } + , nonNegativeInteger = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.NonNegativeInteger + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , plain = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , record = + \(_ : Text) -> + \ ( _ + : { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + ) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = Some _ + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , recordList = + \(_ : Text) -> + \ ( _ + : { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + ) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.List + , description = None Text + , elementFields = Some _ + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , recordOrList = + \(_ : Text) -> + \ ( _ + : { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + ) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = Some _ + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = Some _ + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , rfc3339Utc = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Rfc3339Utc + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , scalar = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Scalar + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , uri = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Uri + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + , uriWithScheme = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , elementFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , field = _@1 + , format = Some + ( < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.UriWithScheme + _ + ) + , objectFields = + None + { optional : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , recommended : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + , required : + List + { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional + { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + } + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , reference = + None + { allowSelf : Bool + , externalUriSchemes : List Text + , localPrefix : Text + } + , when = None { field : Text, hasValue : List Text } + } + } + , NestedFieldRule = + { actor = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Actor + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , boolean = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Boolean + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , bundlePath = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = Some + { allowSelf = False, externalUriSchemes = [] : List Text } + , when = None { field : Text, hasValue : List Text } + } + , conditional = + \ ( _ + : { allowedValues : List Text + , cardinality : < Any | List | Scalar > + , description : Optional Text + , field : Text + , format : + Optional + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path : + Optional { allowSelf : Bool, externalUriSchemes : List Text } + , when : Optional { field : Text, hasValue : List Text } + } + ) -> + \(_ : { field : Text, hasValue : List Text }) -> + _@1 + with when = Some _ + , date = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Date + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , documentHandle = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _@1 + , format = Some + ( < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.DocumentHandle + _ + ) + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , documented = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = Some _ + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , enum = + \(_ : Text) -> + \(_ : List Text) -> + { allowedValues = _ + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , humanActor = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.HumanActor + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , integer = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Integer + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , list = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.List + , description = None Text + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , localOrExternalPath = + \(_ : Text) -> + \(_ : List Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _@1 + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = Some { allowSelf = False, externalUriSchemes = _ } + , when = None { field : Text, hasValue : List Text } + } + , nonNegativeInteger = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.NonNegativeInteger + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , plain = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , rfc3339Utc = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Rfc3339Utc + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , scalar = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Scalar + , description = None Text + , field = _ + , format = + None + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + > + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , uri = + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _ + , format = Some + < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.Uri + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + , uriWithScheme = + \(_ : Text) -> + \(_ : Text) -> + { allowedValues = [] : List Text + , cardinality = < Any | List | Scalar >.Any + , description = None Text + , field = _@1 + , format = Some + ( < Actor + | Boolean + | Date + | DocumentHandle : Text + | HumanActor + | Integer + | NonNegativeInteger + | Rfc3339Utc + | Uri + | UriWithScheme : Text + >.UriWithScheme + _ + ) + , path = None { allowSelf : Bool, externalUriSchemes : List Text } + , when = None { field : Text, hasValue : List Text } + } + } + } +} diff --git a/test/fixtures/catalogue/package.dhall b/test/fixtures/catalogue/package.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/package.dhall @@ -0,0 +1,39 @@ +--| Offline snapshot of mori://shinzui/okf-profiles at v0.10.0. +-- Generated by scripts/refresh-default-registry.sh; do not edit by hand. +-- Profile/okf.dhall is the resolved schema pinned by that release, so this +-- fixture evaluates without network access. +--| Entry point for the okf-profiles package. +-- +-- Import this from any project to get the profile schema types and the +-- ready-made profiles. With a versioned, hash-pinned remote import: +-- +-- let okf = +-- https://raw.githubusercontent.com/shinzui/okf-profiles/v0.1.0/package.dhall +-- sha256:0000000000000000000000000000000000000000000000000000000000000000 +-- +-- in okf.postgresql // { name = "acme-warehouse" } +-- +-- See README.md for how to generate the real hash (`dhall freeze`) and for the +-- public-repo / pinning rationale. +let okf = ./Profile/okf.dhall + +in { Profile = okf.defaults.Profile + , TypeRule = okf.defaults.TypeRule + , FrontmatterRules = okf.defaults.FrontmatterRules + , FieldRule = okf.defaults.FieldRule + , NestedRules = okf.defaults.NestedRules + , NestedFieldRule = okf.defaults.NestedFieldRule + , HandleReferenceRule = okf.defaults.HandleReferenceRule + , PathReferenceRule = okf.defaults.PathReferenceRule + , FieldCondition = okf.FieldCondition + , Cardinality = okf.Cardinality + , FieldFormat = okf.FieldFormat + , mk = okf.mk + , reviewRule = ./Profile/ReviewRule.dhall + , v02 = ./Profile/V02.dhall + , coordination = ./profiles/coordination/package.dhall + , documentation = ./profiles/documentation/package.dhall + , okfV02 = ./profiles/okf-v0-2.dhall + , postgresql = ./profiles/postgresql.dhall + , tanPostgresql = ./profiles/tan-postgresql.dhall + } diff --git a/test/fixtures/catalogue/profiles/coordination/bug-reports.dhall b/test/fixtures/catalogue/profiles/coordination/bug-reports.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/coordination/bug-reports.dhall @@ -0,0 +1,282 @@ +--| Profile for defect reports against a repository's published behavior. +-- +-- ## What a bug report is, and what it is not +-- +-- A bug report is a *broken provision claim*: something this repository already +-- says it does, observably does not do. That is the whole line, and it is what +-- places the type in the coordination family rather than in documentation: +-- +-- * Behavior that was never provided is NOT a bug. It is an improvement +-- request. "The exporter cannot resume" is a bug only if resumable export is +-- something the producer claims today; otherwise it is a request for it. +-- * A defect nobody can reach from the outside is NOT a bug report either. A +-- report names a version, an observation, and steps — if none of those can be +-- written down, what exists is a suspicion, and the right artifact is a +-- research document until it can be reproduced. +-- * Granularity: one report is one wrong behavior with one reproduction. Two +-- symptoms that share a reproduction are one report; two reproductions are +-- two reports even where the cause turns out to be shared. Merging them later +-- is cheap, and `duplicateOf` is how it is recorded. +-- +-- `capability` makes the broken claim explicit where the producer publishes a +-- `coordination.capabilities` catalog: the report names the `CAP-N` handle it +-- contradicts. It is optional because not every repository has one, and because a +-- defect can break behavior that was documented rather than catalogued. +-- +-- +-- ## `observed` and `expected` are frontmatter, not prose +-- +-- Both could live in the body, and in most trackers they do. They are keys here +-- because a corpus is queried: "every unusable defect where the expectation came +-- from a published guide" is a question a reader should be able to ask across +-- repositories without reading three hundred bodies. The body is for the +-- analysis; the keys are for the claim. +-- +-- +-- ## The house `status` vocabulary +-- +-- Per ADR-1 this profile declares a house lifecycle vocabulary on `status` and +-- therefore does NOT splice OKF v0.2 §5.4's `status` or §5.5's `stale_after`. +-- Its question is "where has this defect got to", which is not the +-- draft/stable/deprecated question v0.2 asks of a document. +-- +-- `confirmed` means the *owning* repository reproduced it, not that the reporter +-- is sure. That is the one transition an outside reporter cannot make, and +-- keeping it decidable is what stops the vocabulary collapsing into a mood. +-- +-- Five statuses are terminal — `fixed`, `wont-fix`, `duplicate`, `not-a-bug`, +-- `cannot-reproduce` — and each demands `resolution` under `--strict`. A closed +-- report whose closing reason lives only in a chat log is the failure mode this +-- catches. +-- +-- +-- ## `severity` is an observable consequence, not a priority +-- +-- The four values are ordered by what actually happens to a consumer, and are +-- assigned by observation rather than judgment: +-- +-- * `data-loss` — persisted data is destroyed, or a result is silently wrong. +-- * `unusable` — the behavior cannot be had at all, and no workaround exists. +-- * `degraded` — it works, but only via a workaround or with reduced function. +-- * `cosmetic` — the output reads wrong; the behavior underneath is right. +-- +-- `data-loss` outranks `unusable` deliberately: an outage is visible and a silently +-- wrong number is not. Where two values could apply, take the most severe that +-- actually occurs — and if that feels wrong, check whether two defects are being +-- reported as one. +-- +-- Severity is not priority. Priority weighs severity against reach, cost, and +-- what else is in flight; it changes with the schedule, differs per consumer, and +-- has no place in a cross-repository record. +-- +-- +-- ## The three version keys +-- +-- `affectedVersion`, `fixedVersion`, and `lastWorkingVersion` all take the same +-- fixed vocabulary: a bare released version, `unreleased` for the default branch +-- only, or `unknown` with the reason in the body. The profile cannot enforce it — +-- the values are free text — but a version field a consumer compares +-- mechanically is destroyed by commentary appended to it, so the history goes in +-- the body and the key stays a version. +-- +-- `lastWorkingVersion` is what makes a report a regression, and is optional +-- because most defects were never absent. +-- +-- +-- ## `legacyTimestamp` is deliberately absent +-- +-- `v02.legacyTimestamp` exists so a half-migrated v0.1 corpus keeps validating. +-- This profile is introduced at v0.2 and no v0.1 bug-report corpus exists, so +-- there is nothing to keep validating. Add the rule to `optional` if one ever +-- appears. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let HandleReferenceRule = okf.defaults.HandleReferenceRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let reviewRule = ../../Profile/ReviewRule.dhall + +let v02 = ../../Profile/V02.dhall + +let condition = + \(field : Text) -> \(hasValue : List Text) -> { field, hasValue } + +let terminal = + condition + "status" + [ "fixed", "wont-fix", "duplicate", "not-a-bug", "cannot-reproduce" ] + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +let moriUri = + \(name : Text) -> + \(description : Text) -> + scalar name description + // { format = Some (FieldFormat.UriWithScheme "mori") } + +in Profile::{ + , name = "bug-reports" + , description = Some + "Defect reports against behavior a repository already provides, with stable BUG handles, an observable severity scale, and a reproduction a reader can follow. Behavior that was never provided is an improvement request, not a bug. The house `reviews` family and OKF `verified` coexist: `reviews` records far more than `verified` can, so an approving `reviews` entry should also be mirrored into `verified` to keep the derived trust tier accurate." + , okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , idField = Some "bugId" + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The Bug Report concept type." + , scalar "title" "Short statement of the wrong behavior." + , scalar + "description" + "One sentence naming what is wrong, evaluable without the body." + , v02.generated + // { description = Some + "§5.2. Who produced this report's current content, and when." + } + , FieldRule::{ + , field = "bugId" + , description = Some "Bundle-scoped stable BUG-N handle." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.DocumentHandle "BUG") + } + , FieldRule::{ + , field = "status" + , description = Some + "Where this report has got to. `confirmed` means the owning repository reproduced it." + , allowedValues = + [ "reported" + , "confirmed" + , "in-progress" + , "fixed" + , "wont-fix" + , "duplicate" + , "not-a-bug" + , "cannot-reproduce" + ] + , cardinality = Cardinality.Scalar + } + , -- Consequence, not priority. Take the most severe value that actually + -- occurs; see the header for what each one means. + FieldRule::{ + , field = "severity" + , description = Some + "Observable consequence for a consumer, most severe first." + , allowedValues = [ "data-loss", "unusable", "degraded", "cosmetic" ] + , cardinality = Cardinality.Scalar + } + , moriUri + "origin" + "Mori URI of the project or artifact that observed the defect." + , -- Distinct from `origin`, and the two differ in exactly the case this + -- family exists for: a consumer reporting a defect in a dependency. + moriUri + "affects" + "Mori URI of the project or artifact whose behavior is wrong." + , scalar + "affectedVersion" + "Released version the defect was observed in; `unreleased` or `unknown` otherwise." + , scalar "observed" "What actually happens, stated as a fact." + , scalar + "expected" + "What should happen instead, and on whose authority — a guide, a capability, a test." + , FieldRule::{ + , field = "reproduction" + , description = Some + "Ordered steps a reader can follow to see it, one step per entry." + , cardinality = Cardinality.List + } + , -- The next two are conditionally required, which okf spells `required` + -- plus `when`: a `when` condition gates a presence demand, and an + -- `optional` rule makes no demand to gate. + scalar + "fixedVersion" + "Released version carrying the fix; `unreleased` while it is on the default branch only." + // { when = Some (condition "status" [ "fixed" ]) } + , FieldRule::{ + , field = "duplicateOf" + , description = Some + "The report this one duplicates, as a local BUG-N handle or an external Mori URI." + , cardinality = Cardinality.Scalar + , reference = Some HandleReferenceRule::{ + , localPrefix = "BUG" + , externalUriSchemes = [ "mori" ] + } + , when = Some (condition "status" [ "duplicate" ]) + } + ] + , -- `reviews` is the family's one unconditional recommendation: a + -- coordination corpus that records no review provenance is deficient and + -- `--strict` should say so. The other two are conditional, so neither is + -- reported on a report that has no occasion for it. + recommended = + [ reviewRule + , FieldRule::{ + , field = "resolution" + , description = Some + "Why this report closed the way it did, recorded when it reaches a terminal status." + , cardinality = Cardinality.Scalar + , when = Some terminal + } + , -- `degraded` is *defined* as "a workaround exists", so a degraded + -- report that names none is either incomplete or mis-graded. + scalar + "workaround" + "What a consumer can do meanwhile. Demanded once `severity` is `degraded`." + // { when = Some (condition "severity" [ "degraded" ]) } + ] + , optional = + [ -- Ordinarily absent: most producers publish no capability catalog, and + -- a defect can break behavior that was documented rather than + -- catalogued. + -- + -- A Mori URI rather than a `CAP-N` handle reference, and not by + -- preference: okf resolves a local handle against this bundle's own ID + -- index, and ties every declared reference prefix to a type this + -- profile declares. A capability catalog is a different bundle in a + -- different repository, so the reference is external in every case + -- that matters, and declaring `CAP` here is a profile load failure. + moriUri + "capability" + "Mori URI of the capability whose provision claim this defect contradicts." + , -- Ordinarily absent: most defects were never absent, so demanding this + -- under `--strict` would report a normal state as a deficiency. + scalar + "lastWorkingVersion" + "Newest release where the behavior was correct. Its presence makes this a regression." + , scalar + "environment" + "Where the observation was made, when the defect does not reproduce everywhere." + , v02.verified + // { description = Some + "§5.2. Independent confirmations that this report is accurate. Mirror an approving `reviews` entry here." + } + ] + } + , types = + [ TypeRule::{ + , type = "Bug Report" + , description = Some + "One wrong behavior, in something this repository already provides, with one reproduction." + , pathPattern = Some "*" + , idPrefix = Some "BUG" + } + ] + } diff --git a/test/fixtures/catalogue/profiles/coordination/capabilities.dhall b/test/fixtures/catalogue/profiles/coordination/capabilities.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/coordination/capabilities.dhall @@ -0,0 +1,272 @@ +--| Profile for consumer-facing catalogs of what a repository provides today. +-- +-- ## What a capability is, and what it is not +-- +-- A capability is a *provision claim*: something this repository's code does +-- today, that a consumer can adopt on its own, backed by evidence a reader can +-- open. It completes the coordination family's triangle — a use case describes +-- what a consumer needs, a capability describes what a producer provides, and an +-- improvement request describes the gap between them: +-- +-- * A capability that does not exist yet is NOT a capability record. It is an +-- improvement request. There is deliberately no `planned` status here, and +-- that omission is the profile's single most load-bearing decision. +-- * A capability that only exists when several repositories cooperate is NOT a +-- capability record either — no single repository can assert it or prove it. +-- It belongs to the consuming repository as a use-case feature. +-- * Granularity: one capability is one thing a consumer can adopt AND verify +-- independently. Where two candidates always ship together and are proven by +-- the same evidence, they are one capability. A catalog with one record per +-- exported module is a worse copy of the API reference. +-- * A record must read correctly to someone who has never heard of the +-- repositories that happen to consume it. In practice this test does more +-- than filter vocabulary: a claim that cannot be phrased without naming a +-- sibling service is usually a composition claim in disguise. +-- +-- Where a capability grows materially in a later release, record the growth as a +-- new capability that `requires` the old one, rather than moving an older `since` +-- forward. Both alternatives misinform a consumer pinning an older version. +-- +-- +-- ## The house `status` vocabulary +-- +-- Per ADR-1, this profile declares a house lifecycle vocabulary on `status` and +-- therefore does NOT splice OKF v0.2 §5.4's `status` or §5.5's `stale_after`. +-- `shipped` / `deprecated` / `withdrawn` answer "can a consumer use this right +-- now", which is not the draft/stable/deprecated question v0.2 asks. +-- +-- `stability` is deliberately a separate key rather than more `status` values: a +-- shipped capability in a pre-1.0 project is available *and* unstable, and a +-- consumer choosing a dependency needs both answers. In a project with a uniform +-- compatibility promise the key is uniform too, and carries its signal to an +-- outside reader rather than between records. +-- +-- +-- ## `legacyTimestamp` is deliberately absent +-- +-- `v02.legacyTimestamp` exists so a half-migrated v0.1 corpus keeps validating. +-- This profile is introduced at v0.2 and no v0.1 capability corpus exists, so +-- there is nothing to keep validating. Add the rule to `optional` if one ever +-- appears. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let NestedRules = okf.defaults.NestedRules + +let NestedFieldRule = okf.defaults.NestedFieldRule + +let HandleReferenceRule = okf.defaults.HandleReferenceRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let reviewRule = ../../Profile/ReviewRule.dhall + +let v02 = ../../Profile/V02.dhall + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +let list = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.List + } + +let nestedScalar = + \(name : Text) -> + \(description : Text) -> + NestedFieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +let capabilityReference = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.List + , reference = Some HandleReferenceRule::{ + , localPrefix = "CAP" + , externalUriSchemes = [ "mori" ] + } + } + +-- Evidence is what separates a capability record from a marketing bullet: every +-- claim names an artifact a reader can open and check. +-- +-- `resource` is a plain scalar and deliberately NOT an okf `path` rule. A path +-- rule resolves against the bundle's own concept tree, and a path naming a `.md` +-- file must name a concept inside the bundle. Capability evidence is inherently +-- repository-wide — test modules, package targets, user guides outside the +-- bundle — so declaring `path` here would reject exactly the evidence that +-- matters most. The cost is that resources are unchecked by okf; a +-- repository-local CI check is the right place to resolve them. +let evidence = + FieldRule::{ + , field = "evidence" + , description = Some + "Artifacts proving this capability works today. A record with no evidence is an improvement request, not a capability." + , cardinality = Cardinality.List + , elementFields = Some NestedRules::{ + , required = + [ NestedFieldRule::{ + , field = "kind" + , description = Some "What sort of proof this entry is." + , allowedValues = + [ "test" + , "conformance" + , "example" + , "benchmark" + , "module" + , "guide" + ] + , cardinality = Cardinality.Scalar + } + , nestedScalar + "resource" + "Repository-relative path, package target, module name, or absolute URL a reader can open." + ] + , recommended = + [ nestedScalar + "proves" + "What a reader learns by opening it. Without this an evidence entry is a bare path." + ] + , optional = [] : List NestedFieldRule.Type + } + } + +in Profile::{ + , name = "capabilities" + , description = Some + "Consumer-facing catalog of what a repository provides today: stable CAP-N handles, an explicit compatibility promise, and evidence. Provision claims only — absent capabilities are improvement requests, and capabilities that span repositories are use-case features owned by the consumer. The house `reviews` family and OKF `verified` coexist: `reviews` records far more than `verified` can, so an approving `reviews` entry should also be mirrored into `verified` to keep the derived trust tier accurate." + , okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , idField = Some "capabilityId" + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The Capability concept type." + , scalar "title" "Human-readable capability name." + , scalar + "description" + "One sentence a consumer can evaluate without reading the body." + , v02.generated + // { description = Some + "§5.2. Who produced this capability record's current content, and when." + } + ] + , recommended = [ reviewRule ] + , optional = + [ list "tags" "Producer-defined search and grouping tags." + , list + "links" + "Additional navigation links retained as producer metadata." + , v02.verified + // { description = Some + "§5.2. Independent confirmations that this content is accurate. Mirror an approving `reviews` entry here." + } + ] + } + , types = + [ TypeRule::{ + , type = "Capability" + , description = Some + "One thing this repository's code does today that a consumer can adopt and verify independently." + , frontmatter = FrontmatterRules::{ + , required = + [ FieldRule::{ + , field = "capabilityId" + , description = Some "Bundle-scoped stable CAP-N handle." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.DocumentHandle "CAP") + } + , FieldRule::{ + , field = "provider" + , description = Some + "Mori project URI that provides this capability. Redundant within one bundle, load-bearing once capabilities are aggregated across repositories." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.UriWithScheme "mori") + } + , -- No `planned`: a capability that does not exist yet is an + -- improvement request. See the header. + FieldRule::{ + , field = "status" + , description = Some + "Whether a consumer can use this capability right now." + , allowedValues = [ "shipped", "deprecated", "withdrawn" ] + , cardinality = Cardinality.Scalar + } + , FieldRule::{ + , field = "stability" + , description = Some + "Compatibility promise. `experimental` may change without a major bump." + , allowedValues = [ "experimental", "stable" ] + , cardinality = Cardinality.Scalar + } + , scalar + "since" + "Released version in which this first became available to a consumer. `unreleased` when it exists only on the default branch." + , list + "packages" + "Packages, artifacts, or deployables a consumer depends on to get this capability." + , evidence + , -- Demanded only once the capability is on its way out: a retirement + -- with no forward path is the failure mode worth catching, and a + -- live capability has nothing to say here. + -- + -- This rule lives in `required` rather than `optional` because okf + -- rejects a `when` condition on an optional field: `when` gates a + -- presence demand, and `optional` makes no demand to gate. + -- Conditionally-required is spelled `required` + `when`. + capabilityReference + "replacedBy" + "Where a consumer should go instead. Demanded once `status` is `deprecated` or `withdrawn`." + // { when = Some { field = "status" + , hasValue = [ "deprecated", "withdrawn" ] + } + } + ] + , recommended = + [ list + "interface" + "Entry points a consumer actually touches: module names, endpoints, or commands." + ] + , optional = + [ -- okf derives concept-to-concept graph edges from Markdown *body* + -- links only; frontmatter is preserved and checked but never + -- becomes an edge. A `requires` entry that is not also a body link + -- validates cleanly and is invisible to `okf graph`. Declare each + -- requirement twice: here, where it is typed and can name an + -- external Mori URI, and as a body link, where it becomes an edge. + -- okf cannot enforce the mirror; a repository-local check should. + capabilityReference + "requires" + "Capabilities this one builds on, as local CAP-N handles or external Mori capability URIs. Mirror each entry as a body link so it becomes a graph edge." + ] + } + , pathPattern = Some "*" + , idPrefix = Some "CAP" + } + ] + } diff --git a/test/fixtures/catalogue/profiles/coordination/improvement-requests.dhall b/test/fixtures/catalogue/profiles/coordination/improvement-requests.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/coordination/improvement-requests.dhall @@ -0,0 +1,156 @@ +--| Profile for cross-repository improvement requests with stable IR-N handles. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let HandleReferenceRule = okf.defaults.HandleReferenceRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let reviewRule = ../../Profile/ReviewRule.dhall + +let v02 = ../../Profile/V02.dhall + +let condition = + \(field : Text) -> \(hasValue : List Text) -> { field, hasValue } + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +in Profile::{ + , name = "cross-repository-improvement-requests" + , description = Some + "Cross-repository improvement proposals with stable IR handles and review provenance. The house `reviews` family and OKF `verified` coexist: `reviews` records far more than `verified` can, so an approving `reviews` entry should also be mirrored into `verified` to keep the derived trust tier accurate." + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The Improvement Request concept type." + , scalar "title" "Short statement of the requested improvement." + , scalar + "description" + "Concise explanation of the problem and desired outcome." + , v02.generated + // { description = Some + "§5.2. Who produced this request's current content, and when." + } + , FieldRule::{ + , field = "requestId" + , description = Some "Bundle-scoped stable IR-N handle." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.DocumentHandle "IR") + } + , FieldRule::{ + , field = "status" + , description = Some "Lifecycle decision for the request." + , allowedValues = + [ "proposed" + , "accepted" + , "in-progress" + , "completed" + , "rejected" + , "withdrawn" + , "superseded" + ] + , cardinality = Cardinality.Scalar + } + , FieldRule::{ + , field = "origin" + , description = Some + "Mori URI of the project or artifact raising the request." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.UriWithScheme "mori") + } + , FieldRule::{ + , field = "completedAt" + , description = Some + "UTC time at which acceptance evidence proved the request complete." + , cardinality = Cardinality.Scalar + , format = Some FieldFormat.Rfc3339Utc + , when = Some (condition "status" [ "completed" ]) + } + , FieldRule::{ + , field = "supersededBy" + , description = Some "Later request that replaces this request." + , cardinality = Cardinality.Scalar + , reference = Some HandleReferenceRule::{ + , localPrefix = "IR" + , externalUriSchemes = [ "mori" ] + } + , when = Some (condition "status" [ "superseded" ]) + } + ] + , -- `reviews` is the only unconditional recommendation left: a coordination + -- corpus that records no review provenance at all is deficient, and + -- `--strict` should say so. `resolution` is conditional, so it is only + -- demanded once a request reaches a terminal state — a proposed request + -- with no resolution is not reported. + recommended = + [ reviewRule + , FieldRule::{ + , field = "resolution" + , description = Some + "Evidence or rationale recorded when a request reaches a terminal state." + , cardinality = Cardinality.Scalar + , when = Some + ( condition + "status" + [ "completed", "rejected", "withdrawn", "superseded" ] + ) + } + ] + , optional = + [ -- Ordinarily absent: a request that has not yet been planned has no + -- target plan, so demanding it under `--strict` would report a normal + -- state as a deficiency. + FieldRule::{ + , field = "targetPlan" + , description = Some + "Repository-relative path or Mori URI of the implementation plan." + , cardinality = Cardinality.Scalar + } + , v02.verified + // { description = Some + "§5.2. Independent confirmations that this request is accurate. Mirror an approving `reviews` entry here." + } + , -- The superseded v0.1 key. okf reads it whenever `generated` is + -- absent, so an unmigrated corpus keeps validating; `optional` means + -- its absence is never reported while its format is still checked + -- whenever it is present. Declaring `okfVersion = "0.2"` with this + -- rule in `required` or `recommended` is a hard profile load failure. + v02.legacyTimestamp + // { description = Some + "Superseded v0.1 revision timestamp. Prefer `generated.at`." + } + ] + } + , -- The house `status` key above keeps its request lifecycle vocabulary and + -- deliberately does not adopt OKF v0.2 §5.4's draft/stable/deprecated, nor + -- `stale_after`. See the header of ../../Profile/V02.dhall for the policy + -- and its reasoning. + okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , idField = Some "requestId" + , types = + [ TypeRule::{ + , type = "Improvement Request" + , description = Some + "A request whose implementation may span repository ownership boundaries." + , pathPattern = Some "*" + , idPrefix = Some "IR" + } + ] + } diff --git a/test/fixtures/catalogue/profiles/coordination/package.dhall b/test/fixtures/catalogue/profiles/coordination/package.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/coordination/package.dhall @@ -0,0 +1,12 @@ +--| Reusable coordination profiles. +-- +-- Three of them form one triangle: a use case states what a consumer needs, a +-- capability states what a producer provides, and an improvement request states +-- the gap between them. A bug report is the fourth corner: a capability that is +-- claimed but does not hold. Behavior that was never provided is an improvement +-- request rather than a bug, which is the line that keeps the two apart. +{ bugReports = ./bug-reports.dhall +, capabilities = ./capabilities.dhall +, improvementRequests = ./improvement-requests.dhall +, useCases = ./use-cases.dhall +} diff --git a/test/fixtures/catalogue/profiles/coordination/use-cases.dhall b/test/fixtures/catalogue/profiles/coordination/use-cases.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/coordination/use-cases.dhall @@ -0,0 +1,234 @@ +--| Profile for JTBD use cases connected to repository-owned feature work. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let NestedFieldRule = okf.defaults.NestedFieldRule + +let HandleReferenceRule = okf.defaults.HandleReferenceRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let reviewRule = ../../Profile/ReviewRule.dhall + +let v02 = ../../Profile/V02.dhall + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +let nestedScalar = + \(name : Text) -> + \(description : Text) -> + NestedFieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +let moriList = + \(name : Text) -> + \(description : Text) -> + NestedFieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.List + , format = Some (FieldFormat.UriWithScheme "mori") + } + +let jobs = + FieldRule::{ + , field = "jobs" + , description = Some + "Jobs-to-be-Done statements describing the actor, situation, desired progress, and observable outcome." + , cardinality = Cardinality.List + , elementFields = Some + { required = + [ nestedScalar "name" "Stable name for this job within the use case." + , nestedScalar "actor" "Person, role, or agent trying to make progress." + , nestedScalar "situation" "Circumstance in which the job arises." + , nestedScalar "motivation" "Progress the actor wants to make." + , nestedScalar "outcome" "Observable result that satisfies the job." + ] + , recommended = [] : List NestedFieldRule.Type + , optional = [] : List NestedFieldRule.Type + } + } + +let features = + FieldRule::{ + , field = "features" + , description = Some + "Capabilities whose delivery makes the use case possible, with ownership and request tracking." + , cardinality = Cardinality.List + , elementFields = Some + { required = + [ nestedScalar "name" "Stable feature name within the use case." + , nestedScalar "description" "Capability or behavior the feature supplies." + , NestedFieldRule::{ + , field = "status" + , description = Some "Current delivery state of the feature." + , allowedValues = + [ "discovered" + , "planned" + , "in-progress" + , "delivered" + , "blocked" + , "deferred" + ] + , cardinality = Cardinality.Scalar + } + , moriList "owners" "Mori project URIs accountable for delivering the feature." + , nestedScalar "acceptance" "Observable evidence that proves the feature is delivered." + ] + , recommended = [] : List NestedFieldRule.Type + , optional = + [ NestedFieldRule::{ + , field = "jobs" + , description = Some "Names of the JTBD records this feature advances." + , cardinality = Cardinality.List + } + , moriList + "improvementRequests" + "Stable Mori concept URIs of repository-owned requests delivering this feature." + ] + } + } + +in Profile::{ + , name = "jtbd-use-cases" + , description = Some + "Jobs-to-be-Done use cases connected to typed feature delivery and repository-owned improvement requests. The house `reviews` family and OKF `verified` coexist: `reviews` records far more than `verified` can, so an approving `reviews` entry should also be mirrored into `verified` to keep the derived trust tier accurate." + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The Use Case or Use Case Theme concept type." + , scalar "title" "Human-readable title." + , scalar "description" "Concise statement of the use case or theme." + , -- Profile-wide, not inside the `Use Case` type rule: a theme concept + -- is a document like any other and should record its producer too. + v02.generated + // { description = Some + "§5.2. Who produced this use case or theme's current content, and when." + } + ] + , recommended = [ reviewRule ] + , optional = + [ FieldRule::{ + , field = "tags" + , description = Some "Producer-defined search and grouping tags." + , cardinality = Cardinality.List + } + , FieldRule::{ + , field = "links" + , description = Some "Additional navigation links retained as producer metadata." + , cardinality = Cardinality.List + } + , v02.verified + // { description = Some + "§5.2. Independent confirmations that this content is accurate. Mirror an approving `reviews` entry here." + } + , -- The superseded v0.1 key. okf reads it whenever `generated` is + -- absent, so an unmigrated corpus keeps validating; `optional` means + -- its absence is never reported while its format is still checked + -- whenever it is present. Declaring `okfVersion = "0.2"` with this + -- rule in `required` or `recommended` is a hard profile load failure. + v02.legacyTimestamp + // { description = Some + "Superseded v0.1 revision timestamp. Prefer `generated.at`." + } + ] + } + , -- The `Use Case` type rule's house `status` key keeps its delivery + -- lifecycle vocabulary and deliberately does not adopt OKF v0.2 §5.4's + -- draft/stable/deprecated, nor `stale_after`. Its allowing `draft` is a + -- coincidence, not partial conformance. See the header of + -- ../../Profile/V02.dhall for the policy and its reasoning. + okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , idField = Some "useCaseId" + , types = + [ TypeRule::{ + , type = "Use Case" + , description = Some + "A user-value scenario expressed as JTBD records and the features needed to deliver it." + , frontmatter = FrontmatterRules::{ + , required = + [ FieldRule::{ + , field = "useCaseId" + , description = Some "Bundle-scoped stable UC-N handle." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.DocumentHandle "UC") + } + , FieldRule::{ + , field = "status" + , description = Some "Lifecycle state of the use case." + , allowedValues = + [ "draft" + , "validated" + , "planned" + , "in-progress" + , "delivered" + , "retired" + ] + , cardinality = Cardinality.Scalar + } + , FieldRule::{ + , field = "origin" + , description = Some "Mori project URI that owns this use case." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.UriWithScheme "mori") + } + , jobs + , features + ] + , recommended = + [ FieldRule::{ + , field = "themes" + , description = Some "Theme slugs mirrored by body links to theme concepts." + , cardinality = Cardinality.List + } + ] + , optional = + [ FieldRule::{ + , field = "improvementRequests" + , description = Some + "Stable Mori request URIs; mirror the union of feature-level request references." + , cardinality = Cardinality.List + , format = Some (FieldFormat.UriWithScheme "mori") + } + , FieldRule::{ + , field = "relatedUseCases" + , description = Some "Related local UC handles or external Mori use-case URIs." + , cardinality = Cardinality.List + , reference = Some HandleReferenceRule::{ + , localPrefix = "UC" + , externalUriSchemes = [ "mori" ] + } + } + ] + } + , pathPattern = Some "*" + , idPrefix = Some "UC" + } + , TypeRule::{ + , type = "Use Case Theme" + , description = Some + "A reusable business or product theme referenced by use cases in this bundle." + , pathPattern = Some "themes/*" + } + ] + } diff --git a/test/fixtures/catalogue/profiles/documentation/architecture-decisions.dhall b/test/fixtures/catalogue/profiles/documentation/architecture-decisions.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/documentation/architecture-decisions.dhall @@ -0,0 +1,115 @@ +--| Profile for repository-owned Architecture Decision Records with stable ADR-N handles. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let HandleReferenceRule = okf.defaults.HandleReferenceRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let v02 = ../../Profile/V02.dhall + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +in Profile::{ + , name = "architecture-decision-records" + , description = Some + "Flat repository-owned architecture decisions with stable ADR handles." + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The Architecture Decision Record concept type." + , scalar "title" "Decision title without the ADR number." + , FieldRule::{ + , field = "docId" + , description = Some "Bundle-scoped stable ADR-N handle." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.DocumentHandle "ADR") + } + , scalar "status" "Repository-native decision status." + , FieldRule::{ + , field = "date" + , description = Some "Original calendar date of the decision." + , cardinality = Cardinality.Scalar + , format = Some FieldFormat.Date + } + , scalar "description" "One-sentence summary of the decision." + , v02.generated + // { description = Some + "§5.2. Who produced this decision record's current content, and when." + } + ] + , -- Nothing is recommended. Under `--strict` a recommended-and-absent + -- field is an error, and the three provenance fields below are absent + -- from essentially every real ADR corpus: a live decision that has never + -- been superseded has nothing to record. They are `optional` instead, so + -- their reference constraints still apply whenever they are present. + recommended = [] : List FieldRule.Type + , optional = + [ FieldRule::{ + , field = "supersedes" + , description = Some "Earlier ADR handles replaced by this decision." + , reference = Some HandleReferenceRule::{ + , localPrefix = "ADR" + , externalUriSchemes = [ "mori" ] + } + } + , FieldRule::{ + , field = "supersededBy" + , description = Some "Later ADR handle replacing this decision." + , cardinality = Cardinality.Scalar + , reference = Some HandleReferenceRule::{ + , localPrefix = "ADR" + , externalUriSchemes = [ "mori" ] + } + } + , scalar + "originatingPlan" + "Plan that produced the decision, when recorded." + , v02.verified + // { description = Some + "§5.2. Independent confirmations that this decision record is accurate." + } + , -- The superseded v0.1 key. okf reads it whenever `generated` is + -- absent, so an unmigrated corpus keeps validating; `optional` means + -- its absence is never reported while its format is still checked + -- whenever it is present. Declaring `okfVersion = "0.2"` with this + -- rule in `required` or `recommended` is a hard profile load failure. + v02.legacyTimestamp + // { description = Some + "Superseded v0.1 revision timestamp. Prefer `generated.at`." + } + ] + } + , -- The house `status` key above keeps its repository-native vocabulary and + -- deliberately does not adopt OKF v0.2 §5.4's draft/stable/deprecated, nor + -- `stale_after`. See the header of ../../Profile/V02.dhall for the policy + -- and its reasoning. + okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , idField = Some "docId" + , types = + [ TypeRule::{ + , type = "Architecture Decision Record" + , description = Some + "A durable record of one architecture decision and its rationale." + , pathPattern = Some "*" + , idPrefix = Some "ADR" + } + ] + } diff --git a/test/fixtures/catalogue/profiles/documentation/package.dhall b/test/fixtures/catalogue/profiles/documentation/package.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/documentation/package.dhall @@ -0,0 +1,5 @@ +--| Reusable documentation profiles. +{ architectureDecisions = ./architecture-decisions.dhall +, patternCatalog = ./pattern-catalog.dhall +, researchDocuments = ./research-documents.dhall +} diff --git a/test/fixtures/catalogue/profiles/documentation/pattern-catalog.dhall b/test/fixtures/catalogue/profiles/documentation/pattern-catalog.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/documentation/pattern-catalog.dhall @@ -0,0 +1,113 @@ +--| Profile for a Mori-addressable catalog of implementation patterns and standards. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let v02 = ../../Profile/V02.dhall + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +let rule = + \(conceptType : Text) -> + \(path : Text) -> + TypeRule::{ + , type = conceptType + , description = Some ("A catalog " ++ conceptType ++ " document.") + , pathPattern = Some path + , resourceScheme = Some "mori" + } + +in Profile::{ + , name = "mori-documentation-pattern-catalog" + , description = Some + "Mori-addressable implementation patterns, standards, guides, and operational documentation." + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The documentation category governed by a type rule." + , scalar "title" "Human-readable document title." + , scalar "description" "Concise statement of the document's purpose." + , v02.generated + // { description = Some + "§5.2. Who produced this document's current content, and when." + } + , FieldRule::{ + , field = "resource" + , description = Some "Canonical Mori URI for this document." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.UriWithScheme "mori") + } + , FieldRule::{ + , field = "tags" + , description = Some "Search and discovery terms." + , cardinality = Cardinality.List + } + , FieldRule::{ + , field = "status" + , description = Some "Publication state of this guidance." + , allowedValues = [ "current", "deprecated" ] + , cardinality = Cardinality.Scalar + } + ] + , -- Nothing is recommended. Under `--strict` a recommended-and-absent + -- field is an error, and both fields below are ordinarily absent: most + -- catalog documents supersede nothing and cite no external source. + recommended = [] : List FieldRule.Type + , optional = + [ -- Was a bare list of URI strings; now the OKF v0.2 §5.1 + -- list-of-records shape, where the former URI becomes each entry's + -- required `resource` member. This is breaking for a consumer corpus. + -- + -- Note this is unrelated to the top-level `resource` key above, which + -- is OKF §4.1's canonical Mori URI for the document itself. + v02.sources + , FieldRule::{ + , field = "supersedes" + , description = Some "Earlier guidance replaced by this document." + } + , v02.verified + // { description = Some + "§5.2. Independent confirmations that this guidance is accurate." + } + , -- The superseded v0.1 key, kept so an unmigrated catalog keeps + -- validating. `optional` means its absence is never reported while its + -- format is still checked whenever it is present. + v02.legacyTimestamp + // { description = Some + "Superseded v0.1 revision timestamp. Prefer `generated.at`." + } + ] + } + , -- The house `status` key above keeps its `current`/`deprecated` + -- vocabulary and deliberately does not adopt OKF v0.2 §5.4's + -- draft/stable/deprecated, nor `stale_after`. See the header of + -- ../../Profile/V02.dhall for the policy and its reasoning. + okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , types = + [ rule "Navigation" "getting-started" + , rule "Overview" "*/overview" + , rule "Standard" "*/**" + , rule "Guide" "*/**" + , rule "Pattern" "*/**" + , rule "Runbook" "*/**" + , rule "Reference" "*/**" + , rule "Gotcha" "*/**" + ] + } diff --git a/test/fixtures/catalogue/profiles/documentation/research-documents.dhall b/test/fixtures/catalogue/profiles/documentation/research-documents.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/documentation/research-documents.dhall @@ -0,0 +1,139 @@ +--| Profile for repository-owned research documents with stable RES-N handles. +let Profile = ../../Profile/Type.dhall + +let FrontmatterRules = ../../Profile/FrontmatterRules.dhall + +let TypeRule = ../../Profile/TypeRule.dhall + +let okf = ../../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let HandleReferenceRule = okf.defaults.HandleReferenceRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let reviewRule = ../../Profile/ReviewRule.dhall + +let v02 = ../../Profile/V02.dhall + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +in Profile::{ + , name = "research-documents" + , description = Some + "Repository-owned research records with stable RES handles and structured review provenance. The house `reviews` family and OKF `verified` coexist: `reviews` records far more than `verified` can, so an approving `reviews` entry should also be mirrored into `verified` to keep the derived trust tier accurate." + , frontmatter = FrontmatterRules::{ + , required = + [ scalar "type" "The Research Document concept type." + , scalar "title" "Human-readable research title." + , scalar "description" "Concise statement of the research purpose." + , v02.generated + // { description = Some + "§5.2. Who produced this research record's current content, and when." + } + , FieldRule::{ + , field = "researchId" + , description = Some "Bundle-scoped stable RES-N handle." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.DocumentHandle "RES") + } + , FieldRule::{ + , field = "status" + , description = Some "Lifecycle state of the research record." + , allowedValues = [ "active", "complete", "superseded" ] + , cardinality = Cardinality.Scalar + } + , scalar + "scope" + "Question boundary and evidence considered by the research." + , FieldRule::{ + , field = "supersededBy" + , description = Some "Later research replacing this record." + , cardinality = Cardinality.Scalar + , reference = Some HandleReferenceRule::{ + , localPrefix = "RES" + , externalUriSchemes = [ "mori" ] + } + , when = Some { field = "status", hasValue = [ "superseded" ] } + } + ] + , -- `reviews` stays RECOMMENDED, alone among the fields that were + -- recommended before this migration. Research is the one corpus here + -- where review provenance is part of the work rather than incidental + -- metadata, so a research record that nobody reviewed is genuinely + -- worth reporting under `--strict`. The others below moved to + -- `optional`, where absence is ordinary rather than deficient. + recommended = [ reviewRule ] + , optional = + [ -- Was a bare list of URI strings; now the OKF v0.2 §5.1 + -- list-of-records shape, where the former URI becomes each entry's + -- required `resource` member. This is breaking for a consumer corpus. + v02.sources + // { description = Some "§5.1. Evidence sources used by the research." + } + , FieldRule::{ + , field = "relatedPlans" + , description = Some "Plans informed by this research." + , cardinality = Cardinality.List + } + , FieldRule::{ + , field = "relatedDecisions" + , description = Some + "Architecture decisions informed by this research." + , cardinality = Cardinality.List + } + , FieldRule::{ + , field = "supersedes" + , description = Some "Earlier research replaced by this record." + , reference = Some HandleReferenceRule::{ + , localPrefix = "RES" + , externalUriSchemes = [ "mori" ] + } + } + , -- Coexists with the house `reviews` family above rather than + -- replacing it: `reviews` records reviewer identity, scope, outcome, + -- provider, model, effort, and evidence context, while `verified` + -- records only `by` and `at`. Neither is a superset. Mirror an + -- approving `reviews` entry into `verified` so `okf trust` reports + -- the right tier. + v02.verified + // { description = Some + "§5.2. Independent confirmations that this research is accurate. Mirror approving `reviews` entries here." + } + , -- The superseded v0.1 key, kept so an unmigrated corpus keeps + -- validating. `optional` means its absence is never reported while + -- its format is still checked whenever it is present. + v02.legacyTimestamp + // { description = Some + "Superseded v0.1 revision timestamp. Prefer `generated.at`." + } + ] + } + , -- The house `status` key above keeps its + -- `active`/`complete`/`superseded` vocabulary and deliberately does not + -- adopt OKF v0.2 §5.4's draft/stable/deprecated, nor `stale_after`. See + -- the header of ../../Profile/V02.dhall for the policy and its reasoning. + okfVersion = "0.2" + , requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , idField = Some "researchId" + , types = + [ TypeRule::{ + , type = "Research Document" + , description = Some + "A durable record of evidence, alternatives, and conclusions within a bounded scope." + , pathPattern = Some "**" + , idPrefix = Some "RES" + } + ] + } diff --git a/test/fixtures/catalogue/profiles/okf-v0-2.dhall b/test/fixtures/catalogue/profiles/okf-v0-2.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/okf-v0-2.dhall @@ -0,0 +1,90 @@ +--| A reference profile for the OKF v0.2 frontmatter families. +-- +-- Point `--profile` at it to check that a bundle's v0.2 families are well +-- formed, without authoring a profile of your own first: +-- +-- okf validate BUNDLE --profile --strict +-- +-- Exported from this repository's root package as `okfV02`, so a consumer pins +-- it by URL like any other profile in the catalog: +-- +-- let okf = https://raw.githubusercontent.com/shinzui/okf-profiles/v0.8.0/package.dhall +-- sha256:… +-- +-- in okf.okfV02 +-- +-- This is a *format-level* profile, not a house profile. It says how the v0.2 +-- families must look when they are present and says nothing about which concept +-- types a team has, so `allowUnknownTypes` and `allowUnknownFields` are both +-- True and there are no type rules at all. Every other profile in this catalog +-- is a house profile and adds those; this one would be wrong to. +-- +-- Profiles are not part of the Open Knowledge Format. A bundle that deviates +-- from this file is still fully OKF-conformant, and okf reports deviations as +-- advisories unless `--profile-enforce` is passed. What this file encodes is the +-- specification's own shape rules, not an additional layer of conformance. +-- +-- The rules themselves live in `../Profile/V02.dhall`, shared with the house +-- profiles in this catalog so a correction lands in one place. Read that file's +-- header for the two catalog-wide policies on the `status` key and on the house +-- `reviews` family; neither applies here, because this profile has no house +-- conventions to collide with. +let Profile = ../Profile/Type.dhall + +let TypeRule = ../Profile/TypeRule.dhall + +let FrontmatterRules = ../Profile/FrontmatterRules.dhall + +let okf = ../Profile/okf.dhall + +let field = okf.mk.FieldRule + +let v02 = ../Profile/V02.dhall + +in Profile::{ + , name = "okf-v0-2" + , description = Some + "Reference profile for the OKF v0.2 frontmatter families: provenance, trust, lifecycle, and sources." + , okfVersion = "0.2" + , frontmatter = FrontmatterRules::{ + , required = + [ field.documented + "type" + "The concept type. This profile constrains no vocabulary, because OKF defines no fixed taxonomy and requires consumers to tolerate unknown types." + , field.documented + "title" + "Human-readable name of the concept, as a reader would say it." + , field.documented + "description" + "One or two sentences on what this concept is." + , v02.generated + ] + , -- Nothing is recommended: every rule here is either required by this + -- profile or optional per §11. `FrontmatterRules` defaults this to the + -- empty list, but naming it says the emptiness is a decision. + recommended = [] : List okf.defaults.FieldRule.Type + , optional = + [ -- All five are OPTIONAL deliberately. §11 forbids treating a missing + -- optional family as a deficiency, so a reference profile that made + -- `--strict` complain about an absent `verified` or `sources` would + -- advise the opposite of the specification. A team that wants one of + -- them demanded moves it to `required` or `recommended` in their own + -- profile. + v02.verified + , v02.status + , v02.staleAfter + , v02.sources + , v02.usageWindow + ] + } + , allowUnknownTypes = True + , allowUnknownFields = True + , idField = None Text + , -- Deliberately demanding nothing, for the same reason the families above + -- are optional. §12 makes a bundle's `okf_version` declaration a MAY, so a + -- format-level reference profile that required one would advise the + -- opposite of the specification. The house profiles in this catalog have + -- finished migrating and do write `Some "0.2"` here. + requireBundleVersion = None Text + , types = [] : List TypeRule.Type + } diff --git a/test/fixtures/catalogue/profiles/postgresql.dhall b/test/fixtures/catalogue/profiles/postgresql.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/postgresql.dhall @@ -0,0 +1,129 @@ +--| House profile for representing PostgreSQL database schemas as OKF bundles. +-- +-- Conventions encoded here: +-- +-- * `type:` vocabulary — `PostgreSQL Schema`, `PostgreSQL Table`, `PostgreSQL View`. +-- * Layout — schemas at `schemas/`, tables at `schemas//tables/`, +-- views at `schemas//views/`. +-- * `resource:` — a `postgresql://` URI on every concept. +-- * Tables and views carry a `# Schema` section; tables list +-- Column / Type / Nullable / Description, views Column / Type / Description. +-- +-- Built with record completion (`Profile::{…}`, `TypeRule::{…}`): unset fields take +-- the schema defaults, so this value survives backward-compatible schema growth. +let Profile = ../Profile/Type.dhall + +let TypeRule = ../Profile/TypeRule.dhall + +let okf = ../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let Cardinality = okf.Cardinality + +let FieldFormat = okf.FieldFormat + +let v02 = ../Profile/V02.dhall + +let scalar = + \(name : Text) -> + \(description : Text) -> + FieldRule::{ + , field = name + , description = Some description + , cardinality = Cardinality.Scalar + } + +in Profile::{ + , name = "shinzui-postgresql" + , description = Some + "Conventions for documenting PostgreSQL schemas, tables, and views as an OKF bundle. Targets OKF v0.2: provenance goes in `generated`, independent confirmation in `verified`, and lifecycle in `status` and `stale_after` — a database description decays whether or not anyone edits it." + , frontmatter = + { required = + [ scalar + "type" + "The exact PostgreSQL concept type governed by this profile." + , scalar "title" "Human-readable name of the database object." + ] + , -- `generated` is recommended rather than required, beside `description` + -- and `resource`. This is the most permissive profile in the catalog by + -- design — a large database is documented incrementally and a + -- partially-documented bundle is still useful — so promoting provenance + -- to required would invert that stance for one key. okf's own migrated + -- `docs/profiles/postgresql.dhall` makes the same choice. + recommended = + [ scalar + "description" + "One or two sentences explaining the object's purpose." + , v02.generated + // { description = Some + "§5.2. Who or what produced this description, and when it was last confirmed accurate." + } + , FieldRule::{ + , field = "resource" + , description = Some "postgresql:// URI locating the live object." + , cardinality = Cardinality.Scalar + , format = Some (FieldFormat.UriWithScheme "postgresql") + } + ] + , -- Unlike the profiles that carry a house lifecycle vocabulary on the + -- `status` key, neither PostgreSQL profile declares one, so there is no + -- collision and OKF v0.2 §5.4 `status` and §5.5 `stale_after` are + -- adopted in full. See the header of ../Profile/V02.dhall for the policy, + -- the current list, and why those profiles take the opposite branch. + optional = + [ v02.verified + // { description = Some + "§5.2. Independent confirmations that this description still matches the live object." + } + , v02.status + , v02.staleAfter + // { description = Some + "§5.5. Date after which this description should be re-confirmed against the live object." + } + , -- The superseded v0.1 key. okf reads it whenever `generated` is + -- absent, so an unmigrated corpus keeps validating; `optional` means + -- its absence is never reported while its format is still checked + -- whenever it is present. Declaring `okfVersion = "0.2"` with this + -- rule in `required` or `recommended` is a hard profile load failure. + v02.legacyTimestamp + // { description = Some + "Superseded v0.1 confirmation timestamp. Prefer `generated.at`." + } + ] + } + , okfVersion = "0.2" + , -- A house convention, not a rule of the format: specification §12 makes + -- the bundle's `okf_version` declaration a MAY, so okf never demands one. + -- This profile's rules are written for v0.2, so a bundle it governs should + -- say it is a v0.2 bundle. Write it with + -- `okf index BUNDLE --write --okf-version 0.2`. + requireBundleVersion = Some "0.2" + , allowUnknownTypes = False + , types = + [ TypeRule::{ + , type = "PostgreSQL Schema" + , description = Some + "One PostgreSQL namespace and the objects it groups." + , pathPattern = Some "schemas/*" + , resourceScheme = Some "postgresql" + } + , TypeRule::{ + , type = "PostgreSQL Table" + , description = Some + "One physical table, including its column contract." + , pathPattern = Some "schemas/*/tables/*" + , resourceScheme = Some "postgresql" + , requireSchemaSection = True + , schemaColumns = [ "Column", "Type", "Nullable", "Description" ] + } + , TypeRule::{ + , type = "PostgreSQL View" + , description = Some "One view and the columns it projects." + , pathPattern = Some "schemas/*/views/*" + , resourceScheme = Some "postgresql" + , requireSchemaSection = True + , schemaColumns = [ "Column", "Type", "Description" ] + } + ] + } diff --git a/test/fixtures/catalogue/profiles/tan-postgresql.dhall b/test/fixtures/catalogue/profiles/tan-postgresql.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/catalogue/profiles/tan-postgresql.dhall @@ -0,0 +1,102 @@ +--| House profile for tan PostgreSQL databases as OKF bundles. +-- +-- Extends the shared `shinzui-postgresql` profile (schemas, tables, views) with one extra +-- type that the base profile lacks: +-- +-- * `Event Stream` — an abstract event-sourcing stream (aggregate category) at +-- `streams/`. No `resource:` scheme (it is not a single physical table); it is +-- a logical stream of events inside `message_store.messages`. +-- +-- Read-model projections and scratch/backup tables are NOT separate types: they are +-- physically PostgreSQL tables (`type: PostgreSQL Table`, living under +-- `schemas//tables/
`). Their role is recorded in frontmatter — a convention +-- this profile now validates with type-specific field rules: +-- +-- derivation : projection | event-store | operational | scratch +-- lifecycle : durable | ephemeral +-- domain : true | false +-- sourceStreams : [, …] (when derivation = projection) +let Profile = ../Profile/Type.dhall + +let TypeRule = ../Profile/TypeRule.dhall + +let okf = ../Profile/okf.dhall + +let FieldRule = okf.defaults.FieldRule + +let Cardinality = okf.Cardinality + +let base = ./postgresql.dhall + +in base + // { name = "tan-postgresql" + , description = Some + "Tan PostgreSQL conventions, including table roles and logical event streams." + , types = + [ TypeRule::{ + , type = "PostgreSQL Schema" + , description = Some + "One PostgreSQL namespace and the objects it groups." + , pathPattern = Some "schemas/*" + , resourceScheme = Some "postgresql" + } + , TypeRule::{ + , type = "PostgreSQL Table" + , description = Some + "One physical table classified by derivation, lifecycle, and domain role." + , frontmatter = + { required = + [ FieldRule::{ + , field = "derivation" + , description = Some "How the table's data is produced." + , allowedValues = + [ "projection", "event-store", "operational", "scratch" ] + , cardinality = Cardinality.Scalar + } + , FieldRule::{ + , field = "lifecycle" + , description = Some + "Whether the table is durable or disposable." + , allowedValues = [ "durable", "ephemeral" ] + , cardinality = Cardinality.Scalar + } + , FieldRule::{ + , field = "domain" + , description = Some + "Whether the table stores domain state." + , cardinality = Cardinality.Scalar + } + , FieldRule::{ + , field = "sourceStreams" + , description = Some + "Event-stream categories feeding a projection table." + , cardinality = Cardinality.List + , when = Some + { field = "derivation", hasValue = [ "projection" ] } + } + ] + , recommended = [] : List FieldRule.Type + , optional = [] : List FieldRule.Type + } + , pathPattern = Some "schemas/*/tables/*" + , resourceScheme = Some "postgresql" + , requireSchemaSection = True + , schemaColumns = [ "Column", "Type", "Nullable", "Description" ] + } + , TypeRule::{ + , type = "PostgreSQL View" + , description = Some "One view and the columns it projects." + , pathPattern = Some "schemas/*/views/*" + , resourceScheme = Some "postgresql" + , requireSchemaSection = True + , schemaColumns = [ "Column", "Type", "Description" ] + } + , TypeRule::{ + , type = "Event Stream" + , description = Some + "One logical event-sourcing aggregate category." + , pathPattern = Some "streams/*" + } + ] + } + : Profile.Type diff --git a/test/fixtures/profile-discovery/.hidden/valid-hidden.dhall b/test/fixtures/profile-discovery/.hidden/valid-hidden.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/.hidden/valid-hidden.dhall @@ -0,0 +1,2 @@ +-- Hidden directories are excluded from bounded discovery. +../../profiles/decisions.dhall diff --git a/test/fixtures/profile-discovery/deep/a/b/c/d/e/valid-too-deep.dhall b/test/fixtures/profile-discovery/deep/a/b/c/d/e/valid-too-deep.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/deep/a/b/c/d/e/valid-too-deep.dhall @@ -0,0 +1,2 @@ +-- The default depth four cannot reach this otherwise valid descriptor. +../../../../../../valid.dhall diff --git a/test/fixtures/profile-discovery/dist-newstyle/valid-build-output.dhall b/test/fixtures/profile-discovery/dist-newstyle/valid-build-output.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/dist-newstyle/valid-build-output.dhall @@ -0,0 +1,2 @@ +-- Build-output directories are excluded even when they contain valid profiles. +../../profiles/decisions.dhall diff --git a/test/fixtures/profile-discovery/ignored.txt b/test/fixtures/profile-discovery/ignored.txt new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/ignored.txt @@ -0,0 +1,1 @@ +This non-Dhall file is never evaluated. diff --git a/test/fixtures/profile-discovery/invalid.dhall b/test/fixtures/profile-discovery/invalid.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/invalid.dhall @@ -0,0 +1,1 @@ +this is not valid Dhall diff --git a/test/fixtures/profile-discovery/nested/valid-nested.dhall b/test/fixtures/profile-discovery/nested/valid-nested.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/nested/valid-nested.dhall @@ -0,0 +1,2 @@ +-- Descriptor discovery descends after finding a profile in the parent directory. +../../profiles/postgresql.dhall diff --git a/test/fixtures/profile-discovery/not-a-profile.dhall b/test/fixtures/profile-discovery/not-a-profile.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/not-a-profile.dhall @@ -0,0 +1,2 @@ +-- Valid Dhall that deliberately does not have the profile shape. +{ note = "hello" } diff --git a/test/fixtures/profile-discovery/registry.dhall b/test/fixtures/profile-discovery/registry.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/registry.dhall @@ -0,0 +1,2 @@ +-- A registry record is valid Dhall but is not itself a single profile descriptor. +../registry/package.dhall diff --git a/test/fixtures/profile-discovery/remote-bytes.dhall b/test/fixtures/profile-discovery/remote-bytes.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/remote-bytes.dhall @@ -0,0 +1,2 @@ +-- The bytes-fetch path is disabled independently of text imports. +https://example.invalid/profile.bin as Bytes diff --git a/test/fixtures/profile-discovery/remote.dhall b/test/fixtures/profile-discovery/remote.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/remote.dhall @@ -0,0 +1,2 @@ +-- Automatic discovery must reject this import before any network I/O. +https://example.invalid/profile.dhall diff --git a/test/fixtures/profile-discovery/valid.dhall b/test/fixtures/profile-discovery/valid.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/profile-discovery/valid.dhall @@ -0,0 +1,2 @@ +-- A discoverable descriptor that proves local relative imports remain enabled. +../profiles/decisions.dhall diff --git a/test/fixtures/registry-house/package.dhall b/test/fixtures/registry-house/package.dhall new file mode 100644 --- /dev/null +++ b/test/fixtures/registry-house/package.dhall @@ -0,0 +1,6 @@ +--| Second registry for multi-source tests. It publishes one export that +-- collides with the main registry and one unique export, using only sibling +-- fixtures so enumeration stays offline. +{ postgresql = ../profiles/postgresql.dhall +, runbooks = ../profiles/decisions.dhall +}