You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2026/05/15 18:17:30 UTC
(juneau) branch docs updated: docs: add AI knowledge artifacts and drift checks
This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch docs
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/docs by this push:
new 6e72253760 docs: add AI knowledge artifacts and drift checks
6e72253760 is described below
commit 6e72253760c9f5bccea9b22570430dbe813e8689
Author: James Bognar <ja...@jamesbog-ltmjqf2.internal.salesforce.com>
AuthorDate: Fri May 15 14:17:21 2026 -0400
docs: add AI knowledge artifacts and drift checks
Add deterministic AI artifact generation (JSONL/manifest/taxonomy), validation checks, and contributor docs so AI-consumable Juneau knowledge stays current and traceable.
Co-authored-by: Cursor <cu...@cursor.com>
---
README.md | 2 +-
docusaurus.config.ts | 2 +-
package.json | 2 +
pages/developer-info/02.09.AiKnowledgeAuthoring.md | 59 +++
pages/developer-info/04.03.07.ScriptAiArtifacts.md | 47 +++
scripts/build-docs.py | 11 +
scripts/check-ai-artifacts.py | 123 ++++++
scripts/generate-ai-artifacts.py | 363 +++++++++++++++++
sidebars.ts | 10 +
static/ai/juneau-knowledge.jsonl | 428 +++++++++++++++++++++
static/ai/manifest.json | 10 +
static/ai/taxonomy.json | 58 +++
12 files changed, 1113 insertions(+), 2 deletions(-)
diff --git a/README.md b/README.md
index 45bd4100fb..2c42f6777c 100644
--- a/README.md
+++ b/README.md
@@ -69,7 +69,7 @@ Apache Juneau™ excels in the following scenarios:
<dependency>
<groupId>org.apache.juneau</groupId>
<artifactId>juneau-shaded-all</artifactId>
- <version>9.1.0</version>
+ <version>9.5.0</version>
</dependency>
```
diff --git a/docusaurus.config.ts b/docusaurus.config.ts
index 2757cde42f..1e2a092516 100644
--- a/docusaurus.config.ts
+++ b/docusaurus.config.ts
@@ -104,7 +104,7 @@ const baseThemeConfig: Preset.ThemeConfig = {
{
// Use pathname:// protocol to tell Docusaurus this is an external link
// (even though it's on the same domain) to bypass link validation
- href: 'pathname:///javadocs/index.html',
+ href: 'pathname:///site/apidocs/index.html',
label: 'Javadocs',
position: 'right',
},
diff --git a/package.json b/package.json
index 5810e97957..d5672ee6af 100644
--- a/package.json
+++ b/package.json
@@ -6,6 +6,8 @@
"docusaurus": "docusaurus",
"start": "docusaurus start",
"build": "docusaurus build",
+ "build:ai-artifacts": "python3 scripts/generate-ai-artifacts.py",
+ "check:ai-artifacts": "python3 scripts/check-ai-artifacts.py",
"swizzle": "docusaurus swizzle",
"deploy": "docusaurus deploy",
"clear": "docusaurus clear",
diff --git a/pages/developer-info/02.09.AiKnowledgeAuthoring.md b/pages/developer-info/02.09.AiKnowledgeAuthoring.md
new file mode 100644
index 0000000000..988993c458
--- /dev/null
+++ b/pages/developer-info/02.09.AiKnowledgeAuthoring.md
@@ -0,0 +1,59 @@
+---
+title: "AI Knowledge Authoring Guide"
+slug: AiKnowledgeAuthoring
+---
+
+This guide defines how Juneau documentation should be authored and published so AI agents can consume it reliably.
+
+## Canonical Sources
+
+Use these source-of-truth locations:
+
+- **Concepts and behavior**: `pages/topics/*.md`
+- **Versioned changes**: `pages/release-notes/*.md` and migration guides
+- **API semantics**: Java sources and Javadocs in the main `juneau` repository
+
+Do not treat `todo/*.md` as authoritative runtime behavior documentation unless content is explicitly promoted into docs/release notes.
+
+## Canonical AI Artifacts
+
+Generated artifacts live in:
+
+- `static/ai/manifest.json`
+- `static/ai/juneau-knowledge.jsonl`
+- `static/ai/taxonomy.json`
+
+These files are the machine-first entrypoint for AI indexing/RAG pipelines and local coding agents.
+
+## Field Guidance (`summary` vs `description`)
+
+Use a short `summary` for compact, token-efficient explanations and a fuller `description` for nuance:
+
+- **`summary`**: One sentence, plain language, no paragraphs.
+- **`description`**: Longer explanation with context, caveats, and examples.
+- Prefer explicit summary metadata from annotations (`summary` / `su`) when available.
+
+## Regeneration Workflow
+
+From `juneau-docs`:
+
+```bash
+python3 scripts/generate-ai-artifacts.py
+python3 scripts/check-ai-artifacts.py
+```
+
+The first command regenerates deterministic artifacts. The second verifies:
+
+- generated AI files are up to date,
+- required manifest/record shape is present,
+- README quickstart version matches current Juneau release,
+- Javadocs link paths in docs config are consistent,
+- canonical release-note source for current release exists.
+
+## Definition Of Done (Docs-Affecting PRs)
+
+- New or changed feature docs are added under canonical source locations.
+- AI artifacts are regenerated if source content changed.
+- `check-ai-artifacts.py` passes locally.
+- `summary` text is concise and `description` adds non-redundant detail.
+- Source provenance remains traceable via `source_path` in JSONL output.
diff --git a/pages/developer-info/04.03.07.ScriptAiArtifacts.md b/pages/developer-info/04.03.07.ScriptAiArtifacts.md
new file mode 100644
index 0000000000..9ba787e92b
--- /dev/null
+++ b/pages/developer-info/04.03.07.ScriptAiArtifacts.md
@@ -0,0 +1,47 @@
+---
+title: "generate-ai-artifacts.py / check-ai-artifacts.py"
+slug: ScriptAiArtifacts
+---
+
+These scripts produce and validate the machine-consumable AI knowledge artifacts for Juneau documentation.
+
+## What They Generate
+
+`generate-ai-artifacts.py` writes:
+
+- `static/ai/manifest.json`
+- `static/ai/juneau-knowledge.jsonl`
+- `static/ai/taxonomy.json`
+
+The output is deterministic to avoid noisy diffs and index churn.
+
+## What They Validate
+
+`check-ai-artifacts.py` verifies:
+
+- generated artifact files are current (`--check` mode),
+- required manifest shape exists,
+- quickstart dependency version in `README.md` matches current release,
+- Javadocs links in `docusaurus.config.ts` are internally consistent,
+- current release has a canonical page in `pages/release-notes`.
+
+## Usage
+
+From the `juneau-docs` repository root:
+
+```bash
+python3 scripts/generate-ai-artifacts.py
+python3 scripts/check-ai-artifacts.py
+```
+
+Or via npm scripts:
+
+```bash
+npm run build:ai-artifacts
+npm run check:ai-artifacts
+```
+
+## Notes
+
+- The generator consumes documentation pages and release notes plus selected API metadata signals from the sibling `juneau` repository.
+- Keep summaries short and descriptive to support low-token retrieval workflows.
diff --git a/scripts/build-docs.py b/scripts/build-docs.py
index e226172f26..d934786c5b 100755
--- a/scripts/build-docs.py
+++ b/scripts/build-docs.py
@@ -307,6 +307,16 @@ def check_topic_links(master_root, docs_dir):
# It will scan master_root for links and docs_dir for topics
run_command(['python3', str(checker_script)], cwd=docs_dir)
+def check_ai_artifacts(docs_dir):
+ """Run AI artifact drift checks."""
+ print("\n=== Checking AI artifacts ===")
+ script_dir = Path(__file__).parent
+ checker_script = script_dir / 'check-ai-artifacts.py'
+ if not checker_script.exists():
+ print(f"WARNING: AI artifact checker not found at {checker_script}")
+ return
+ run_command(['python3', str(checker_script)], cwd=docs_dir)
+
def main():
parser = argparse.ArgumentParser(description='Build Apache Juneau documentation')
parser.add_argument('--skip-npm', action='store_true', help='Skip npm install and Docusaurus build')
@@ -382,6 +392,7 @@ def main():
# Check topic links (runs once at the end)
check_topic_links(master_root, docs_dir)
+ check_ai_artifacts(docs_dir)
print("\n=== Documentation build complete ===")
print(f"Documentation is available in: {docs_dir / 'build'}")
diff --git a/scripts/check-ai-artifacts.py b/scripts/check-ai-artifacts.py
new file mode 100644
index 0000000000..6765089eb3
--- /dev/null
+++ b/scripts/check-ai-artifacts.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# ***************************************************************************************************************************
+# * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file *
+# * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file *
+# * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance *
+# * with the License. You may obtain a copy of the License at *
+# * *
+# * http://www.apache.org/licenses/LICENSE-2.0 *
+# * *
+# * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an *
+# * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the *
+# * specific language governing permissions and limitations under the License. *
+# ***************************************************************************************************************************
+"""
+Checks AI artifacts freshness and source drift signals.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run(cmd: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+ return subprocess.run(cmd, cwd=cwd, text=True, capture_output=True)
+
+
+def check_ai_artifact_freshness(docs_root: Path) -> list[str]:
+ result = run(
+ [sys.executable, "scripts/generate-ai-artifacts.py", "--check", "--docs-root", str(docs_root)],
+ docs_root,
+ )
+ if result.returncode == 0:
+ return []
+ errors = ["AI artifact freshness check failed."]
+ if result.stdout:
+ errors.append(result.stdout.strip())
+ if result.stderr:
+ errors.append(result.stderr.strip())
+ return errors
+
+
+def check_readme_version(docs_root: Path, release: str) -> list[str]:
+ readme = (docs_root / "README.md").read_text(encoding="utf-8")
+ m = re.search(r"<version>([^<]+)</version>", readme)
+ if not m:
+ return ["Could not find Maven <version> in juneau-docs README.md quickstart section."]
+ found = m.group(1).strip()
+ if found != release:
+ return [f"README quickstart version mismatch: expected {release}, found {found}."]
+ return []
+
+
+def check_javadocs_link_consistency(docs_root: Path) -> list[str]:
+ config = (docs_root / "docusaurus.config.ts").read_text(encoding="utf-8")
+ matches = re.findall(r"href:\s*'pathname:///([^']+)'", config)
+ javadocs_links = sorted(link for link in matches if "javadocs" in link or "apidocs" in link)
+ unique = sorted(set(javadocs_links))
+ if len(unique) <= 1:
+ return []
+ return [f"Javadocs links are inconsistent in docusaurus.config.ts: {', '.join(unique)}."]
+
+
+def check_release_note_source_presence(docs_root: Path, juneau_root: Path, release: str) -> list[str]:
+ errors = []
+ docs_release = docs_root / "pages" / "release-notes" / f"{release}.md"
+ if not docs_release.exists():
+ errors.append(f"Missing canonical release note page: {docs_release}")
+
+ root_release = juneau_root / "RELEASE-NOTES.txt"
+ if not root_release.exists():
+ errors.append(f"Missing legacy release-notes file: {root_release}")
+ return errors
+
+
+def check_manifest_shape(docs_root: Path) -> list[str]:
+ manifest_path = docs_root / "static" / "ai" / "manifest.json"
+ if not manifest_path.exists():
+ return [f"Missing manifest: {manifest_path}"]
+ manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+ required = {"schema_version", "version", "generated_at", "source_commit", "record_count"}
+ missing = sorted(required.difference(manifest.keys()))
+ if missing:
+ return [f"Manifest missing required fields: {', '.join(missing)}"]
+ return []
+
+
+def resolve_current_release(juneau_root: Path) -> str:
+ script = juneau_root / "scripts" / "current-release.py"
+ result = run([sys.executable, str(script)], juneau_root)
+ if result.returncode != 0:
+ raise RuntimeError(result.stderr or "unable to resolve current release")
+ return result.stdout.strip()
+
+
+def main() -> int:
+ script_dir = Path(__file__).resolve().parent
+ docs_root = script_dir.parent
+ juneau_root = (docs_root.parent / "juneau").resolve()
+
+ release = resolve_current_release(juneau_root)
+ errors: list[str] = []
+ errors.extend(check_ai_artifact_freshness(docs_root))
+ errors.extend(check_manifest_shape(docs_root))
+ errors.extend(check_readme_version(docs_root, release))
+ errors.extend(check_javadocs_link_consistency(docs_root))
+ errors.extend(check_release_note_source_presence(docs_root, juneau_root, release))
+
+ if errors:
+ print("AI documentation checks failed:")
+ for err in errors:
+ print(f"- {err}")
+ return 1
+
+ print("All AI documentation checks passed.")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/generate-ai-artifacts.py b/scripts/generate-ai-artifacts.py
new file mode 100644
index 0000000000..3c63018b89
--- /dev/null
+++ b/scripts/generate-ai-artifacts.py
@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+# ***************************************************************************************************************************
+# * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file *
+# * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file *
+# * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance *
+# * with the License. You may obtain a copy of the License at *
+# * *
+# * http://www.apache.org/licenses/LICENSE-2.0 *
+# * *
+# * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an *
+# * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the *
+# * specific language governing permissions and limitations under the License. *
+# ***************************************************************************************************************************
+"""
+Generate deterministic AI-consumable knowledge artifacts for Apache Juneau.
+
+Outputs are written to static/ai:
+ - manifest.json
+ - juneau-knowledge.jsonl
+ - taxonomy.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import subprocess
+import sys
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+TOPIC_GLOB = "pages/topics/*.md"
+RELEASE_NOTES_GLOB = "pages/release-notes/*.md"
+SCHEMA_VERSION = "1.0.0"
+REQUIRED_FIELDS = [
+ "id",
+ "title",
+ "summary",
+ "description",
+ "module",
+ "source_type",
+ "source_path",
+ "version",
+ "tags",
+ "related_ids",
+ "updated_at",
+]
+
+
+@dataclass
+class ExtractConfig:
+ docs_root: Path
+ juneau_root: Path
+ output_dir: Path
+
+
+def parse_args() -> argparse.Namespace:
+ script_dir = Path(__file__).resolve().parent
+ docs_root = script_dir.parent
+ default_juneau_root = docs_root.parent / "juneau"
+ default_output_dir = docs_root / "static" / "ai"
+
+ parser = argparse.ArgumentParser(description="Generate AI artifacts for Juneau docs.")
+ parser.add_argument("--docs-root", type=Path, default=docs_root)
+ parser.add_argument("--juneau-root", type=Path, default=default_juneau_root)
+ parser.add_argument("--output-dir", type=Path, default=default_output_dir)
+ parser.add_argument("--check", action="store_true", help="Verify generated output is up to date without writing.")
+ return parser.parse_args()
+
+
+def read_text(path: Path) -> str:
+ return path.read_text(encoding="utf-8")
+
+
+def get_git_commit(repo_root: Path) -> str:
+ try:
+ result = subprocess.run(
+ ["git", "rev-parse", "HEAD"],
+ cwd=repo_root,
+ capture_output=True,
+ text=True,
+ check=True,
+ )
+ return result.stdout.strip()
+ except Exception:
+ return "unknown"
+
+
+def get_current_release(juneau_root: Path) -> str:
+ script = juneau_root / "scripts" / "current-release.py"
+ if not script.exists():
+ return "unknown"
+ try:
+ result = subprocess.run(
+ [sys.executable, str(script)],
+ cwd=juneau_root,
+ capture_output=True,
+ text=True,
+ check=True,
+ )
+ return result.stdout.strip() or "unknown"
+ except Exception:
+ return "unknown"
+
+
+def parse_frontmatter(content: str) -> dict[str, str]:
+ m = re.match(r"^---\n(.*?)\n---\n?", content, re.DOTALL)
+ if not m:
+ return {}
+ frontmatter = {}
+ for line in m.group(1).splitlines():
+ if ":" not in line:
+ continue
+ key, value = line.split(":", 1)
+ frontmatter[key.strip()] = value.strip().strip("\"'")
+ return frontmatter
+
+
+def remove_frontmatter(content: str) -> str:
+ return re.sub(r"^---\n.*?\n---\n?", "", content, count=1, flags=re.DOTALL)
+
+
+def first_heading(content: str) -> str:
+ for line in content.splitlines():
+ if line.startswith("# "):
+ return line[2:].strip()
+ return ""
+
+
+def first_paragraph(content: str) -> str:
+ cleaned = remove_frontmatter(content)
+ lines = [ln.rstrip() for ln in cleaned.splitlines()]
+ bucket = []
+ for line in lines:
+ stripped = line.strip()
+ if not stripped:
+ if bucket:
+ break
+ continue
+ if stripped.startswith("#") or stripped.startswith("```") or stripped.startswith(">"):
+ continue
+ bucket.append(stripped)
+ if len(" ".join(bucket)) > 240:
+ break
+ return " ".join(bucket).strip()
+
+
+def short_digest(parts: list[str]) -> str:
+ payload = "|".join(parts)
+ return hashlib.sha1(payload.encode("utf-8")).hexdigest()[:12]
+
+
+def build_doc_record(path: Path, docs_root: Path, source_type: str, default_version: str) -> dict[str, Any]:
+ content = read_text(path)
+ fm = parse_frontmatter(content)
+ rel_path = str(path.relative_to(docs_root))
+ title = fm.get("title") or first_heading(content) or path.stem
+ summary = first_paragraph(content) or title
+ description = remove_frontmatter(content).strip()
+ if len(description) > 2000:
+ description = description[:1997] + "..."
+
+ module = "general"
+ if source_type == "topic":
+ m = re.match(r"^\d+[a-z]?\.([^.]+)", path.name)
+ if m:
+ module = m.group(1)
+ if source_type == "release-note":
+ module = "release-notes"
+
+ version = default_version
+ if source_type == "release-note":
+ version = path.stem
+
+ return {
+ "id": f"{source_type}:{short_digest([rel_path, title])}",
+ "title": title,
+ "summary": summary,
+ "description": description,
+ "module": module,
+ "source_type": source_type,
+ "source_path": rel_path,
+ "version": version,
+ "tags": [source_type, module],
+ "related_ids": [],
+ "updated_at": "source-controlled",
+ }
+
+
+def extract_api_metadata_records(juneau_root: Path, default_version: str) -> list[dict[str, Any]]:
+ patterns = [
+ r"\bsummary\s*\(\)\s*default\s*\"\"",
+ r"\bsu\s*\(\)\s*default\s*\"\"",
+ ]
+ include_roots = [
+ juneau_root / "juneau-core",
+ juneau_root / "juneau-rest",
+ ]
+
+ records = []
+ for root in include_roots:
+ if not root.exists():
+ continue
+ for path in sorted(root.rglob("*.java")):
+ text = read_text(path)
+ if not any(re.search(pattern, text) for pattern in patterns):
+ continue
+ rel_path = str(path.relative_to(juneau_root))
+ symbol = path.stem
+ records.append(
+ {
+ "id": f"api-metadata:{short_digest([rel_path, symbol])}",
+ "title": f"{symbol} summary/su metadata",
+ "summary": f"{symbol} exposes summary/su metadata fields for concise AI-oriented descriptions.",
+ "description": (
+ "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata "
+ "annotations. These fields provide short descriptions intended for compact AI/LLM consumption."
+ ),
+ "module": "api-metadata",
+ "source_type": "api-metadata",
+ "source_path": rel_path,
+ "version": default_version,
+ "tags": ["api-metadata", "summary", "su"],
+ "related_ids": [],
+ "updated_at": "source-controlled",
+ }
+ )
+ return records
+
+
+def build_records(config: ExtractConfig, current_release: str) -> list[dict[str, Any]]:
+ records = []
+ for path in sorted(config.docs_root.glob(TOPIC_GLOB)):
+ records.append(build_doc_record(path, config.docs_root, "topic", current_release))
+ for path in sorted(config.docs_root.glob(RELEASE_NOTES_GLOB)):
+ records.append(build_doc_record(path, config.docs_root, "release-note", current_release))
+
+ records.extend(extract_api_metadata_records(config.juneau_root, current_release))
+ records.sort(key=lambda r: (r["source_type"], r["source_path"], r["id"]))
+ return records
+
+
+def validate_records(records: list[dict[str, Any]]) -> None:
+ for record in records:
+ missing = [field for field in REQUIRED_FIELDS if field not in record]
+ if missing:
+ raise ValueError(f"Record missing required fields {missing}: {record.get('id')}")
+ if not isinstance(record["tags"], list):
+ raise ValueError(f"Record tags must be a list: {record['id']}")
+ if not isinstance(record["related_ids"], list):
+ raise ValueError(f"Record related_ids must be a list: {record['id']}")
+
+
+def build_taxonomy(records: list[dict[str, Any]]) -> dict[str, Any]:
+ by_module: dict[str, int] = defaultdict(int)
+ by_type: dict[str, int] = defaultdict(int)
+ for record in records:
+ by_module[record["module"]] += 1
+ by_type[record["source_type"]] += 1
+ return {
+ "schema_version": SCHEMA_VERSION,
+ "modules": dict(sorted(by_module.items())),
+ "source_types": dict(sorted(by_type.items())),
+ }
+
+
+def compute_generated_at(records: list[dict[str, Any]]) -> str:
+ digest = short_digest([record["id"] for record in records])
+ return f"content-hash:{digest}"
+
+
+def build_manifest(
+ docs_commit: str,
+ juneau_commit: str,
+ current_release: str,
+ records: list[dict[str, Any]],
+) -> dict[str, Any]:
+ return {
+ "schema_version": SCHEMA_VERSION,
+ "version": current_release,
+ "generated_at": compute_generated_at(records),
+ "source_commit": {
+ "juneau_docs": docs_commit,
+ "juneau": juneau_commit,
+ },
+ "record_count": len(records),
+ }
+
+
+def render_jsonl(records: list[dict[str, Any]]) -> str:
+ return "".join(json.dumps(record, sort_keys=True, ensure_ascii=True) + "\n" for record in records)
+
+
+def render_json(value: dict[str, Any]) -> str:
+ return json.dumps(value, indent=2, sort_keys=True, ensure_ascii=True) + "\n"
+
+
+def write_if_changed(path: Path, content: str) -> bool:
+ existing = path.read_text(encoding="utf-8") if path.exists() else None
+ if existing == content:
+ return False
+ path.parent.mkdir(parents=True, exist_ok=True)
+ path.write_text(content, encoding="utf-8")
+ return True
+
+
+def main() -> int:
+ args = parse_args()
+ config = ExtractConfig(
+ docs_root=args.docs_root.resolve(),
+ juneau_root=args.juneau_root.resolve(),
+ output_dir=args.output_dir.resolve(),
+ )
+
+ current_release = get_current_release(config.juneau_root)
+ docs_commit = get_git_commit(config.docs_root)
+ juneau_commit = get_git_commit(config.juneau_root)
+
+ records = build_records(config, current_release)
+ validate_records(records)
+ taxonomy = build_taxonomy(records)
+ manifest = build_manifest(docs_commit, juneau_commit, current_release, records)
+
+ outputs = {
+ config.output_dir / "juneau-knowledge.jsonl": render_jsonl(records),
+ config.output_dir / "taxonomy.json": render_json(taxonomy),
+ config.output_dir / "manifest.json": render_json(manifest),
+ }
+
+ if args.check:
+ stale = []
+ for path, expected in outputs.items():
+ actual = path.read_text(encoding="utf-8") if path.exists() else None
+ if actual != expected:
+ stale.append(path)
+ if stale:
+ print("ERROR: AI artifacts are stale. Regenerate with:")
+ print(" python3 scripts/generate-ai-artifacts.py")
+ for path in stale:
+ print(f" - {path}")
+ return 1
+ print("AI artifacts are up to date.")
+ return 0
+
+ changed = 0
+ for path, content in outputs.items():
+ if write_if_changed(path, content):
+ changed += 1
+ print(f"Updated {path}")
+ else:
+ print(f"No change {path}")
+
+ print(f"Done. {changed} file(s) updated.")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/sidebars.ts b/sidebars.ts
index c99fcdd69d..665775e87c 100644
--- a/sidebars.ts
+++ b/sidebars.ts
@@ -2061,6 +2061,11 @@ const sidebars: SidebarsConfig = {
id: 'developer-info/02.08.DevelopmentWishList',
label: '2.7. Development wish list',
},
+ {
+ type: 'doc',
+ id: 'developer-info/02.09.AiKnowledgeAuthoring',
+ label: '2.8. AI Knowledge Authoring Guide',
+ },
],
},
{
@@ -2185,6 +2190,11 @@ const sidebars: SidebarsConfig = {
id: 'developer-info/04.03.06.ScriptCheckTopicLinks',
label: '4.3.6. check-topic-links.py',
},
+ {
+ type: 'doc',
+ id: 'developer-info/04.03.07.ScriptAiArtifacts',
+ label: '4.3.7. AI artifact scripts',
+ },
],
},
],
diff --git a/static/ai/juneau-knowledge.jsonl b/static/ai/juneau-knowledge.jsonl
new file mode 100644
index 0000000000..b7d4d3b3bc
--- /dev/null
+++ b/static/ai/juneau-knowledge.jsonl
@@ -0,0 +1,428 @@
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:d29c5fa4b242", "module": "api-metadata", "related_ids": [], "source_path": "juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/annotation/Schema.java", "source_type": "api-metadata", "summary": "Schema exposes summary/su metadata fields for concise AI-orien [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:b9cd2bb74560", "module": "api-metadata", "related_ids": [], "source_path": "juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/bean/BeanProp.java", "source_type": "api-metadata", "summary": "BeanProp exposes summary/su metadata fields for concise AI-oriente [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:6501f0250156", "module": "api-metadata", "related_ids": [], "source_path": "juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Marshalled.java", "source_type": "api-metadata", "summary": "Marshalled exposes summary/su metadata fields for concise AI-orie [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:01b021dcdee3", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-common/src/main/java/org/apache/juneau/http/annotation/Content.java", "source_type": "api-metadata", "summary": "Content exposes summary/su metadata fields for concise AI-or [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:ebfe5cea52b8", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-common/src/main/java/org/apache/juneau/http/annotation/FormData.java", "source_type": "api-metadata", "summary": "FormData exposes summary/su metadata fields for concise AI- [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:31cacc5f1437", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-common/src/main/java/org/apache/juneau/http/annotation/Header.java", "source_type": "api-metadata", "summary": "Header exposes summary/su metadata fields for concise AI-orie [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:dd1a4133877c", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-common/src/main/java/org/apache/juneau/http/annotation/Path.java", "source_type": "api-metadata", "summary": "Path exposes summary/su metadata fields for concise AI-oriented [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:e6f3080be0c6", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-common/src/main/java/org/apache/juneau/http/annotation/Query.java", "source_type": "api-metadata", "summary": "Query exposes summary/su metadata fields for concise AI-orient [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:e487595438cc", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-common/src/main/java/org/apache/juneau/http/annotation/Response.java", "source_type": "api-metadata", "summary": "Response exposes summary/su metadata fields for concise AI- [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:d745a0f9cbbf", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestDelete.java", "source_type": "api-metadata", "summary": "RestDelete exposes summary/su metadata fields for concise [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:bf83fb904826", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestGet.java", "source_type": "api-metadata", "summary": "RestGet exposes summary/su metadata fields for concise AI-or [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:2286330b94a8", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestOp.java", "source_type": "api-metadata", "summary": "RestOp exposes summary/su metadata fields for concise AI-orie [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:f53e804c48a8", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestOptions.java", "source_type": "api-metadata", "summary": "RestOptions exposes summary/su metadata fields for conci [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:36bd269a0d90", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestPatch.java", "source_type": "api-metadata", "summary": "RestPatch exposes summary/su metadata fields for concise A [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:3ca872d97a9b", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestPost.java", "source_type": "api-metadata", "summary": "RestPost exposes summary/su metadata fields for concise AI- [...]
+{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:68e2fcc08f07", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestPut.java", "source_type": "api-metadata", "summary": "RestPut exposes summary/su metadata fields for concise AI-or [...]
+{"description": "# Release 5.0.0.0\n\n**Date:** Jun 11, 2012\n\nVersion 5.0 marks a major release milestone for the Juno/JJSON library. \n\nIt is now available for download from iRAM under the name \"Juno (previously JJSON)\". \n\nThe Juno Starters Guide has been updated to reflect new functionality in this release.\n\n- New name. Unfortunately, \"JJSON\" was already trademarked by another similar library. Therefore, it's been renamed \"Juno\" (after the Roman goddess and wife of Jupit [...]
+{"description": "# Release 5.0.0.1\n\n**Date:** Jun 14, 2012\n\nJuno 5.0.0.1 is a moderate update.\n\n- New support for generating XML-Schema documents from POJO models.\n\n- New support for serializing to RDF/XML.", "id": "release-note:907dd2e70994", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.01.md", "source_type": "release-note", "summary": "**Date:** Jun 14, 2012", "tags": ["release-note", "release-notes"], "title": "Release 5.0.0.1", "upda [...]
+{"description": "# Release 5.0.0.2\n\n**Date:** Sept 28, 2012\n\nJuno 5.0.0.2 is a minor update.\n\n- Improvements to Javadocs.\n Most of the information in the Juno Starters Guide wiki has been moved into the overview and package-level javadocs.\n Since the information is now written in HTML, you can now copy and paste the code examples directly from the\n Javadocs.\n The code examples are also syntax-highlighted using CSS.\n\n- Support for defining default XML namespaces on package [...]
+{"description": "# Release 5.0.0.3\n\n**Date:** Oct 3, 2012\n\nJuno 5.0.0.3 is a minor update.\n\n- Support for parsing into read-only beans (i.e. beans with only getters, property values set through constructor args). To support this, the ~~@BeanConstructor~~ annotation has been added.\n\n- Merged separate settings classes back into their base classes (simplifies the API).\n\n- ~~SerializerGroups~~ and ~~ParserGroups~~ now share <a href=\"/site/apidocs/org/apache/juneau/BeanContext.html [...]
+{"description": "# Release 5.0.0.4\n\n**Date:** Oct 7, 2012\n\nJuno 5.0.0.4 is a minor update.\n\n- New ~~@RestMethod~~ annotation on ~~RestServlet~~ methods. Allows the usage of URL pattern matching and automatic conversion of URL variables to arguments passed to method handlers. See ~~RestServlet~~ for more information.\n\n- Enhancements to ~~BeanContext.convertToType(Object,Class)~~ to be able to convert `Strings` to classes with `fromString(String)`/`valueOf(String)` static methods o [...]
+{"description": "# Release 5.0.0.5\n\n**Date:** Oct 29, 2012\n\nJuno 5.0.0.5 is a major update.\n\n- New ~~@RestChild~~ annotation for identifying child resources.\n\n- New `traversable` and `filterable` attributes added to ~~@RestMethod~~ annotation. Eliminates the need for ~~PojoResource~~ and ~~FilteredRestResource~~ classes.\n\n- Simplified client API. Easier to use when making multiple connections to the same server.\n\n- Support for pluggable authentication in the client API.\n\n- [...]
+{"description": "# Release 5.0.0.6\n\n**Date:** Oct 30, 2012\n\nJuno 5.0.0.6 is a minor update that fixes a small bug in 5.0.0.5.", "id": "release-note:18f6baa0ff41", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.06.md", "source_type": "release-note", "summary": "**Date:** Oct 30, 2012", "tags": ["release-note", "release-notes"], "title": "Release 5.0.0.6", "updated_at": "source-controlled", "version": "5.0.0.06"}
+{"description": "# Release 5.0.0.7\n\n**Date:** Jan 20, 2013\n\nJuno 5.0.0.7 is a major update.\n\n### Core API updates\n\n- Combined previous 3 libraries into a single library.\n\n- New <a href=\"/site/apidocs/org/apache/juneau/parser/ParserListener.html\" target=\"_blank\">ParserListener</a> class.\n Adds ability to find and process unknown bean properties during parsing.\n\n- Enhancements to <a href=\"/site/apidocs/org/apache/juneau/xml/XmlParser.html\" target=\"_blank\">XmlParser</a [...]
+{"description": "# Release 5.0.0.8\n\n**Date:** Jan 30, 2013\n\nJuno 5.0.0.8 is a minor update.\n\n- New <a href=\"/site/apidocs/org/apache/juneau/config/package-summary.html\" target=\"_blank\">INI file</a> support.\n - Makes reading, updating, and manipulating INI configuration files a snap.\n - Supports automatic conversion of data types in line with the functionality of the rest of the product.\n - Comments and layout of INI files are persisted during saves.", "id": "release-note: [...]
+{"description": "# Release 5.0.0.9\n\n**Date:** Feb 26, 2013\n\nJuno 5.0.0.9 is a moderate update.\n\n### Core API changes\n\n- <a href=\"/site/apidocs/org/apache/juneau/config/package-summary.html\" target=\"_blank\">INI config file support</a>:\n - A convenient API for reading, writing, and manipulating INI files.\n - Ability to convert INI files to batch and shell environment variables.\n - Command-line interface for updating INI files.\n - Support for encoded INI file values.\n\n [...]
+{"description": "# Release 5.0.0.10\n\n**Date:** Mar 7, 2013\n\nJuno 5.0.0.10 is a minor update.\n\n### Core API changes\n\n- New ~~ObjectMap.findKeyIgnoreCase(String)~~ method.\n\n- HtmlSerializer will now create 2-dimensional tables for collections of mixed beans/maps if all object have the same set of property names/keys.\n\n### REST server API changes\n\n- New `RestServletProperties` class that defines all the class-level properties that can be set on the servlet.\n\n- Properties can [...]
+{"description": "# Release 5.0.0.11\n\n**Date:** Mar 8, 2013\n\nJuno 5.0.0.11 is a moderate update.\n\n### REST server API changes\n\n- New `UrlEncodingRestSerializer` and `UrlEncodingRestParser` classes. Allows parsing form posts directly to POJOs.\n\n- Support for `Accept` and `Content-Type` `\"application/x-www-form-urlencoded\"` added by default on ~~BasicRestServlet~~.\n\n- New ~~RestServlet.renderError(HttpServletRequest,HttpServletResponse,RestException)~~ method to allow customi [...]
+{"description": "# Release 5.0.0.12\n\n**Date:** Mar 10, 2013\n\nJuno 5.0.0.12 is a minor update.\n\n### Core API changes\n\n- Relaxed method naming conventions when using ~~@BeanProperty~~ annotation.\n Methods with zero parameters are interpreted as getters, and methods with one parameter are interpreted as setters.\n Eliminated the `BeanProperty.method` annotation, since it's now unnecessary.\n\n### REST server API changes\n\n- Significantly improved response error messages.\n Olde [...]
+{"description": "# Release 5.0.0.13\n\n**Date:** Mar 14, 2013\n\nJuno 5.0.0.13 is a minor update.\n\n### Core API changes\n\n- New support for relative URIs.\n - URIs of the form `\"foo/bar\"` are interpreted as relative to the context root of the web application.\n - URIs of the form `\"/foo/bar\"` are interpreted as relative to the HTTP authority (e.g. `\"http://myhost:9080\"`).\n\n- New `SerializerContext.SERIALIZER_uriContext` and `SerializerContext.SERIALIZER_uriAuthority` seriali [...]
+{"description": "# Release 5.0.0.14\n\n**Date:** Mar 23, 2013\n\nJuno 5.0.0.14 is a major update.\n\nThe biggest change is that the `RestSerializer`, `RestParser`, `RestSerializerGroup`, and `RestParserGroup` classes have\nbeen eliminated entirely.\nInstead, the existing <a href=\"/site/apidocs/org/apache/juneau/serializer/Serializer.html\" target=\"_blank\">Serializer</a>,\n<a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html\" target=\"_blank\">Parser</a>, ~~SerializerGroup~~, [...]
+{"description": "# Release 5.0.0.15\n\n**Date:** Mar 24, 2013\n\nJuno 5.0.0.15 is a moderate update.\n\n- Juno-Wink integration components that have been requested by many for a long time! Refer to ~~jaxrs~~ for information.\n\n- New ~~@Produces~~ annotation in place of `ISerializer.getMediaTypes()` for specifying what media types a serializer produces. Available when subclassing from <a href=\"/site/apidocs/org/apache/juneau/serializer/Serializer.html\" target=\"_blank\">Serializer</a> [...]
+{"description": "# Release 5.0.0.16\n\n**Date:** Mar 25, 2013\n\nJuno 5.0.0.16 is a minor update.\n\n- New ~~@Properties~~ REST method parameter annotation that can be used to get the runtime properties map through a parameter instead of through <a href=\"/site/apidocs/org/apache/juneau/rest/RestResponse.html\" target=\"_blank\">RestResponse</a>.", "id": "release-note:4dffa1b34a05", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.16.md", "source_ty [...]
+{"description": "# Release 5.0.0.17\n\n**Date:** Mar 25, 2013\n\nJuno 5.0.0.17 is a minor update.\n\n- Charset now passed as a parameter to `IOutputStreamSerializer.serialize()` and `IInputStreamParser.parse()`.", "id": "release-note:1a533c673995", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.17.md", "source_type": "release-note", "summary": "**Date:** Mar 25, 2013", "tags": ["release-note", "release-notes"], "title": "Release 5.0.0.17", "update [...]
+{"description": "# Release 5.0.0.18\n\n**Date:** Mar 27, 2013\n\nJuno 5.0.0.18 is a moderate update.\n\nThe biggest change is the introduction of the ~~RdfSerializer~~ class that uses Jena to generate RDF/XML,\nRDF/XML-ABBREV, N-Tuple, N3, and Turtle output.\n\nThis code should be considered prototype-quality, and subject to change in the future.\nThere are plans of adding an equivalent `RdfParser` class in the future, so the serializer logic may need to be\ntweaked to allow POJOs to be [...]
+{"description": "# Release 5.0.0.19\n\n**Date:** Apr 1, 2013\n\nJuno 5.0.0.19 is a minor update.\n\n- New methods on ~~RestServlet~~:\n - ~~RestServlet.onPreCall(RestRequest)~~\n - ~~RestServlet.onPostCall(RestRequest,RestResponse)~~\n\n- `TRIM_NULLS` setting changed to ~~SerializerContext.SERIALIZER_trimNullProperties~~. New property default is <jk>true</jk>. Only applies to bean properties, not map or collection entries.", "id": "release-note:254dc8260a5f", "module": "release-notes" [...]
+{"description": "# Release 5.0.0.20\n\n**Date:** Apr 7, 2013\n\nJuno 5.0.0.20 is a major update.\n\n### Core API changes\n\n- New Jena-based ~~RdfSerializer~~ for serializing POJOs to RDF/XML, RDF/XML-ABBREV, N-Triple, Turtle, and N3.\n Serializes ANY POJOs to RDF, even simple objects and primitives.\n\n- New Jena-based ~~RdfParser~~ for parsing RDF/XML, RDF/XML-ABBREV, N3, Turtle, and N-Triple back into POJOs.\n\n- ~~XmlSerializerContext.XML_autoDetectNamespaces~~ default changed to [...]
+{"description": "# Release 5.0.0.21\n\n**Date:** Apr 9, 2013\n\nJuno 5.0.0.21 is a minor update.\n\n### Core API changes\n\n- New ~~HtmlDocSerializerContext.HTMLDOC_navlinks~~ annotation for adding links to HTML page views.\n\n- Renamed the properties in ~~HtmlDocSerializerContext~~ for clarity.\n\n### Servlet API changes\n\n- Added new `RestServlet.addDefaultProperties(ObjectMap,RestRequest)` method for programmatically adding properties to\n the property map per request.\n\n- Added t [...]
+{"description": "# Release 5.0.0.22\n\n**Date:** Apr 12, 2013\n\nJuno 5.0.0.22 is a minor update.\n\n### Core API changes\n\n- New `@Property.nls()` annotation for specifying localized property values. For example, allows you to set the `HTMLDOC_title` and `HTMLDOC_description` properties to localized values pulled from a resource bundle. See the `AddressBookResource` class for an example.\n\n### REST Servlet API changes\n\n- Fix a bug where the `&Content` query parameter was not always [...]
+{"description": "# Release 5.0.0.23\n\n**Date:** Apr 14, 2013\n\nJuno 5.0.0.23 is a minor update.\n\n- Simplified ~~Cognos~~ support.\n\n- Fixed bug where <a href=\"/site/apidocs/org/apache/juneau/xml/annotation/Xml.html\" target=\"_blank\">@Xml</a> annotation was not being inherited by inner classes.\n\n- Javadoc stylesheet improvements.", "id": "release-note:03d8a6c609a7", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.23.md", "source_type": "re [...]
+{"description": "# Release 5.0.0.24\n\n**Date:** May 9, 2013\n\nJuno 5.0.0.24 is a major update.\n\n### Core API updates\n\n- New support for <a href=\"/site/apidocs/org/apache/juneau/bean/atom/package-summary.html\" target=\"_blank\">ATOM</a>.\n - New `AtomFeedResource` class added to sample war.\n\n- New ~~XmlFormat.CONTENT~~ enum value.\n Allows bean properties to be persisted as XML element text.\n\n- New ~~XmlContentHandler~~ class and ~~@Xml.contentHandler~~ annotation.\n Allows [...]
+{"description": "# Release 5.0.0.25\n\n**Date:** May 11, 2013\n\nJuno 5.0.0.25 is a minor update.\n\n### Core API updates\n\n- New <a href=\"/site/apidocs/org/apache/juneau/bean/ResultSetList.html\" target=\"_blank\">ResultSetList</a> DTO for serializing SQL result sets to JSON/XML/HTML and so forth.\n\n- New `SqlQueryResource` class in the sample war for demonstrating the `ResultSetList` DTO.\n\n### Server API updates\n\n- Fixed issue with media type for CSS files being reported as `tex [...]
+{"description": "# Release 5.0.0.26\n\n**Date:** Jun 5, 2013\n\nJuno 5.0.0.26 is a minor update.\n\n- FindBug fixes.\n\n- Changed the way child REST resources are defined.\n Eliminated the ~~@RestChild~~ annotation on getter methods and replaced it with ~~@RestResource(children)~~ defined on the\n resource class itself.\n Child resource paths are specified through ~~@RestResource(path)~~.\n\n- New ~~ChildResourceDescriptions~~ bean for automatically generating the contents of router r [...]
+{"description": "# Release 5.0.0.27\n\n**Date:** July 7, 2013\n\nJuno 5.0.0.27 is a moderate update.\n\n- Fixed some HTML formatting issues in <a href=\"/site/apidocs/org/apache/juneau/html/HtmlSerializer.html\" target=\"_blank\">HtmlSerializer</a>.\n\n- ~~BasicRestServlet~~ now includes <a href=\"/site/apidocs/org/apache/juneau/plaintext/PlainTextSerializer.html\" target=\"_blank\">PlainTextSerializer</a> and <a href=\"/site/apidocs/org/apache/juneau/plaintext/PlainTextParser.html\" ta [...]
+{"description": "# Release 5.0.0.28\n\n**Date:** July 9, 2013\n\nJuno 5.0.0.28 is a moderate update.\n\n- Fixes an `OutOfMemoryError` and performance issue caused by incorrect caching of class metadata.\n\n- Added `WriterSerializer.serialize(Object,Writer)` convenience method for serializing directly to a writer.\n Applies to all serializers.", "id": "release-note:630be68f9150", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.28.md", "source_type" [...]
+{"description": "# Release 5.0.0.29\n\n**Date:** Aug 2, 2013\n\nJuno 5.0.0.29 is a moderate update.\n\n- Revamped the API for filter support:\n - Updated ~~BeanFilter~~ class to mirror the <a href=\"/site/apidocs/org/apache/juneau/annotation/Bean.html\" target=\"_blank\">@Bean</a> annotation.\n - Introduced support for bean ~~Bean.subTypeProperty() subtypes~~.\n - Replaced `@Bean(filter=xxx)` with new ~~@Transform~~ annotation.\n\n- Revamped URL-Encoding support.\n The old URL-Encod [...]
+{"description": "# Release 5.0.0.30\n\n**Date:** Aug 8, 2013\n\nJuno 5.0.0.30 is a minor update.\n\n- Fixed bug involving beans using ~~Bean.subTypes()~~ annotation in addition to `subTypes` property.\n\n- Modified the <a href=\"/site/apidocs/org/apache/juneau/json/JsonParser.html\" target=\"_blank\">JSON parser</a> to handle non-existent JSON values to get around an issue where Cognos was generating invalid JSON.", "id": "release-note:82071ec90233", "module": "release-notes", "related_i [...]
+{"description": "# Release 5.0.0.31\n\n**Date:** Aug 9, 2013\n\nJuno 5.0.0.31 is a moderate update.\n\n- Simplified the <a href=\"/site/apidocs/org/apache/juneau/serializer/Serializer.html\" target=\"_blank\">Serializer</a> and <a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html\" target=\"_blank\">Parser</a> class hierarchies.\n This reverses a previous change that added a bunch of interfaces in these APIs (and subsequently required compiling with\n Java 7 to get around a com [...]
+{"description": "# Release 5.0.0.32\n\n**Date:** Oct 5, 2013\n\nJuno 5.0.0.32 is a moderate update.\n\n- New support for generating and consuming fully-compliant JSON-Schema documents.\n See ~~jsonschema~~ for information.\n\n- New methods added to <a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html\" target=\"_blank\">Parser</a>:\n - `org.apache.juneau.parser.Parser.parseMap(Object,int,Class,Class,Class)`\n - `org.apache.juneau.parser.Parser.parseCollection(Object,int,Class [...]
+{"description": "# Release 5.0.0.33\n\n**Date:** Oct 20, 2013\n\nJuno 5.0.0.33 is a moderate update.\n\n- Removed generic parameter from <a href=\"/site/apidocs/org/apache/juneau/serializer/WriterSerializer.html\" target=\"_blank\">WriterSerializer</a> class.\n - Many of the examples in the documentation were written as follows, which resulted in \"unchecked\" compile warnings:\n `WriterSerializer s = new JsonSerializer();`\n These compile warnings will now go away.\n\n- New setti [...]
+{"description": "# Release 5.0.0.34\n\n**Date:** Nov 10, 2013\n\nJuno 5.0.0.34 is a moderate update.\n\n- New support for runtime-replaced variables in REST resource properties:\n\n ```java\n @RestResource(\n messages=\"nls/Messages\",\n properties={\n @Property(name=\"label\",value=\"$L{servletTitle}\"), // Localized variable in Messages.properties\n @Property(name=\"javaVendor\",value=\"$S{java.vendor}\"), // System property\n @Property(name=\"f [...]
+{"description": "# Release 5.0.0.35\n\n**Date:** Nov 26, 2013\n\nJuno 5.0.0.35 is a minor update.\n\n- ~~RestGuard.guard(RestRequest,RestResponse)~~ now returns a boolean to allow redirects to login pages.\n- Fixed bug in `RestServlet` where occasional false positive `duplicate method with same name and path` errors were occurring.", "id": "release-note:ab767403d7d9", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.35.md", "source_type": "release-n [...]
+{"description": "# Release 5.0.0.36\n\n**Date:** Dec 18, 2013\n\nJuno 5.0.0.36 is a minor update.\n\n- Implemented `org.apache.juneau.urlencoding.UrlEncodingParser.parseArgs(Reader,int,ClassMeta[])`.\n- `name` parameter of ~~ResourceDescription.ResourceDescription(String,String,String)~~ is now automatically URL-encoded so that the name can contain special characters (e.g. `foo/bar(baz)`).\n- Support for URL-matching and path info containing encoded characters (e.g. '/') now supported.\n [...]
+{"description": "# Release 5.1.0.0\n\n**Date:** Jan 18, 2014\n\nJuno 5.1.0.0 is a major update.\n\n### Major changes\n\n- Brand new REST client API that uses Apache HttpClient for HTTP communication.\n The new client API is simply a thin layer on top of `HttpClient` that performs serialization and parsing using Juno\n parsers but leaves all the details of the HTTP connection to the Apache code.\n See the ~~client~~ package for details.\n\n- New `org.apache.juneau.rest.client.jazz` pa [...]
+{"description": "# Release 5.1.0.1\n\n**Date:** Jan 25, 2014\n\nJuno 5.1.0.1 is a minor update.\n\n- Addressed some behavioral differences between Tomcat and WAS.\n - Query parameter lookup is now always case-insensitive (per WAS behavior).\n - Consistent handling of redirect requests (Tomcat and WAS handle relative redirect paths differently).\n\n- Fixed bug involving incorrect resolution of overlapping URL match patterns.\n\n- Overall improvements in HTTP request parameter and header [...]
+{"description": "# Release 5.1.0.2\n\n**Date:** Apr 27, 2014\n\nJuno 5.1.0.2 is a minor update.\n\n- Fixed issue preventing `&Accept-Language` from being used as a GET parameter.\n\n- Minor XSS vulnerability fix.\n\n- Empty results on HTML pages now shows `no results` instead of a blank page.\n\n- Fixed issues preventing REST pages from rendering HTML in newer versions of Internet Explorer.\n\n- Changed `RestServletProperties.REST_allowMethodParam` to be disabled by default.", "id": "rel [...]
+{"description": "# Release 5.1.0.3\n\n**Date:** Jun 28, 2014\n\nJuno 5.1.0.3 is a moderate update.\n\n### Core API updates\n\n- Ability to detect and use non-public bean classes, getters/setters, and fields using the following new properties:\n - ~~BeanContext.BEAN_beanConstructorVisibility~~ - Control which bean constructors are visible to Juno.\n - ~~BeanContext.BEAN_beanClassVisibility~~ - Control which bean classes are interpreted as beans to Juno.\n - ~~BeanContext.BEAN_beanField [...]
+{"description": "# Release 5.1.0.4\n\n**Date:** Aug 25, 2014\n\nJuno 5.1.0.4 is a minor update.\n\n- New ~~RestServlet.getPath()~~ method.\n\n- New `SerializerContext.getJavaMethod()` and `ParserContext.getJavaMethod()` to allow access to REST methods that invoked the serializers or parsers.\n For example, can be used to access additional annotations on REST methods to perform special handing during\n serialization or parsing.\n\n- Better behavior on overriding of filters in `BeanConte [...]
+{"description": "# Release 5.1.0.5\n\n**Date:** Sept 1, 2014\n\nJuno 5.1.0.5 is a moderate update.\n\n- New ~~Redirect~~ class that simplifies performing redirections in REST methods.\n\n- New pluggable ~~ResponseHandler~~ class and ~~@RestResource(responseHandlers)~~ annotation for defining customer response handlers for special kinds of POJOs.\n\n- New method ~~UrlEncodingSerializer.serializeUrlPart(Object)~~ method.\n\n- New method ~~RestRequest.getServletURIBuilder()~~ for construci [...]
+{"description": "# Release 5.1.0.6\n\n**Date:** Sept 21, 2014\n\nJuno 5.1.0.6 is a moderate update.\n\n- Simplified API for ~~PojoSwap~~.\n Since it's rarely used, the `beanContext` parameter was replaced with a ~~PojoSwap.getBeanContext()~~ method on the\n class.\n\n- New simplified way of defining POJO filters without needing to extend ~~PojoSwap~~.\n See ~~SurrogateSwap~~ for details.\n\n- New <a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html\" target=\"_blank\ [...]
+{"description": "# Release 5.1.0.7\n\n**Date:** Oct 5, 2014\n\nJuno 5.1.0.7 is a moderate update.\n\n- Improved error handling.\n\n- New ~~ParserContext.PARSER_debug~~ and ~~SerializerContext.SERIALIZER_debug~~ settings for logging additional information for debugging problems.\n\n- New ~~SERIALIZER_ignoreRecursions~~ setting for explicitly ignoring recursions when serializing models.\n Previously, the `SERIALIZER_detectRecursions` setting did this but now it simply looks for recursions [...]
+{"description": "# Release 5.1.0.8\n\n**Date:** Oct 25, 2014\n\nJuno 5.1.0.8 is a moderate update, focused primarily on performance improvements.\n\n- Improved performance on JSON and URL-Encoding parsers by approximately 50% on large data sets.\n - Rewrote <a href=\"/site/apidocs/org/apache/juneau/parser/ParserReader.html\" target=\"_blank\">ParserReader</a> class to handle it's own buffering.\n The change allowed several optimizations to be made when dealing with JSON and URL-Encod [...]
+{"description": "# Release 5.1.0.9\n\n**Date:** Dec 1, 2014\n\nJuno 5.1.0.9 is a major update.\n\nThere weren't very many code changes but the source has been made a part of Jazz Foundation.\nThis required some restructuring of the project.\nThe project on Jazz Hub will eventually be discontinued.\nHowever, the libraries on IBM Community Source will continue to be updated regularly.\n\n- Project split up into 3 separate bundles:\n - `org.apache.juneau` - Core serializers and parsers.\n [...]
+{"description": "# Release 5.1.0.10\n\n**Date:** Dec 23, 2014\n\nJuno 5.1.0.10 is a moderate update.\n\n### Core\n\n- Major changes to URL-Encoded serializer and parser.\n - Logic for serializing and parsing URL-Encoded key-value pairs moved to <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingSerializer.html\" target=\"_blank\">UrlEncodingSerializer</a> and <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingParser.html\" target=\"_blank\">UrlEncodingParser< [...]
+{"description": "# Release 5.1.0.11\n\n**Date:** Feb 14, 2015\n\nJuno 5.1.0.11 is a moderate update.\n\n### Core\n\n- Additions to <a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html\" target=\"_blank\">@Html</a> bean annotation.\n - New <a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html#noTables()\" target=\"_blank\">@Html(noTables)</a> annotation that prevents arrays/Collections from being serialized as tables.\n - New <a href=\"/site/apidocs/org/apac [...]
+{"description": "# Release 5.1.0.12\n\n**Date:** Mar 28, 2015\n\nJuno 5.1.0.12 is a minor update.\n\n### Core\n\n- Fixed ~~ConfigFile.isEmpty()~~ method.\n\n- Changed behavior on <a href=\"/site/apidocs/org/apache/juneau/uon/UonParser.html\" target=\"_blank\">UonParser</a> to not treat `'~'` characters as escapes unless followed by one of the following characters: `( ) , $ = ~`.\n\n### Client\n\n- New class ~~RestCallInterceptor~~.\n Allows responses to be inspected and modified before [...]
+{"description": "# Release 5.1.0.13\n\n**Date:** Apr 24, 2015\n\nJuno 5.1.0.13 is a minor update.\n\n### Core\n\n- <a href=\"/site/apidocs/org/apache/juneau/ClassMeta.html#newInstance()\" target=\"_blank\">ClassMeta.newInstance()</a> method can now create new instances of arrays.\n\n- Arguments passed to ~~Link~~ are now serialized using <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingSerializer.html\" target=\"_blank\">UrlEncodingSerializer</a>, so arbitrary POJOs can [...]
+{"description": "# Release 5.1.0.14\n\n**Date:** May 10, 2015\n\nJuno 5.1.0.14 is a moderate update.\n\nThe major addition is support for **Remoteable Services**, the ability to invoke server-side POJO methods through\nclient-side proxy interfaces.\n\n### Core\n\n- Simplified ~~PojoIntrospector~~ class.\n\n- New ~~ClassUtils.getMethodSignature(Method)~~ method.\n\n### Client\n\n- New methods in <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html\" target=\"_blank\">Res [...]
+{"description": "# Release 5.1.0.15\n\n**Date:** May 24, 2015\n\nJuno 5.1.0.15 is a minor update.\n\n### Core\n\n- New properties in ~~SerializerContext~~:\n 1. ~~SerializerContext.SERIALIZER_relativeUriBase~~\n 2. ~~SerializerContext.SERIALIZER_absolutePathUriBase~~\n\n These replace the `SERIALIZER_uriAuthority` and `SERIALIZER_uriContext` properties.\n\n- Improvements in <a href=\"/site/apidocs/org/apache/juneau/csv/CsvSerializer.html\" target=\"_blank\">CsvSerializer</a>.\n\n### S [...]
+{"description": "# Release 5.1.0.16\n\n**Date:** June 28, 2015\n\nJuno 5.1.0.16 is a moderate update.\n\n### Core\n\n- New methods on <a href=\"/site/apidocs/org/apache/juneau/ClassMeta.html\" target=\"_blank\">ClassMeta</a> that eliminates language-specific code in the general class metadata.\n - ~~ClassMeta.getXmlMeta()~~\n - ~~ClassMeta.getJsonMeta()~~\n - ~~ClassMeta.getHtmlMeta()~~\n - ~~ClassMeta.getUrlEncodingMeta()~~\n - ~~ClassMeta.getRdfMeta()~~\n\n- New <a href=\"/site/ap [...]
+{"description": "# Release 5.1.0.17\n\n**Date:** Aug 3, 2015\n\nJuno 5.1.0.17 is a major update.\n\n### Core\n\n- <a href=\"/site/apidocs/org/apache/juneau/BeanMap.html#get(java.lang.Object)\" target=\"_blank\">BeanMap.get(Object)</a> and <a href=\"/site/apidocs/org/apache/juneau/BeanMap.html#put(java.lang.String,java.lang.Object)\" target=\"_blank\">BeanMap.put(String,Object)</a> now automatically performs filtering if filters are defined on the bean property or bean property class.\n [...]
+{"description": "# Release 5.1.0.18\n\n**Date:** Aug 5, 2015\n\nJuno 5.1.0.18 is a minor update affecting the server component only.\n\n### Server\n\n- Fixed bug where localized strings weren't resolving when using chained resource bundles.\n\n- Servlet and method labels and descriptions can now contain embedded string variables.\n\n- New ~~RestMethod.input()~~ and ~~RestMethod.responses()~~ annotations.\n These replace the various `description` annotations added 2 days ago with a simpl [...]
+{"description": "# Release 5.1.0.19\n\n**Date:** Aug 15, 2015\n\nJuno 5.1.0.19 is a minor update in terms of core functionality.\n\nBut it introduces a **Microservices** project for building REST microservices and docker containers.\n\n### Core\n\n- Beans can now be serialized to and parsed from ~~ObjectMaps~~.\n See **Serializing to ObjectMaps** for details.\n\n- New ~~ObjectMap.include(String[])~~ and ~~ObjectMap.exclude(String[])~~ methods.\n\n- <a href=\"/site/apidocs/org/apache/jun [...]
+{"description": "# Release 5.1.0.20\n\n**Date:** Sept 5, 2015\n\nJuno 5.1.0.20 is a moderate update.\n\nThe biggest improvement is the ability to associate external INI config files with REST servlets using the\n ~~ConfigFile~~ functionality.\n\n### Core\n\n- Significant API changes to `org.apache.juneau.config` API.\n - ~~ConfigFile~~ is now thread safe and can be shared across multiple threads.\n - New ~~ConfigMgr~~ class for managing configuration files.\n - Serializers and parser [...]
+{"description": "# Release 5.2.0.0\n\n**Date:** Dec 30, 2015\n\nJuno 5.2.0.0 is a major update.\n\nMajor changes have been made to the microservice architecture and config INI file APIs.\n\n### Core\n\n- Significant changes and enhancements to the `org.apache.juneau.config` API.\n - More consistent handling of comma-delimited lists of objects.\n - New methods in ~~ConfigFile~~:\n - ~~ConfigFile.getStringArray(String)~~, ~~ConfigFile.getStringArray(String,String[])~~\n - ~~Config [...]
+{"description": "# Release 5.2.0.1\n\n**Date:** Mar 23, 2016\n\nJuno 5.2.0.1 is a moderate update.\n\n### com.ibm.team.juno\n\n- Improved support for multi-line values in config files.\n Any line that begins with whitespace is interpreted as a continuation of the previous line.\n\n- Support for `'\\uXXXX'` character sequences in config files.\n\n- Fixed issue in <a href=\"/site/apidocs/org/apache/juneau/xml/XmlSerializer.html\" target=\"_blank\">XmlSerializer</a> where `'\\r'` and `'\\n [...]
+{"description": "# Release 6.0.0\n\n**Date:** Oct 3, 2016\n\nJuneau 6.0.0 is a major update.\n\nThe major change is rebranding from \"Juno\" to \"Juneau\" in preparation for donation to the Apache Foundation.\n\n### org.apache.juneau\n\n- Major changes around how serializer and parser class properties are defined to improve performance and\n concurrency.\n\n - New ~~PropertyStore~~ class - Used for creating context objects.\n - New <a href=\"/site/apidocs/org/apache/juneau/Context.htm [...]
+{"description": "# Release 6.0.1\n\n**Date:** Jan 3, 2017\n\nJuneau 6.0.1 is a minor update.\n\n### org.apache.juneau\n\n- General improvements to JSON parser.\n - Several fixes to handle obscure edge cases.\n\n- New properties in ~~ParserContext~~.\n - ~~ParserContext.PARSER_strict~~\n - ~~ParserContext.PARSER_inputStreamCharset~~\n - ~~ParserContext.PARSER_fileCharset~~\n\n- Removed `JsonParserContext.JSON_strictMode`. Replaced by `PARSER_strict`.\n\n- `byte[]` arrays can now be p [...]
+{"description": "# Release 6.1.0\n\n**Date:** Feb 25, 2017\n\nJuneau 6.1.0 is a major update.\n\nIn particular, this release cleans up the <a href=\"/site/apidocs/org/apache/juneau/BeanContext.html\" target=\"_blank\">BeanContext</a> API to\nmatch the ~~PropertyStore~~/<a href=\"/site/apidocs/org/apache/juneau/Context.html\" target=\"_blank\">Context</a>/ ~~Session~~ paradigm previously\nused in the serializer and parser APIs.\nIt also makes several improvements to the HTML and XML seri [...]
+{"description": "# Release 6.2.0\n\n**Date:** Apr 28, 2017\n\nJuneau 6.2.0 is a major update.\n\n### org.apache.juneau\n\n- Revamped the serializer, parser classes to use builders for creation.\n Serializers and parsers are now unmodifiable objects once they are created.\n This is a breaking code change that will require adoption.\n\n ```java\n /* Creating a new serializer or parser */ \n \n // Old way\n WriterSerializer s = new JsonSerializer().setUseWhitespace(true).pojoSwaps(BS [...]
+{"description": "# Release 6.3.0\n\n**Date:** Jun 30, 2017\n\nJuneau 6.3.0 is a major update with significant new functionality for defining proxy interfaces against arbitrary\n3rd-party REST interfaces.\n\n### org.apache.juneau\n\n- New package: <a href=\"/site/apidocs/org/apache/juneau/http/package-summary.html\" target=\"_blank\">org.apache.juneau.http</a>.\n\n- Support for dynamic beans. See ~~@BeanProperty(name)~~.\n\n- New doc: ~~2.8 - Virtual Beans~~\n\n- New doc: ~~2.13 - Compari [...]
+{"description": "# Release 6.3.1\n\n**Date:** Aug 1, 2017\n\nJuneau 6.3.1 is a minor release.\n\n### org.apache.juneau\n\n- ~~PojoQuery~~ improvements.\n\n- New ~~RemoteMethod.returns()~~ annotation.\n Allows you to specify whether the remote method returns the HTTP body or status code.\n\n- Fixed bugs with ~~BEAN_includeProperties~~ and ~~BEAN_excludeProperties~~ settings.\n\n- New/modified settings in ~~HtmlDocSerializerContext~~:\n\n - ~~HTMLDOC_script~~\n - ~~HTMLDOC_style~~ [...]
+{"description": "# Release 6.4.0\n\n**Date:** Oct 5, 2017\n\nThe major change in this release is the project structure.\n\nThe library now consists of the following artifacts found in the Maven group `\"org.apache.juneau\"`:\n\n| Category | Maven Artifacts | Description | Prereqs |\n|----------|-----------------|-------------|---------|\n| **Juneau Core** | `juneau-marshall` | Serializers and parsers for: JSON, XML, HTML, UON, URL-Encoding, MessagePack, SOAP/XML, CSV, BSON (coming soon), [...]
+{"description": "# Release 7.0.0\n\n**Date:** Oct 25, 2017\n\nThis release ups the Java prerequisite to Java 7.\n\n### juneau-marshall\n\n- New class ~~HttpMethodName~~ with valid static string HTTP method names.\n\n### juneau-dto\n\n- Class ~~org.apache.juneau.dto.Link~~ renamed to <a href=\"/site/apidocs/org/apache/juneau/bean/LinkString.html\" target=\"_blank\">LinkString</a>.\n Helps avoid confusion since there are other Link classes in the library.\n\n### juneau-rest-server\n\n- A [...]
+{"description": "# Release 7.0.1\n\n**Date:** Dec 24, 2017\n\nThis release is a minor update.\nIt includes the following prereq updates:\n\n- Apache HttpClient: 4.5.3 to 4.5.4\n- Eclipse Jetty: 9.4.6.v20170531 to 9.4.8.v20171121\n\n### juneau-marshall\n\n- New static `create()` methods for builders on serializers and parsers.\n This simplifies the syntax of creation of serializers and parsers by scratch.\n\n ```java\n // Old way\n JsonSerializer s1 = new JsonSerializer.Builder().ws() [...]
+{"description": "# Release 7.1.0\n\n**Date:** Mar 08, 2018\n\nVersion 7.1.0 is a major update with major implementation refactoring across all aspects of the product.\n\n### juneau-marshall\n\n- Significant improvements made to the internals of the Serializer and Parser classes.\n\n - Caching improvements on serializers and parsers have reduced execution time of the core JUnits by approximately\n 1/3.\n The 17000+ JUnit tests now execute in less than 10 seconds and have a cache-re [...]
+{"description": "# Release 7.2.0\n\n**Date:** Sept 25, 2018\n\n7.2.0 is a major release that introduces several significant new features:\n\n- OpenAPI part serializing and parsing with full support for OpenAPI validation of input and output in the REST\n servlet and client APIs.\n- Swagger UI.\n- New HTTP-Part annotations that are applicable to both the servlet and client APIs.\n- Serverless servlet and client unit testing.\n- Simplified UI customization.\n- Marshalls that combines seri [...]
+{"description": "# Release 7.2.1\n\n**Date:** Oct 23, 2018\n\nThis release contains mostly bug fixes.\nCode changes have been made to preserve binary backwards compatibility with 7.1.0.\n\n### juneau-marshall\n\n- The ~~@JsonSchema~~ annotation has been merged with the ~~@Schema~~ annotation.\n\n- Annotations typically used on bean properties (getters/setters/public fields) can now be used on private fields.\n This is inline with behavior on JPA-annotated beans.\n These include: `@Swap [...]
+{"description": "# Release 7.2.2\n\n**Date:** Nov 7, 2018\n\nThis release contains minor bug fixes and general improvements to the PetStore sample application.", "id": "release-note:20adb785ad2a", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/7.2.2.md", "source_type": "release-note", "summary": "**Date:** Nov 7, 2018", "tags": ["release-note", "release-notes"], "title": "Release 7.2.2", "updated_at": "source-controlled", "version": "7.2.2"}
+{"description": "# Release 8.0.0\n\n**Date:** Jan 01, 2019\n\nThis release cleans up deprecated APIs from the 7.2.0 release and makes significant modifications to the Microservice\nAPIs.\n\nThe project structures of the REST, Microservice, and Examples have been modified to fit new Spring Boot integration\nsupport.\n\nThe structure is now as follows:\n\n- `juneau-rest`\n - `juneau-rest-client`\n - `juneau-rest-server`\n - `juneau-rest-server-jaxrs`\n - `juneau-rest-server-rdf`\n - * [...]
+{"description": "# Release 8.1.0\n\n**Date:** Aug 21, 2019\n\n8.1.0 introduces some significant new features including:\n\n- ~~Configurable Annotations~~\n- ~~Default PojoSwaps~~\n- ~~Config Imports~~\n- ~~BasicRest~~, ~~BasicRestGroup~~ classes\n- ~~Path variables on resource paths~~\n- ~~Request Attributes API~~\n- ~~Role Guards~~\n- ~~Improved REST logging/debugging~~\n- New MockRest API\n\n### juneau-marshall\n\n- New utility class for diffing beans:\n <tree>\n <node-0><java-class> [...]
+{"description": "# Release 8.1.1\n\n**Date:** Sept 20, 2019\n\nJuneau 8.1.1 is a minor release but introduces some new features/modifications.\n\n### juneau-marshall\n\n- Support for serializing/parsing [Optional](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html) objects and bean properties.\n\n- Fixed a bug in the parsers where the generic subtype of a complex bean property type involving both collections and arrays was not being found. (e.g. `List<Long>[]`)\n\n- New pa [...]
+{"description": "# Release 8.1.2\n\n**Date:** Dec 01, 2019\n\nJuneau 8.1.2 is a moderate release.\n\n### juneau-marshall\n\n- Support for read-only and write-only properties.\n\n <tree>\n <node-0><java-annotation> ~~@Bean.bpro()~~</java-annotation></node-0>\n <node-0><java-annotation> ~~@Bean.bpwo()~~</java-annotation></node-0>\n <node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/annotation/Beanp.html#ro()\" target=\"_blank\">@Beanp.ro()</a></java-annotation></node-0> [...]
+{"description": "# Release 8.1.3\n\n**Date:** Jan 20, 2020\n\nJuneau 8.1.3 is a moderate release.\n\n### juneau-marshall\n\n- Dynamically applied annotations: ~~DynamicallyAppliedAnnotations~~\n- Better representation of nulls for XML and HTML content properties.\n - Old: `\"<myBean><null></myBean>\"`\n - New: `\"<myBean nil='true'></myBean>\"`\n- Configurable properties such as ~~Context.CONTEXT_debug~~ can now be set globally by either system properties or environment variables.\n [...]
+{"description": "# Release 8.2.0\n\n**Date:** Oct 14, 2020\n\nJuneau 8.2.0 is a major release. \n\nThe most significant change is the addition of an entirely new ~~RestClient~~ API build from scratch with near 100% unit test coverage.\n\nThe new API is located in the `org.apache.juneau.rest.client2` package and will replace the old API in 9.0.\n\n### juneau-marshall\n\n- <a href=\"/site/apidocs/org/apache/juneau/annotation/Bean.html\" target=\"_blank\">@Bean</a> and <a href=\"/site/apid [...]
+{"description": "# Release 9.0.0\n\n**Date:** Feb 27, 2023\n\nJuneau 9.0.0 is a major release.\nDeprecated APIs that have been accumulating over time have been removed.\n\nMajor changes include:\n\n- The code has undergone significant refactoring to ease maintainability and improve overall performance.\n- Configuration properties have been removed entirely.\n They have been replaced with a standard builder-based architecture.\n In addition to making the code more maintainable, it also [...]
+{"description": "# Release 9.0.1\n\n**Date:** Sept 6, 2023\n\nJuneau 9.0.1 is a minor maintenance release containing dependency updates.\n\n## Dependency Updates\n\n- Updated all dependent project versions to their latest minor releases\n- Security patches and bug fixes from upstream dependencies\n- Improved compatibility with latest build tools and environments\n\n## Notes\n\nThis release contains no functional changes to Juneau APIs or features.\nAll changes are limited to dependency v [...]
+{"description": "# Release 9.1.0\n\n**Date:** June 19, 2025\n\nJuneau 9.1.0 is a major compatibility update focused on Jakarta EE migration and Spring Boot modernization.\n\n## Major Changes\n\n### Jakarta EE Migration\n\n- **Complete javax to jakarta namespace migration**: All references to `javax.*` packages have been converted to their corresponding `jakarta.*` equivalents.\n This includes:\n - `javax.servlet.*` \u2192 `jakarta.servlet.*`\n - `javax.validation.*` \u2192 `jakarta.va [...]
+{"description": "# Release 9.2.0\n\n**Date:** 01/05/2026\n\nJuneau 9.2.0 is a minor release focused on enhancements and bug fixes.\n\nMajor changes include:\n\n- **Hjson (Human JSON) Support**: New native serializer and parser for Hjson format with quoteless strings, multiline strings, comments, and optional commas \u2014 ideal for configuration files and hand-edited data\n- **New Module**: Introduced `juneau-shaded` with five shaded (uber) JAR artifacts for simplified dependency managem [...]
+{"description": "# Release 9.5.0\n\n**Date:** TBD\n\nJuneau 9.5.0 is a minor release with native TOML and YAML support, BSON (Binary JSON) support for MongoDB-interoperable binary serialization, CBOR (Concise Binary Object Representation) per RFC 8949 for IoT and constrained environments, full CSV serializer/parser support, JCS (JSON Canonicalization Scheme) per RFC 8785 for deterministic hashing and signing, RDF/THRIFT and RDF/PROTO binary format support, native serialization support fo [...]
+{"description": "#### About\n\nApache Juneau\u2122 is a single cohesive Java ecosystem for marshalling Java objects to a wide variety of language types and \ncreating annotation-based REST end-to-end server and client APIs.\n\n#### Ecosystem\n\nThe Juneau ecosystem consists of the following parts:\n\n| Category | Maven Artifacts | Description | Prerequisites |\n|----------|------------------|-------------|---------------|\n| **juneau-core** | [juneau\u2011assertions](/docs/topics/JuneauA [...]
+{"description": "The [juneau-marshall](/docs/topics/JuneauMarshallBasics) library includes easy-to-use and highly customizable serializers and parsers based around a common\nAPI.\nIt allows you to marshall Java POJOs directly to and from a wide variety of language types without the need for\nintermediate Document Object Models making them extremely efficient.\n\nSupported languages include: \n\n- JSON\n- XML\n- HTML\n- UON\n- URL-Encoding\n- MessagePack\n- OpenAPI\n- SOAP/XML\n- CSV\n- Y [...]
+{"description": "The [juneau-rest-server](/docs/topics/JuneauRestServerBasics) and [juneau-rest-client](/docs/topics/JuneauRestClientBasics) libraries provide server and client side REST capabilities that can be\nused by themselves, or together to create simplified yet sophisticated Java-based REST communications layers that\ncompletely hide away the complexities of the REST protocol.\n\nA typical pattern is to define a REST API on the server side:\n\n```java\n@Rest(path=\"/petstore\")\n [...]
+{"description": "#### `@Rest`-Annotated Resources\n\nA REST resource is simply a Java class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">Rest</a>.\nThe most common case is a class that extends <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a>, which itself is simply an extension of <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/htt [...]
+{"description": "Built upon the feature-rich Apache HttpClient library, the Juneau RestClient API adds support for fluent-style REST\ncalls and the ability to perform marshalling of POJOs to and from HTTP parts.\n\n:::tip Example\n```java\n// Create a basic REST client with JSON support and download a bean.\nMyBean bean = RestClient.create()\n .json5()\n .build()\n .get(URI)\n .run()\n .assertStatus().asCode().is(200)\n .assertHeader(\"Content-Type\").matchesSimple(\"ap [...]
+{"description": "The [juneau-bean](/docs/topics/JuneauBeanBasics) libraries contain several predefined POJOs for generating commonly-used document types that are designed\nto be used with the Juneau Marshaller APIs for both serializing and parsing.\n\n#### HTML5\n\nThe Juneau HTML5 DTO beans are simply beans with fluent-style setters that allow you to quickly construct HTML fragments as\nJava objects.\nThese objects can then be serialized to HTML using one of the existing HTML serializer [...]
+{"description": "The [juneau-config](/docs/topics/JuneauConfigBasics) library contains a powerful API for creating and using INI-style config files.\n\n:::tip Example configuration file\n```ini\n# A set of entries\n[Section1]\n\n# An integer\nkey1 = 1\n\n# A boolean\nkey2 = true\n\n# An array\nkey3 = 1,2,3\n\n# A POJO\nkey4 = http://bar\n```\n:::\n\nConfig files are accessed through the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a> class whic [...]
+{"description": "The juneau-assertions module in Juneau is a powerful API for performing fluent style assertions.\n\nFluent assertions have two types of methods:\n\n- `asX` methods which perform transformations.\n- `isX` methods which perform assertions.\n\nMultiple transformations and assertions can be performed per statement.\n\n:::tip Examples\n```java\nimport static org.apache.juneau.assertions.Assertions.*;\nimport static org.apache.juneau.assertions.AssertionPredicates.*;\n\n// Che [...]
+{"description": "The Juneau framework uses the design pattern of builders, context, and session objects:\n\n- Context Builders - Modifiable objects that allow you to define configuration settings for contexts.\n- Contexts - Unmodifiable thread-safe objects meant to be cacheable and reusable.\n- Sessions - Modifiable objects usually meant for one-time use.\n\nThis is a general design pattern used throughout the framework including the REST client and server APIs.\n\nThe following shows th [...]
+{"description": "# Framework Comparisons\n\nThis page provides detailed comparisons between Juneau and popular alternatives to help you choose the right tool for your needs.\n\n## Juneau vs Jackson\n\n| Feature | Juneau | Jackson | Winner |\n|---------|--------|---------|--------|\n| **Multi-format support** | JSON, XML, HTML, URL-Encoding, UON, OpenAPI, PlainText, CSV, SOAP, MessagePack, RDF | Primarily JSON (with modules for XML, YAML, etc.) | **Juneau** - Built-in multi-format support [...]
+{"description": "# Why Choose Juneau?\n\nApache Juneau\u2122 offers a unique combination of simplicity, power, and zero-dependency design that makes it an excellent choice for modern Java development. Here's why developers choose Juneau over alternatives.\n\n## The Juneau Advantage\n\n### **Zero Dependencies, Maximum Power**\n\nUnlike other frameworks that require multiple dependencies and complex configurations, Juneau provides comprehensive functionality with minimal external requireme [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-marshall-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.marshall_0.0.0.jar\n```\n\n#### Contents/Features\n\n- Foundation for all serializers and parsers.\n- Implementations for all serializers and parsers except RDF lang [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/marshaller/Marshaller.html\" target=\"_blank\">Marshallers</a> are simple pairings of a <a href=\"/site/apidocs/org/apache/juneau/serializer/Serializer.html\" target=\"_blank\">Serializer</a> \nand <a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html\" target=\"_blank\">Parser</a> with convenience methods for serializing and parsing\nPOJOs.\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/ [...]
+{"description": "One of the goals of Juneau was to make serialization as simple as possible.\nIn a single line of code, you should be able to serialize and parse most POJOs.\n\nDespite this simplicity, Juneau provides lots of extensibility and configuration properties for tailoring how POJOs are\nserialized and parsed.\n\nThe built-in serializers in Juneau are fast, efficient, and highly configurable.\nThey work by serializing POJOs directly to streams instead of using intermediate Docum [...]
+{"description": "At the heart of the marshalling APIs is the <a href=\"/site/apidocs/org/apache/juneau/MarshallingContext.html\" target=\"_blank\">Marshalling Context</a> API that\nprovides a common framework for marshalling beans and POJOs across all serializers and parsers.\n\nAll serializers and parsers (and their builders) extend from the marshalling context API classes.\n\nOne important feature of the marshalling context API is the ability to wrap Java beans inside maps to allow pro [...]
+{"description": "Out-of-the-box, Juneau supports marshalling of Java beans with standard public getters and setters, public fields, and\nfluent setters (e.g.\n`withX` naming convention).\nThere are also many settings and annotations that can be used to customize how bean properties are detected.\n\nThe following is an example of some of the ways to define bean properties:\n\n```java\npublic class MyBean {\n\n // Public field property.\n public String property1;\n\n // Standard p [...]
+{"description": "Juneau supports serialization and parsing of Java records out of the box. Records are treated as beans whose\nproperties are derived from the record's components. The canonical constructor is automatically detected for\nparsing, so no `@MarshalledCtor` annotation is needed.\n\n## Basic Usage\n\nRecords work seamlessly with all Juneau serializers and parsers:\n\n```java\npublic record Person(String name, int age) {}\n```\n\n```java\n// Serialization\nPerson person = new [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/Marshalled.html\" target=\"_blank\">@Marshalled</a> annotation is used to tailor how beans and types are interpreted\nby the framework.\n\nBean property inclusion and ordering on a bean class can be done using the <a href=\"/site/apidocs/org/apache/juneau/annotation/Marshalled.html#properties()\" target=\"_blank\">@Marshalled(properties|p)</a> annotation.\n\n```java\n// Address class with only street/city/state pro [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/MarshalledProp.html\" target=\"_blank\">@MarshalledProp</a> annotation is used to tailor how individual bean\nproperties are interpreted by the framework.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/annotation/MarshalledProp.html#name()\" target=\"_blank\">@MarshalledProp(name)</a> annotation is used to override the name\nof the bean property.\n\n```java\npublic class MyBean {\n @MarshalledProp(name=\"Bar\" [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/MarshalledCtor.html\" target=\"_blank\">@MarshalledCtor</a> annotation is used to map constructor arguments to\nproperty names on bean with read-only properties.\n\nSince method parameter names are lost during compilation, this annotation essentially redefines them so that they are\navailable at runtime.\n\nThe definition of a read-only bean is a bean with properties with only getters, like shown below:\n\n```java\ [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/MarshalledIgnore.html\" target=\"_blank\">@MarshalledIgnore</a> annotation is used to ignore fields and\nmethods from being interpreted as bean components, and to suppress serialization of a class entirely.\n\nWhen applied to **fields and getters/setters**, they will be ignored as bean properties.\n\n```java\npublic class MyBean {\n\n // Not a bean property!\n @MarshalledIgnore\n public String foo;\n\n [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/NameProperty.html\" target=\"_blank\">@NameProperty</a> annotation is used to identify a setter method or field for setting the name of a POJO as it's known by its parent object.\n\nThis annotation is used by parsers to automatically set the name/key of an object when parsing structured data (e.g., JSON maps, XML elements). A common use case is when parsing a map where the map key should be stored as a property on [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/ParentProperty.html\" target=\"_blank\">@ParentProperty</a> annotation is used to identify a setter method or field for adding a parent reference to a child object.\n\nThis annotation is used by parsers to automatically establish parent-child relationships when parsing nested objects. When a child object is created within a parent object (e.g., in a list or as a property), the parser automatically sets the parent r [...]
+{"description": "Juneau parsers can use builders to instantiate POJOs.\nThis is useful in cases where you want to create beans with read-only properties.\n\nNote that while it's possible to do this using the <a href=\"/site/apidocs/org/apache/juneau/annotation/MarshalledCtor.html\" target=\"_blank\">@MarshalledCtor</a>\nannotation, using builders can often be cleaner.\n\nA typical builder usage is shown below:\n\n```java\nMyBean bean = MyBean.create().foo(\"foo\").bar(123).build();\n```\ [...]
+{"description": "Juneau serializers treat instances of `Readers` and `InputStreams` special by simply serializing their contents directly\nto the output stream or writer.\nThis allows you to embed fully customized serializer output.\n\n```java\npublic class MyBean {\n // A bean property that produces raw JSON.\n public Reader f1 = new StringReader(\"{'foo':'bar'}\");\n}\n\n// Produces \"{f1:{'foo':'bar'}}\"\nString json = Json5.of(new MyBean());\n```\n\nNote that if you're serializ [...]
+{"description": "There is a separate set of serializers and parsers for marshalling HTTP parts (query, form-data, headers, path\nvariables, and plain-text request bodies).\nThe distinction is that these are designed to marshall directly to-and-from strings based on OpenAPI schema\ninformation.\n\n```java\n// Schema information about our part.\nHttpPartSchema schema = HttpPartSchema\n .tArrayPipes()\n .items(\n HttpPartSchema\n .tArrayCsv()\n .items(\n [...]
+{"description": "Serializers and parsers have a wide variety of configurable settings.\nTheir builders all extend from the <a href=\"/site/apidocs/org/apache/juneau/MarshallingContext.Builder.html\" target=\"_blank\">MarshallingContext.Builder</a> class\nthat allows you to easily construct new instances from scratch or build upon existing instances.\n\nFor example, the following code shows how to configure a JSON serializer:\n\n```java\nWriterSerializer serializer = JsonSerializer\n . [...]
+{"description": "All configurable properties described in the previous section have annotation equivalents that can be applied on classes\nor methods.\n\nIn the section on the REST server API, we describe how to configure serializers and parsers using `@XConfig` annotations\nlike those shown below:\n\n```java\n@Rest(\n path=\"/addressBook\",\n title=\"Address Book REST API\"\n ...\n)\n@SerializerConfig(quoteChar=\"'\")\n@RdfConfig(rdfxml_tab=\"5\", addRootProperty=\"true\")\n@Ma [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/collections/JsonMap.html\" target=\"_blank\">JsonMap</a> and <a href=\"/site/apidocs/org/apache/juneau/collections/JsonList.html\" target=\"_blank\">JsonList</a> classes are generic Java representations of JSON objects and arrays.\nThese classes can be used to create \"unstructured\" models for serialization (as opposed to \"structured\" models\nconsisting of beans).\n\nIf you want to quickly generate JSON/XML/HTML from gener [...]
+{"description": "The Juneau parsers have the ability to parse into complex data types that consist of multidimensional arrays and nested\n`Maps` and `Collections` using the methods below:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html\" target=\"_blank\">Parser</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html#<init>(org.apache.juneau.parser.Parser.Builder)\" target=\"_blank\">parse(Ob [...]
+{"description": "On top of the serializers and parsers are the <a href=\"/site/apidocs/org/apache/juneau/serializer/SerializerSet.html\" target=\"_blank\">SerializerSet</a> and <a href=\"/site/apidocs/org/apache/juneau/parser/ParserSet.html\" target=\"_blank\">ParserSet</a> classes.\nThese classes allow serializers and parsers to be grouped and retrieved by W3C-compliant HTTP `Accept` and\n`Content-Type` values...\n\n```java\n// Construct a new serializer group with configuration paramet [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/swap/ObjectSwap.html\" target=\"_blank\">Swaps</a> are a critical component of Juneau.\nThey allow the serializers and parsers to handle Java objects that wouldn't normally be serializable.\n\nSwaps are, simply put, 'object swappers' that swap in serializable objects for non-serializable ones during serialization, and vis-versa during parsing.\n\nSome examples of non-serializable objects are `File`, `Reader`, `Iterable`, etc...\n [...]
+{"description": "By default, all serializers and parsers have built in `ObjectSwaps` defined for the following common data types:\n\n:::note\nAs of 9.5.0, `Iterator`, `Iterable`, `Stream`, and `Enumeration` types are serialized natively without swaps.\nThe `IteratorSwap` and `EnumerationSwap` classes have been removed.\nSee [Release 9.5.0](/release-notes/9.5.0) for details.\n:::\n\n:::note\nAs of 9.5.0, date/time types (`Calendar`, `Date`, `Temporal` subtypes, `XMLGregorianCalendar`) and [...]
+{"description": "Various methods can be defined on a class directly to affect how it gets serialized.\nThis can often be simpler than using `ObjectSwaps`.\n\nObjects serialized as `Strings` can be parsed back into their original objects by implementing one of the following methods on the class:\n\n- `public static T fromString(String)` method.\n \n Any of the following method names also work:\n - `valueOf(String)`\n - `parse(String)`\n - `parseString(String)`\n - `forName(String)`\ [...]
+{"description": "Swaps can also be defined per-media-type.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/swap/ObjectSwap.html#forMediaTypes()\" target=\"_blank\">ObjectSwap.forMediaTypes()</a> method can be\noverridden to provide a set of media types that the swap is invoked on.\n\nIt's also possible to define multiple swaps against the same object as long as they're differentiated by media type.\n\nWhen multiple swaps are defined, the best-match media type is used.\n\nIn the followin [...]
+{"description": "In the previous sections, we defined two-way swaps, meaning swaps where the original objects could be reconstructing\nduring parsing.\nHowever, there are certain kinds of objects that we may want to support for serializing but that are not possible to\nreconstruct during parsing.\nFor these, we can use one-way object swaps.\n\nA one-way swap is simply an object transform that only implements the `swap()` method.\nThe `unswap()` method is simply left unimplemented.\n\n::: [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/annotation/Swap.html\" target=\"_blank\">@Swap</a> can be used to associate a swap class using an annotation.\nThis is often cleaner than using the builder `swaps()` method since you can keep your swap class near your POJO class.\n\n```java\n@Swap(MyObjectSwap.class)\npublic class MyPojo {\n ...\n}\n\n// Sample swap for converting MyPojo classes to a simple string.\npublic class MyObjectSwap extends ObjectSwap {\n @Override [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/Swap.html#template()\" target=\"_blank\">@Swap(template)</a> annotation allows you to associate\narbitrary contextual strings with swaps.\nThe primary purpose is for providing template names, such as for Apache FreeMarker, therefore the name 'template'.\nHowever, the usage of the string is open-ended.\n\nFor example, you could pair a template string like so:\n\n```java\n@Swap(impl=FreeMarkerSwap.class, template=\"M [...]
+{"description": "Surrogate classes are very similar in concept to `ObjectSwaps` except they're simpler to define.\n\nFor example, let's say we want to be able to serialize the following class but it's not serializable for some reason\n(for example, there are no properties exposed):\n\n```java\n// Not serializable because it's not a bean because it has no public properties.\npublic class MyNonSerializableClass {\n protected String foo;\n}\n```\n\nThis could be solved with the following [...]
+{"description": "In the section [Swaps](/docs/topics/SwapBasics), you were introduced to annotations that can be applied to bean classes, methods,\nfields, and constructors such as <a href=\"/site/apidocs/org/apache/juneau/commons/bean/BeanType.html\" target=\"_blank\">@BeanType</a>:\n\n```java\n// Address class with only street/city/state properties (in that order).\n// All other properties are ignored.\n@BeanType(properties=\"street,city,state\")\npublic class Address { ... }\n```\n\nA [...]
+{"description": "While parsing into beans, Juneau attempts to determine the class types of bean properties through reflection on the bean\nproperty getter or setter.\nOften this is insufficient if the property type is an interface or abstract class that cannot be instantiated.\nThis is where bean names and dictionaries come into play.\n\nBean names and dictionaries are used for identifying class types when they cannot be inferred through reflection.\nBean classes are given names through [...]
+{"description": "In addition to the bean type name support described above, simplified support is provided for bean subtypes.\n\nBean subtypes are similar in concept to bean type names, except for the following differences:\n\n- You specify the list of possible subclasses through an annotation on a parent bean class.\n- You do not need to register the subtype classes on the bean dictionary of the parser.\n\nIn the following example, the abstract class has two subclasses:\n\n```java\n// A [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/MarshallingContext.Builder.html#disableInterfaceProxies()\" target=\"_blank\">MarshallingContext.Builder.disableInterfaceProxies()</a> setting (enabled by default) allows the Juneau parsers to parse content into virtual beans (bean interfaces without implementation classes).\n\nFor example, the following code creates an instance of the specified unimplemented interface:\n\n```java\n// Our unimplemented interface\npublic inter [...]
+{"description": "The Juneau Serializer API is designed to be used against POJO tree structures.\nIt expects that there not be loops in the POJO model (e.g.\nchildren with references to parents, etc...).\nIf you try to serialize models with loops, you will usually cause a `StackOverflowError` to be thrown (if <a href=\"/site/apidocs/org/apache/juneau/MarshallingTraverseContext.Builder.html#maxDepth(int)\" target=\"_blank\">MarshallingTraverseContext.Builder.maxDepth(int)</a> is not reache [...]
+{"description": "The Juneau parsers are not limited to parsing back into the original bean classes.\nIf the bean classes are not available on the parsing side, the parser can also be used to parse into a generic model\nconsisting of `Maps`, `Collections`, and primitive objects.\n\nYou can parse into any `Map` type (e.g. `HashMap`, `TreeMap`) but using <a href=\"/site/apidocs/org/apache/juneau/collections/JsonMap.html\" target=\"_blank\">JsonMap</a> is recommended since it has many conven [...]
+{"description": "The following parsers can be configured to read continuous streams of objects from the same input stream:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/json/JsonParser.html\" target=\"_blank\">JsonParser</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/uon/UonParser.html\" target=\"_blank\">UonParser</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/msgpack/MsgPackParser.html\" target=\"_blank\">M [...]
+{"description": "Juneau supports streaming serialization and parsing of arbitrarily large datasets without loading\nall elements into memory. The feature is built directly into the serializer and parser APIs, so\nevery format (JSON, XML, YAML, CSV, MessagePack, \u2026) works transparently.\n\n## Key Interfaces\n\n| Interface | Extends | Direction | Purpose |\n|---|---|---|---|\n| `BeanSupplier<T>` | `Iterable<T>` | Serialization | Provides beans to serializers lazily from a cursor or que [...]
+{"description": "Juneau serializers have sophisticated support for transforming relative URIs to absolute form.\n\nThe following example shows a bean containing URIs of various forms and how they end up serialized.\n\n```java\n// Our bean with properties containing various kinds of URIs.\npublic class TestURIs {\n public URI\n a = URI.create(\"http://www.apache.org/a\"),\n b = URI.create(\"/b\"),\n c = URI.create(\"/c/x/y\"),\n d = URI.create(\"d\"),\n [...]
+{"description": "Juneau was developed independently from Jackson but shares many of the same features and capabilities.\nWhereas Jackson was created to work primarily with JSON, Juneau was created to work for multiple languages.\nTherefore, the terminology and annotations in Juneau are similar but language-agnostic.\n\nThe following charts describe equivalent features between the two libraries:\n\n## Annotations\n\n| Jackson | Juneau |\n|---------|--------|\n| `@JsonGetter`<br/>`@JsonSet [...]
+{"description": "In general, Juneau allows for marshalling for a wide variety of POJO types including:\n\nThe following chart shows POJOs categorized into groups and whether they can be serialized or parsed:\n\n#### General POJO serialization/parsing support\n\n<table className=\"styled w800\" style={{borderCollapse: 'collapse'}}>\n <tr>\n <th>Group</th>\n <th>Description</th>\n <th>Examples</th>\n <th>Can<br />serialize?</th>\n <th>Can<br />parse?</th>\n </tr>\n <tr cl [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/commons/svl/package-summary.html\" target=\"_blank\">org.apache.juneau.commons.svl</a> package defines an API for a language called\n\"Simple Variable Language\".\n\nIn a nutshell, Simple Variable Language (or SVL) is text that contains variables of the form `$varName{varKey}`.\nIt is used extensively in the Config, REST and Microservice APIs.\n\nMost variables can be recursively nested within the varKey (e.g. `$FOO{$BAR{xxx} [...]
+{"description": "Variables are defined through the <a href=\"/site/apidocs/org/apache/juneau/commons/svl/Var.html\" target=\"_blank\">Var</a> API.\nThe API comes with several predefined variables and is easily extensible.\n\nThe following is an example of a variable that performs URL-Encoding on strings.\n\n```java\n// First create our var.\npublic class UrlEncodeVar extends SimpleVar {\n\n // Must have a no-arg constructor!\n public UrlEncodeVar() {\n super(\"UE\");\n }\ [...]
+{"description": "The main class for performing variable resolution is <a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html\" target=\"_blank\">VarResolver</a>.\n\nTwo methods are provided for resolving variables:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html\" target=\"_blank\">VarResolver</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html#resolve( [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html#DEFAULT\" target=\"_blank\">VarResolver.DEFAULT</a> is a reusable variable resolver with\ndefault support for the following variables:\n\n- `$S{key[,default]}` - <a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/SystemPropertiesVar.html\" target=\"_blank\">SystemPropertiesVar</a>\n- `$E{key[,default]}` - <a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/EnvVariablesVar.html\" target= [...]
+{"description": "- The escape character `\\` can be used when necessary to escape the following characters: `$ , { }` \n\n:::warning\nIt is possible to cause <a href=\"https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StackOverflowError.html\" target=\"_blank\">StackOverflowErrors</a> if your nested variables\nresult in a recursive loop (e.g. the environment variable `'MYPROPERTY'` has the value `'$E{MYPROPERTY}'`).\nSo don't do that!\n:::\n\n- As a general rule, thi [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/encoders/package-summary.html\" target=\"_blank\">org.apache.juneau.encoders</a> package defines an API for handling encoding-based matching\nof `Accept-Encoding`/`Content-Encoding` HTTP headers.\n\nIt consists of the following classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/encoders/EncoderSet.html\" target=\"_blank\">EncoderSet</a></java-class></node-0>\n<node-0><java-abstract-class><a href [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/objecttools/package-summary.html\" target=\"_blank\">org.apache.juneau.objecttools</a> package defines convenience utility\nclasses for accessing and manipulating POJOs.\n\nIt consists of the following classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/objecttools/ObjectRest.html\" target=\"_blank\">ObjectRest</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/june [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from JSON using ultra-efficient serializers and parsers.\nThe <a href=\"/site/apidocs/org/apache/juneau/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> converts POJOs directly to strict RFC 8259 JSON (double quotes) without intermediate DOM objects.\nThe <a href=\"/site/apidocs/org/apache/juneau/json/JsonParser.html\" target=\"_blank\">JsonParser</a> creates POJOs from strict JSON only. For JSON5 syntax (s [...]
+{"description": "The JSON data type produced depends on the Java object type being serialized.\n\n- Primitives and primitive objects are converted to JSON primitives.\n- Beans and `Maps` are converted to JSON objects.\n- `Collections` and arrays are converted to JSON arrays.\n- Anything else is converted to JSON strings.\n\n##### Data type conversions:\n\n| POJO type | JSON type | Example | Serialized form |\n|-----------|-----------|---------|----------------|\n| String | String | `seri [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> class is used to serialize POJOs into\nJSON.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingC [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/json/Json5Serializer.html\" target=\"_blank\">Json5Serializer</a> class can be used to serialized POJOs\ninto JSON 5 notation.\n\nJSON 5 is similar to JSON except for the following:\n\n- JSON attributes are only quoted when necessary.\n- Uses single-quotes for quoting.\n\n:::tip Examples\n```java\n// Some free-form JSON.\nJsonMap map = JsonMap.of(\n \"foo\", \"x1\",\n \"_bar\", \"x2\",\n \" baz \", \"x3\",\n \"123 [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/json/JsonParser.html\" target=\"_blank\">JsonParser</a> class is used to parse JSON into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.Builde [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/json/annotation/Json.html\" target=\"_blank\">@Json</a> annotation is used to override the behavior of <a href=\"/site/apidocs/org/apache/juneau/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> on individual bean classes or properties.\n\nThe annotation can be applied to beans as well as other objects serialized to other types (e.g. strings).\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apach [...]
+{"description": "Juneau provides the <a href=\"/site/apidocs/org/apache/juneau/json/JsonSchemaSerializer.html\" target=\"_blank\">JsonSchemaSerializer</a> class for\ngenerating JSON-Schema documents that describe the output generated by the <a href=\"/site/apidocs/org/apache/juneau/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> class.\nThis class shares the same properties as `JsonSerializer`.\n\nFor convenience the <a href=\"/site/apidocs/org/apache/juneau/json/JsonSeri [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from XML using ultra-efficient serializers and parsers.\n\nThe XML serializer converts POJOs directly to XML without the need for intermediate DOM objects.\nLikewise, the XML parser uses a STaX parser and creates POJOs directly without intermediate DOM objects.\n\nUnlike frameworks such as JAXB, Juneau does not require POJO classes to be annotated to produce and consume XML.\nHowever, several XML annotations are provided [...]
+{"description": "The following examples show how different data types are represented in XML.\nThey mirror how the data structures are represented in JSON.\n\n##### Simple types\n\nThe representation of loose (not a direct bean property value) simple types are shown below:\n\n<table class=\"code-table\">\n<tr>\n<th>Data type</th>\n<th>JSON example</th>\n<th>XML</th>\n</tr>\n<tr>\n<td>string</td>\n<td>\n```json\n'foo'\n```\n</td>\n<td>\n```xml\n<string>foo</string>\n```\n</td>\n</tr>\n<tr [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/xml/XmlSerializer.html\" target=\"_blank\">XmlSerializer</a> class is used to serialize POJOs into XML.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/xml/XmlDocSerializer.html\" target=\"_blank\">XmlDocSerializer</a> class is the same but serializes a\n`<?xml?>` header at the top of the file.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/ap [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/xml/XmlParser.html\" target=\"_blank\">XmlParser</a> class is used to parse XML into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.Builder.ht [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/Marshalled.html#typeName()\" target=\"_blank\">@Marshalled(typeName)</a> annotation can be used to override the Juneau default name on bean elements.\n\nTypes names serve two distinct purposes:\n\n1. To override the element name.\n2. To serve as a class identifier so that the bean class can be inferred during parsing if it cannot automatically be inferred through reflection.\n\n:::tip Example\n<table class=\"code-t [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/xml/annotation/Xml.html#childName()\" target=\"_blank\">@Xml(childName)</a> annotation can be used to\nspecify the name of XML child elements for bean properties of type collection or array.\n\n:::tip Example\n\n<table class=\"code-table\">\n<tr>\n<th>Data type</th>\n<th>JSON example</th>\n<th>Without annotation</th>\n<th>With annotation</th>\n</tr>\n<tr>\n<td>\n\n```java\nclass MyBean {\n @Xml(childName=\"X\")\n public Str [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/xml/annotation/Xml.html#format()\" target=\"_blank\">@Xml(format)</a> annotation can be used to tweak the\nXML format of a POJO.\nThe value is set to an enum value of type <a href=\"/site/apidocs/org/apache/juneau/xml/annotation/XmlFormat.html\" target=\"_blank\">XmlFormat</a>.\nThis annotation can be applied to both classes and bean properties.\nThe <a href=\"/site/apidocs/org/apache/juneau/xml/annotation/XmlFormat.html#ATTR [...]
+{"description": "Let's go back to the example of our original `Person` bean class but add some namespace annotations:\n\n##### Sample Beans\n\n```java\n@Xml(prefix=\"per\")\n@Marshalled(typeName=\"person\")\npublic class Person {\n\n // Bean properties\n public String name;\n @Swap(TemporalCalendarSwap.IsoInstant.class) public Calendar birthDate;\n public List addresses;\n\n // Getters/setters omitted\n}\n\n@Xml(prefix=\"addr\")\n@Marshalled(typeName=\"address\")\npublic c [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from HTML.\nBuilt on top of the existing XML parser, it also uses a STaX parser and creates POJOs directly without intermediate DOM\nobjects.\n\nThe primary use case for HTML serialization is rendering POJOs in easy-to-read format in REST interfaces.", "id": "topic:7d11f8d84944", "module": "27", "related_ids": [], "source_path": "pages/topics/02.27.01.HtmlBasics.md", "source_type": "topic", "summary": "Juneau supports con [...]
+{"description": "The following examples show how different data types are represented in HTML.\nThey mirror how the data structures are represented in JSON.\n\n##### Simple types\n\nThe representation for simple types mirror those produced by the XML serializer.\nTags are added to help differentiate data types when they cannot be inferred through reflection.\nThese tags are ignored by browsers and treated as plain text.\n\n<table class=\"code-table\">\n<tr>\n<th>Data type</th>\n<th>JSON [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/HtmlSerializer.html\" target=\"_blank\">HtmlSerializer</a> class is used to serialize POJOs into\nHTML.\nThe <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a> class is the same but wraps the\nserialized POJO inside a document template consisting of header, nav, aside, and footer sections.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\ [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/HtmlParser.html\" target=\"_blank\">HtmlParser</a> class is used to parse HTML into POJOs.\nThey can also parse the contents produced by <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a>.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_b [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html\" target=\"_blank\">@Html</a> annotation can be used to customize how POJOs are\nserialized to HTML on a per-class/field/method basis.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html\" target=\"_blank\">Html</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html#anchor [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/annotation/Html.html#render()\" target=\"_blank\">@Html(render)</a> annotation allows for custom\nrendering of bean property values when serialized as HTML.\nUsing this class, you can alter the CSS style and HTML content of the bean property.\n\nThe following example shows two render classes that customize the appearance of the `pctFull` and `status` columns in\nthe code below:\n\n```java\nimport static org.apache.juneau [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a> is an extension of <a href=\"/site/apidocs/org/apache/juneau/html/HtmlSerializer.html\" target=\"_blank\">HtmlSerializer</a> that wraps serialized POJOs in a complete HTML document.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blan [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/BasicHtmlDocTemplate.html\" target=\"_blank\">BasicHtmlDocTemplate</a> class defines a default\ntemplate for HTML documents created by <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a>.\n\nThe HTML document created by this template consists of the following structure:\n\n```xml\n<html>\n <head>\n <style type='text/css'>\n CSS styles and li [...]
+{"description": "Custom page templates can be created by implementing the <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocTemplate.html\" target=\"_blank\">HtmlDocTemplate</a> interface and associating it with your <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a> using the <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.Builder.html#template(java.lang.Class)\" target=\"_blank\">HtmlDocSerializer.Builder [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/HtmlSchemaSerializer.html\" target=\"_blank\">HtmlSchemaSerializer</a> class is the HTML-equivalent\nto the <a href=\"/site/apidocs/org/apache/juneau/json/JsonSchemaSerializer.html\" target=\"_blank\">JsonSchemaSerializer</a> class.\nIt's used to generate HTML versions of JSON-Schema documents that describe the output generated by the <a href=\"/site/apidocs/org/apache/juneau/json/JsonSerializer.html\" target=\"_blank\"> [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from UON strings using ultra-efficient serializers and parsers.\n\nThe serializer converts POJOs directly to UON strings without the need for intermediate DOM objects using a\nhighly-efficient state machine.\nLikewise, the parser creates POJOs directly from UON strings without the need for intermediate DOM objects.\n\nJuneau uses UON (URL-Encoded Object Notation) for representing POJOs.\n\nThe UON specification can be fou [...]
+{"description": "#### General methodology:\n\n<table class=\"code-table\">\n<tr>\n<th>Java type</th>\n<th>JSON equivalent</th>\n<th>UON</th>\n</tr>\n<tr>\n<td>`Maps`/beans</td>\n<td>OBJECT</td>\n<td>\n\n```\na1=(b1=x1,b2=x2)\na1=(b1=(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>`Collections`/arrays</td>\n<td>ARRAY</td>\n<td>\n\n```\na1=@(x1,x2)\na1=@(@(x1,x2),@(x3,x4))\na1=@((b1=x1,b2=x2),(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>Booleans</td>\n<td>BOOLEAN</td>\n<td>\n\n```\na1=tru [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/uon/UonSerializer.html\" target=\"_blank\">UonSerializer</a> class is used to serialize POJOs into UON.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContex [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/uon/UonParser.html\" target=\"_blank\">UonParser</a> class is used to parse UON into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.Builder.ht [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from URL-encoded strings using ultra-efficient serializers and\nparsers.\n\nThe serializer converts POJOs directly to URL-encoded strings without the need for intermediate DOM objects using a\nhighly-efficient state machine.\nLikewise, the parser creates POJOs directly from URL-encoded strings without the need for intermediate DOM objects.\n\nJuneau uses UON (URL-Encoded Object Notation) for representing POJOs as URL-Enco [...]
+{"description": "#### General methodology:\n\n<table class=\"code-table\">\n<tr>\n<th>Java type</th>\n<th>JSON equivalent</th>\n<th>UON</th>\n</tr>\n<tr>\n<td>`Maps`/beans</td>\n<td>OBJECT</td>\n<td>\n\n```\na1=(b1=x1,b2=x2)\na1=(b1=(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>`Collections`/arrays</td>\n<td>ARRAY</td>\n<td>\n\n```\na1=@(x1,x2)\na1=@(@(x1,x2),@(x3,x4))\na1=@((b1=x1,b2=x2),(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>Booleans</td>\n<td>BOOLEAN</td>\n<td>\n\n```\na1=tru [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingSerializer.html\" target=\"_blank\">UrlEncodingSerializer</a> class is used to\nserialize POJOs into URL-Encoding.\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingParser.html\" target=\"_blank\">UrlEncodingParser</a> class is used to parse\nURL-Encoding into POJOs.\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/M [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/urlencoding/annotation/UrlEncoding.html\" target=\"_blank\">@UrlEncoding</a> annotation is used to\noverride the behavior of <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingSerializer.html\" target=\"_blank\">UrlEncodingSerializer</a>\non individual bean classes or properties.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/urlencoding/annotation/UrlEncoding.html\" target=\"_blan [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from MessagePack using ultra-efficient serializers and parsers.\nMessagePack is a compact binary form of JSON.\n\nThe serialization support for MessagePack mirrors that of JSON.", "id": "topic:29d5171dfaba", "module": "31", "related_ids": [], "source_path": "pages/topics/02.31.01.MessagePackBasics.md", "source_type": "topic", "summary": "Juneau supports converting arbitrary POJOs to and from MessagePack using ultra-effici [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/msgpack/MsgPackSerializer.html\" target=\"_blank\">MsgPackSerializer</a> class is used to serialize POJOs\ninto MessagePack.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/jun [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/msgpack/MsgPackParser.html\" target=\"_blank\">MsgPackParser</a> class is used to parse MessagePack into\nPOJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingC [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from strings using OpenAPI-based schema rules.\n\nThe relevant classes for using OpenAPI-based serialization are:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/oapi/OpenApiSerializer.html\" target=\"_blank\">OpenApiSerializer</a></java-class> - Converts POJOs to strings.</node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/oapi/OpenApiParser.html\" target=\"_blank\">OpenApiPar [...]
+{"description": "Unlike the other Juneau serializers and parsers that convert input and output directly to-and-from POJOs, the OpenAPI\nserializers and parsers use intermediate objects based on the `type` and `format` of the schema.\nThe following table shows the \"natural\" intermediate type of the object based on the `type/format`:\n\n<table class=\"code-table\">\n<tr>\n<th>Type</th>\n<th>Format</th>\n<th>Intermediate Java Type</th>\n</tr>\n<tr>\n<td rowSpan=\"4\">`string` or empty</td [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/oapi/OpenApiSerializer.html\" target=\"_blank\">OpenApiSerializer</a> class is used to convert POJOs to\nHTTP parts.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Mars [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/oapi/OpenApiParser.html\" target=\"_blank\">OpenApiParser</a> class is used to convert HTTP parts back\ninto POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Marshalli [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from TOML (Tom's Obvious Minimal Language) using native serializers and parsers implemented without any external dependencies.\nTOML is a configuration file format that maps unambiguously to hash tables, widely used in projects like Cargo (Rust) and Python's `pyproject.toml`.\nThe <a href=\"/site/apidocs/org/apache/juneau/toml/TomlSerializer.html\" target=\"_blank\">TomlSerializer</a> converts POJOs directly to TOML forma [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from the **Protobuf Text Format** using native serializers and parsers implemented without any external dependencies. This is the human-readable text format (not the binary wire format) used for protobuf configuration files, debugging, and interop with tools like `protoc --decode`. The <a href=\"/site/apidocs/org/apache/juneau/proto/ProtoSerializer.html\" target=\"_blank\">ProtoSerializer</a> converts POJOs directly to Pr [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from YAML using native serializers and parsers implemented\nwithout any external dependencies.\nThe YAML serializer converts POJOs directly to YAML block-style output using indentation-based structure.\nThe YAML parser creates POJOs directly from YAML using an indentation-aware state machine.\n\nThe following example shows YAML for a typical bean:\n\n##### Sample Beans\n\n```java\npublic class Person {\n\n // Bean prop [...]
+{"description": "The YAML data type produced depends on the Java object type being serialized.\n\n- Primitives and primitive objects are converted to YAML scalars.\n- Beans and `Maps` are converted to YAML block mappings.\n- `Collections` and arrays are converted to YAML block sequences.\n- Anything else is converted to YAML string scalars (with quoting if necessary).\n\n##### Data type conversions:\n\n| POJO type | YAML type | Example | Serialized form |\n|-----------|-----------|------ [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/yaml/YamlSerializer.html\" target=\"_blank\">YamlSerializer</a> class is used to serialize POJOs into\nYAML.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingC [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/yaml/YamlParser.html\" target=\"_blank\">YamlParser</a> class is used to parse YAML into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.Builde [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/yaml/annotation/YamlConfig.html\" target=\"_blank\">@YamlConfig</a> annotation is used to apply\nYAML serializer and parser configuration annotations to REST resources, methods, and other contexts.\n\n##### REST Integration\n\nYAML support can be added to REST resources using the `BasicYamlConfig` interface or by including the YAML serializer\nand parser in `BasicUniversalConfig`:\n\n```java\n// YAML-only REST resource\n@Rest [...]
+{"description": "- Reuse instances of serializers and parsers whenever possible. \nThey are designed to be thread safe and maintain internal caches of bean metadata to increase performance.\n\n- The <a href=\"/site/apidocs/org/apache/juneau/MarshallingTraverseContext.Builder.html#detectRecursions()\" target=\"_blank\">MarshallingTraverseContext.Builder.detectRecursions()</a> option can cause a performance penalty of around 20%.\nTherefore, it's recommended that this option be used only [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/csv/package-summary.html\" target=\"_blank\">org.apache.juneau.csv</a>\npackage provides a fully-implemented CSV (Comma Separated Values) serializer and parser.\n\n##### Maven Dependency\n\nCSV support is included in `juneau-marshall`:\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n##### Overview\n [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/csv/CsvSerializer.html\" target=\"_blank\">CsvSerializer</a> class is used to serialize POJOs into\nCSV.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingConte [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/csv/CsvParser.html\" target=\"_blank\">CsvParser</a> class is used to parse CSV into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.Builder.ht [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/markdown/package-summary.html\" target=\"_blank\">org.apache.juneau.markdown</a>\npackage provides Markdown serialization and parsing for POJOs. Output is optimized for human readability and LLM/AI consumption.\n\n##### Maven Dependency\n\nMarkdown support is included in `juneau-marshall`:\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall</artifactId>\n <version>${juneau.ver [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from JSONL (JSON Lines, also called NDJSON) using native serializers and parsers. JSONL is a text format where each line is a valid JSON value, separated by newlines. It is the standard format for LLM fine-tuning datasets, streaming AI inference, log aggregation, and bulk data pipelines.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/jsonl/JsonlSerializer.html\" target=\"_blank\">JsonlSerializer</a> converts POJOs direc [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from Hjson (Human JSON) using native serializers and parsers. Hjson is a syntax extension of JSON designed for human-friendly configuration files and hand-edited data. It extends JSON with quoteless strings, multiline strings, comments, optional commas, and unquoted keys.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/hjson/HjsonSerializer.html\" target=\"_blank\">HjsonSerializer</a> converts POJOs directly to Hjson for [...]
+{"description": "Juneau supports converting arbitrary POJOs to canonical JSON per [RFC 8785](https://www.rfc-editor.org/rfc/rfc8785) (JCS - JSON Canonicalization Scheme) using a native serializer. JCS produces a deterministic, byte-for-byte representation suitable for cryptographic operations such as hashing and digital signing.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/json/JcsSerializer.html\" target=\"_blank\">JcsSerializer</a> converts POJOs to canonical JSON. The <a href=\"/s [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from BSON (Binary JSON) using native serializers and parsers. BSON is the binary serialization format used by MongoDB, extending JSON with typed integers (int32/int64), native datetime, decimal128, and binary data. It uses little-endian byte order and length-prefixed documents.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/bson/BsonSerializer.html\" target=\"_blank\">BsonSerializer</a> converts POJOs directly to BSON f [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from CBOR (Concise Binary Object Representation) per RFC 8949 using native serializers and parsers. CBOR is a compact binary format designed for extremely small code size, very small message size, and extensibility. It is widely used in IoT, constrained environments, COSE (CBOR Object Signing and Encryption), and WebAuthn.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/cbor/CborSerializer.html\" target=\"_blank\">CborSe [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from HOCON (Human-Optimized Config Object Notation) using native serializers and parsers. HOCON is a superset of JSON used extensively in the JVM ecosystem (Akka, Play Framework, sbt, Apache Spark, Kafka, Flink) for configuration files. It extends JSON with path expressions, `=` as key-value separator, unquoted strings, object merging, substitutions (`${var}`), triple-quoted multi-line strings, and optional root braces.\n [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshaller/package-summary.html\" target=\"_blank\">org.apache.juneau.marshaller</a> and\n<a href=\"/site/apidocs/org/apache/juneau/jena/package-summary.html\" target=\"_blank\">org.apache.juneau.jena</a> packages provide\nRDF (Resource Description Framework) serializers and parsers for converting POJOs to and from RDF formats.\nThese rely on the Apache Jena library and support both text-based and binary RDF representations.\ [...]
+{"description": "The RDF serializers convert POJOs into RDF representations. The module provides both character-based serializers (text formats) and stream-based serializers (RDF/THRIFT and RDF/PROTO binary formats).\n\n##### Text-Based Serializers\n\n| Class | Format | Output |\n|---|---|---|\n| <a href=\"/site/apidocs/org/apache/juneau/jena/RdfXmlSerializer.html\" target=\"_blank\">RdfXmlSerializer</a> | RDF/XML | String |\n| <a href=\"/site/apidocs/org/apache/juneau/jena/RdfXmlAbbrevS [...]
+{"description": "The RDF parsers convert RDF input (text or binary) into POJOs. The module provides character-based parsers for all text RDF formats and stream-based parsers for RDF/THRIFT and RDF/PROTO binary formats.\n\n##### Text-Based Parsers\n\n| Class | Format | Input |\n|---|---|---|\n| <a href=\"/site/apidocs/org/apache/juneau/jena/RdfXmlParser.html\" target=\"_blank\">RdfXmlParser</a> | RDF/XML | String, Reader |\n| <a href=\"/site/apidocs/org/apache/juneau/jena/RdfJsonParser.ht [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall-rdf</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-marshall-rdf-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.marshaller.rdf_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-marshall-rdf` library provides additional serializers and parsers for RDF.\nThese rely [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-bean</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-bean-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.bean_0.0.0.jar\n```\n\n#### Contents/Features\n- Predefined POJOs for generating commonly-used document types.", "id": "topic:94e763732154", "module": "01", "related_ids": [ [...]
+{"description": "The Juneau HTML5 DTO beans are simply beans with fluent-style setters that allow you to quickly construct HTML fragments as\nJava objects.\nThese object can then be serialized to HTML using one of the existing HTML serializers, or to other languages such as\nJSON using the JSON serializers.\nThe <a href=\"/site/apidocs/org/apache/juneau/bean/html5/HtmlBuilder.html\" target=\"_blank\">HtmlBuilder</a> class is a utility class with predefined\nstatic methods that allow you [...]
+{"description": "The Juneau ATOM feed DTO beans are simply beans with fluent-style setters.\n\nThe following code shows a feed being created programmatically using the <a href=\"/site/apidocs/org/apache/juneau/bean/atom/AtomBuilder.html\" target=\"_blank\">AtomBuilder</a> class.\n\n```java\nimport static org.apache.juneau.bean.atom.AtomBuilder.*;\n\nFeed feed =\n feed(\"tag:juneau.apache.org\", \"Juneau ATOM specification\", \"2016-01-02T03:04:05Z\")\n .setSubtitle(text(\"html\").s [...]
+{"description": "# juneau-bean-jsonschema\n\nThe `juneau-bean-jsonschema` module provides Java beans for working with JSON Schema documents following the **JSON Schema Draft 2020-12** specification.\n\n## Overview\n\nThis module contains predefined POJOs for representing and manipulating JSON Schema documents programmatically. These beans can be serialized to any format supported by Juneau (JSON, XML, HTML, etc.), making it easy to generate and consume JSON Schema documents in your appli [...]
+{"description": "# juneau-bean-openapi-v3\n\nThe `juneau-bean-openapi-v3` module provides Java beans for working with OpenAPI 3.0 documents and user interfaces.\n\n## Overview\n\nThis module contains predefined POJOs for:\n\n- OpenAPI 3.0 document structure\n- API documentation generation\n- OpenAPI UI rendering\n- Schema validation\n\n## OpenAPI Documents\n\nThe Juneau OpenAPI DTO beans are simply beans with fluent-style setters that allow you to quickly construct OpenAPI documents as J [...]
+{"description": "# juneau-bean-common\n\nThe `juneau-bean-common` module provides common utilities and base classes for the other `juneau-bean-X` modules.\n\n## Overview\n\nThis module contains shared functionality used across all bean modules, including:\n\n- Common base classes\n- Shared utilities\n- Base interfaces\n- Common annotations\n\n## Usage\n\nThe `juneau-bean-common` module is automatically included when you use any of the other `juneau-bean-X` modules, so you typically don't [...]
+{"description": "The `juneau-bean-swagger-v2` module provides Java beans for working with Swagger 2.0 documents and user interfaces.\n\n*WORK-IN-PROGRESS*", "id": "topic:8f51becbe70d", "module": "07", "related_ids": [], "source_path": "pages/topics/04.07.JuneauBeanSwagger2.md", "source_type": "topic", "summary": "The `juneau-bean-swagger-v2` module provides Java beans for working with Swagger 2.0 documents and user interfaces.", "tags": ["topic", "07"], "title": "juneau-bean-swagger-v2", [...]
+{"description": "# juneau-bean-mcp\n\nThe `juneau-bean-mcp` module provides Java beans modelling the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) wire format.\n\n## Overview\n\nMCP is a JSON-RPC 2.0 protocol used by AI assistants and agents to interact with external tools, prompts, and resources. This module provides a complete set of Juneau `@Marshalled`-annotated POJOs covering the MCP HTTP wire surface, so you can build MCP servers and clients using any Juneau seri [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-config</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-config-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.config_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-config` library contains a powerful API for creating and using INI-style config files.\n\n**Key Capabiliti [...]
+{"description": "The `juneau-config` library contains a powerful API for creating and using INI-style config files.\n\n:::tip Example configuration file\n```ini\n# A set of entries\n[Section1]\n\n# An integer\nkey1 = 1\n\n# A boolean\nkey2 = true\n\n# An array\nkey3 = 1,2,3\n\n# A POJO\nkey4 = http://bar\n```\n:::\n\nConfig files are accessed through the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a> class which are \ncreated through the <a hr [...]
+{"description": "Each config file contains zero or more sections containing zero or more entries:\n\n```ini\n[Section1]\nkey1 = 1\n\n[Section2]\nkey1 = 2\n```\n\nUnicode escapes can be used in values.\n\n```ini\nkey1 = \\u0070\\u0075\\u0062\\u006c\\u0069\\u0063\n```\n\nComment lines start with the '#' character and can be placed on lines before sections and entries:\n\n```ini\n# A comment about this section\n[Section1]\n\n# A comment about this entry\nkey1 = 1\n```\n\nComments can also b [...]
+{"description": "Configuration files can contain entries for anything from primitive types up to complex hierarchies of POJOs consisting\nof `Maps`, `Collections`, and/or beans.\n\nEntries are accessed via the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html#get(java.lang.String)\" target=\"_blank\">Config.get(String)</a> method\nwhich returns the following bean:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/config/Entry.html\" target=\"_blank\">En [...]
+{"description": "Entries can also be read as POJOs.\n\nIn theory, any [parsable](/docs/topics/PojoCategories) POJO type can be represented as a config value.\nHowever in practice, we're typically talking about the following:\n\n- Objects convertible from Strings.\n- Beans.\n\nAn example of an object convertible from a String was already shown in an example above.\nIn that case, it was a URL which has a public constructor that takes in a String:\n\n```ini\n# A POJO\nkey4 = http://bar\n``` [...]
+{"description": "The `asStringArray()` method allows you to retrieve comma-delimited lists of values:\n\n```ini\nkey1 = foo, bar, baz\n```\n\n```java\nString[] key1 = config.get(\"key1\").asStringArray().orElse(null);\n```\n\nString arrays can also be represented in JSON when the registered parser is a JSON parser:\n\n```ini\nkey1 = ['foo','bar','baz']\n```\n\n```java\nString[] key1 = config.get(\"key1\").asStringArray().orElse(null);\n```\n\nPrimitive arrays can also be retrieved using [...]
+{"description": "Entries can also be read as Java Collection Framework objects.\n\nThe `Type,Type...` arguments allow you to specify the component types for `Maps` and `Collections`.\n`List<T>` class arguments can be followed by zero or one arguments representing the entry types.\n`Map` class arguments can be followed by zero or two arguments representing the key and value types.\nThe arguments can be chained to produce any data structure consisting of `Maps`, `Collections`, or POJOs.\n\ [...]
+{"description": "Entries can also be accessed as binary data.\n\nBinary data can be represented in 3 formats:\n\n<table class=\"code-table\">\n<tr>\n<th>Format</th>\n<th>Example</th>\n</tr>\n<tr>\n<td>BASE-64 (default)</td>\n<td>`Zm9vYmFycw==`</td>\n</tr>\n<tr>\n<td>Hexadecimal</td>\n<td>`666F6F62617273`</td>\n</tr>\n<tr>\n<td>Spaced hexadecimal</td>\n<td>`66 6F 6F 62 61 72 73`</td>\n</tr>\n</table>\n\nThe binary data format is controlled via the following setting:\n\n<tree>\n<node-0><ja [...]
+{"description": "Config files can contain variables that get resolved dynamically using the previously-described <a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html\" target=\"_blank\">VarResolver</a> API.\n\n:::tip Example\n```ini\n#--------------------------\n# My section\n\n#--------------------------\n[MySection]\n\n# A system property\n\nlocale = $S{java.locale, en_US}\n\n# An environment variable\n\npath = $E{PATH, unknown}\n\n# Another value in this config file\ [...]
+{"description": "The default variable resolver also provides the following logic variables for performing simple logical operations:\n\n<tree>\n<node-0>Logic Variables</node-0>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/IfVar.html\" target=\"_blank\">IfVar</a></java-class> - `$IF{arg,then[,else]}`</node-1>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/SwitchVar.html\" target=\"_blank\">SwitchVar</a></java-class> - `$S [...]
+{"description": "Juneau 9.5 introduces a unified property-source model behind\n<a href=\"/site/apidocs/org/apache/juneau/commons/settings/Settings.html\" target=\"_blank\">Settings</a>.\n\n## Core APIs\n\n- `PropertySource` - Read-only source of `name -> Optional<String>`.\n- `PropertyStore` - Read/write source (extends `PropertySource`).\n- `PropertySourceProvider` - ServiceLoader SPI for auto-registering ambient sources.\n\n## Default Source Stack\n\nBy default, the stack resolves in t [...]
+{"description": "The following method can be used to associates entry modifiers to a config:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.Builder.html\" target=\"_blank\">Config.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.Builder.html#mods(org.apache.juneau.config.mod.Mod...)\" target=\"_blank\">mods(Mod...)</a></java-method></node-1>\n</tree>\n\nMods are used to modify values be [...]
+{"description": "Config sections can be retrieved in-bulk using the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html#getSection(java.lang.String)\" target=\"_blank\">Config.getSection(String)</a> method.\n\nIt returns the following bean:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/config/Section.html\" target=\"_blank\">Section</a></javac-class> <javac-method><a href=\"/site/apidocs/org/apache/juneau/config/Section.html#asBean(java.lang.Class)\" [...]
+{"description": "The following methods allow you to add, remove, and modify entries and sections in a config file:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.html#set(java.lang.String,java.lang.Object)\" target=\"_blank\">set(String,Object)</a></java-method></node-1>\n<node-1><java-method><a href=\"/site/apidoc [...]
+{"description": "In general, external file modifications will be detected immediately in the `Config` object when a watcher thread is\nenabled (explained later).\nOtherwise, they are detected when a commit is performed.\n\nThe `Config` object maintains an in-memory record of all changes that have been applied to it through getters and\nsetters.\nWhen the underlying file changes, the new contents are loaded and the in-memory changes are then applied to the new\nconfiguration.\nThis provid [...]
+{"description": "Setter methods that take in a `Serializer` can be used to provide custom serialization of entries instead of using the\npredefined serializer.\n\n```java\n// Set an XML value instead of JSON.\nconfig.set(\"key1\", myAddress, XmlSerializer.DEFAULT_SQ_READABLE);\n```\n\n```ini\nkey1 =\n 123 Main Street\n Anywhere\n NY\n 12345\n```\nThe value can then be retrieved using the equivalent parser:\n\n```java\nAddress myAddress = config.get(\"key1\").as(XmlParser.DEFA [...]
+{"description": "The following methods can be used to bulk-load configuration values:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.html#setSection(java.lang.String,java.util.List)\" target=\"_blank\">setSection(String,List,Map)</a></java-method></node-1>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/ju [...]
+{"description": "Configuration change events can be listened for using the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.html#addListener(org.apache.juneau.config.event.ConfigEventListener)\" target=\"_blank\">addListener(ConfigEventListener)</a></java-method></node-1>\n<node-1><java-method><a h [...]
+{"description": "The following methods are used for serializing `Config` objects back into INI files:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.html#writeTo(java.io.Writer)\" target=\"_blank\">writeTo(Writer)</a></java-method></node-1>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Conf [...]
+{"description": "Configurations can import values from other configurations using the following syntax:\n\n```ini\n# Import values from configuration 'ParentConfig'\n<ParentConfig>\n\n# Our normal section\n[Section1]\n...\n```\n\nA configuration can contain zero or more imports anywhere in the file.\nHowever, for clarity, imports should normally be placed in the default section of the configuration file.\nThe resolved configuration is retrieved from the configuration store used for the c [...]
+{"description": "Configuration files are stored in entities called Stores.\n\nThe methods that need to be implemented on a store are:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html\" target=\"_blank\">ConfigStore</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html#read(java.lang.String)\" target=\"_blank\">read(String)</a></java-method></node-1>\n<node-1><java-metho [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/config/store/MemoryStore.html\" target=\"_blank\">MemoryStore</a> class is simply an in-memory storage\nlocation for configuration files.\n\nThere is no hard persistence and is used primarily for testing purposes.\nHowever, the implementation provides a good idea on how stores work (especially the write method):\n\n```java\npublic class MemoryStore extends ConfigStore {\n\n // Some methods ommitted.\n\n private final Co [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.html\" target=\"_blank\">FileStore</a> is the typical store used for configuration\nfiles.\n\nIt provides the following configurable settings:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.Builder.html\" target=\"_blank\">FileStore.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.Bui [...]
+{"description": "The `ConfigStore` API has been written to allow easy development of custom configuration storage classes.\nThe example below shows a starting point for an implementation based on polling a relational database.\nThe source can be found here: <a href=\"/site/apidocs/org/apache/juneau/examples/core/config/store/SqlStore.html\" target=\"_blank\">SqlStore</a>.\n\nCompleting it is left as an exercise:\n\n:::tip Example Store Class\n```java\npublic class SqlStore extends Config [...]
+{"description": "The `ConfigStore` class has the following listener methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html\" target=\"_blank\">ConfigStore</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html#register(java.lang.String,org.apache.juneau.config.store.ConfigStoreListener)\" target=\"_blank\">register(String,ConfigStoreListener)</a></java-method></node-1 [...]
+{"description": "The following settings can be used to create read-only `Config` objects:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.Builder.html\" target=\"_blank\">Config.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.Builder.html#readOnly()\" target=\"_blank\">readOnly()</a></java-method></node-1>\n</tree>\n\n:::tip Example\n```java\n// Create a read-only config\nConfig config [...]
+{"description": "In general, it's good practice to close Config if you're only creating them temporarily so that their listeners get\nunregistered from the underlying storage APIs.\n\n:::tip Example\n```java\n// Create a transient config.\nConfig config = Config.create(\"MyConfig.cfg\").build();\n\n// Do stuff with it.\n\n// Then close the config to unregister the listeners.\nconfig.close();\n```\n:::", "id": "topic:2edb2acc6c2e", "module": "13", "related_ids": [], "source_path": "pages/ [...]
+{"description": "Each JVM has a system default config.\nThis is a configuration file that serves as the default configuration for the system.\nIt's accessed using the following static methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.html#getSystemDefault()\" target=\"_blank\">getSystemDefault()</a></java-met [...]
+{"description": "# YAML Config Files\n\n`juneau-config` now supports YAML config files as an alternative to INI/CFG files.\n\n## Enabling YAML\n\nUse a `.yml` or `.yaml` config name to auto-select YAML format:\n\n```java\nConfig c = Config.create()\n\t.name(\"MyConfig.yaml\")\n\t.build();\n```\n\nYou can also force YAML explicitly:\n\n```java\nConfig c = Config.create()\n\t.name(\"MyConfig.cfg\")\n\t.yaml()\n\t.build();\n```\n\n## Section path mapping\n\nINI section paths map directly to [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-commons</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-commons-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.common_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-commons` module provides common utilities and APIs used across the Juneau ecosystem.\n\n**Key Packages:* [...]
+{"description": "The `org.apache.juneau.commons.collections` package provides enhanced collection utilities that extend the standard Java Collections Framework with fluent APIs, specialized collection types, and caching capabilities.\n\n## Key Classes\n\n### Collection Builders\n\n#### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/collections/Lists.html\" target=\"_blank\">Lists</a></java-class>\nFluent builder for constructing `List` instances with various configuration [...]
+{"description": "The `org.apache.juneau.commons.utils` package provides general-purpose utility classes for common operations including string manipulation, collection operations, class utilities, file operations, and more.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/utils/Utils.html\" target=\"_blank\">Utils</a></java-class>\nCommon utility methods for working with collections, strings, objects, and other common operations.\n\n```java\nimport s [...]
+{"description": "The `org.apache.juneau.commons.reflect` package provides comprehensive reflection utilities for working with classes, methods, fields, constructors, and annotations in a more convenient and type-safe way than the standard Java reflection APIs.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/reflect/ReflectionUtils.html\" target=\"_blank\">ReflectionUtils</a></java-class>\nUtility class providing convenient static methods for creatin [...]
+{"description": "The `org.apache.juneau.commons.settings` package provides a thread-safe way to access system properties with support for global and per-thread overrides, making it useful for unit tests and configuration management.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/settings/Settings.html\" target=\"_blank\">Settings</a></java-class>\nEncapsulates Java system properties with support for global and per-thread overrides.\n\n```java\n// G [...]
+{"description": "The `org.apache.juneau.commons.lang` package provides language utilities including value wrappers, version management, string formatting, state enums, and other common language constructs.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/lang/Value.html\" target=\"_blank\">Value</a></java-class>\nA generic mutable value wrapper.\n\n```java\n// Basic usage\nValue<String> name = Value.of(\"John\");\nname.set(\"Jane\");\nString result = [...]
+{"description": "The `org.apache.juneau.commons.io` package provides file and stream utilities, console support, MIME type detection, and path builders for working with files and I/O operations.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/io/LocalFile.html\" target=\"_blank\">LocalFile</a></java-class>\nRepresents a file that can be located either on the classpath or in the file system.\n\n```java\n// Classpath file\nLocalFile classpathFile = ne [...]
+{"description": "The `org.apache.juneau.commons.inject` package provides Juneau's lightweight injection model. The framework is **JSR-330\u2013aligned** (`jakarta.inject` / `javax.inject`) and layers a small set of Spring-flavored conveniences (`@Bean`, `@Configuration`, `@Primary`, `@Order`, `@Conditional`) on top \u2014 all under Juneau-owned annotations, and **without a compile-time dependency on `jakarta.inject-api` or `jakarta.annotation-api`**.\n\n> Juneau supports JSR-330 (`jakart [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-assertions</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-assertions-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.assertions_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe <a href=\"/site/apidocs/org/apache/juneau/assertions/package-summary.html\" target=\"_blank\">org.apac [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/assertions/package-summary.html\" target=\"_blank\">org.apache.juneau.assertions</a> package in Juneau is a powerful API for performing\nfluent style assertions.\nIt is used throughout the REST client and server APIs for performing inline assertions on REST requests and responses.\n\n:::tip Example\n```java\n// Create a basic REST client with JSON support and download a bean.\nMyBean bean = RestClient.create()\n .json5()\n [...]
+{"description": "# Bean-Centric Testing Framework\n\nA powerful and intuitive testing framework that extends JUnit with streamlined assertion methods for Java objects. BCT eliminates verbose test code while providing comprehensive object introspection and comparison capabilities.\n\n## \ud83d\udccb Table of Contents\n\n- [Overview](#overview)\n- [Quick Start](#quick-start)\n- [Core Assertion Methods](#core-assertion-methods)\n- [Nested Property Access](#nested-property-access)\n- [Advanc [...]
+{"description": "# Custom Error Messages\n\nCustom error messages allow you to provide contextual information when BCT assertions fail. This makes test failures more informative and helps identify issues faster during debugging.\n\n## Overview\n\nBCT supports custom error messages through a `Supplier<String>` parameter in all assertion methods. This provides:\n- **Lazy evaluation** - Messages are only generated when assertions fail\n- **Format support** - Use `Utils.fs()` for convenient [...]
+{"description": "# Customization\n\nBCT provides flexible customization options through the `@BctConfig` annotation and the `BctConfiguration` class. These tools allow you to configure assertion behavior, customize property access, and extend BCT's capabilities to match your testing needs.\n\n## \ud83d\udccb Table of Contents\n\n- [@BctConfig Annotation](#bctconfig-annotation)\n- [BctConfiguration Class](#bctconfiguration-class)\n- [Configuration Properties](#configuration-properties)\n- [...]
+{"description": "# Stringifiers\n\nStringifiers define how specific types should be converted to strings for comparison in BCT assertions. They provide flexible, customizable string representations that can be tailored to your testing needs.\n\n## Built-in Stringifiers\n\nBCT comes with comprehensive built-in stringifiers for common Java types:\n\n```java\n// Array types\nchar[] chars = {'H', 'e', 'l', 'l', 'o'};\nassertString(\"Hello\", chars); // Uses charArrayStringifier()\n\nbyte[] [...]
+{"description": "# Listifiers\n\nListifiers convert collection-like objects into lists for use in BCT assertions. They provide a unified way to work with various collection types, iterators, streams, and other iterable data structures.\n\n## Built-in Listifiers\n\nBCT comes with comprehensive built-in listifiers for collection-like Java types:\n\n```java\n// Collection types\nList<String> list = List.of(\"a\", \"b\", \"c\");\nassertList(list, \"a\", \"b\", \"c\"); // Uses collectionList [...]
+{"description": "# Swappers\n\nSwappers transform objects before they are processed by BCT assertions. They provide a way to unwrap, evaluate, or transform objects into more testable forms. Swappers are particularly useful for wrapper types like Optional, Supplier, and Future.\n\n## Built-in Swappers\n\nBCT comes with built-in swappers for common wrapper and lazy-evaluation types:\n\n```java\n// Optional types\nOptional<String> optional = Optional.of(\"Hello\");\nassertString(\"Hello\", [...]
+{"description": "# Property Extractors\n\nProperty extractors define custom property access logic for objects that don't follow standard JavaBean patterns or require specialized property extraction. They provide a flexible way to access properties from any object structure.\n\n## Overview\n\nProperty extractors are used when:\n- Objects don't follow JavaBean getter conventions\n- You need to compute properties dynamically\n- You want to provide custom property names or aliases\n- Objects [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-common</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-common-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.common_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe <a href=\"/site/apidocs/org/apache/juneau/http/package-summary.html\" target=\"_blank\">org.apache. [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/header/package-summary.html\" target=\"_blank\">org.apache.juneau.http.header</a> package contains various convenience classes for creating\nstandard HTTP components using static imports.\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/http/HttpHeaders.html\" target=\"_blank\">HttpHeaders</a></java-class> - Utility class for standard HTTP headers.</node-0>\n<node-0><java-class><a href=\"/site/api [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/package-summary.html\" target=\"_blank\">org.apache.juneau.http.annotation</a> package contains annotations for defining both\nserver and client side APIs.\n\nThe server-side APIs also use it for producing auto-generated Swagger documentation through the REST API itself.\n\n<tree>\n<node-0><javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Contact.html\" target=\"_blank\">Contact</a></ [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/header/package-summary.html\" target=\"_blank\">org.apache.juneau.http.header</a> package contains implementations of\n`org.apache.http.Header` for all common HTTP headers.\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/header/Accept.html\" target=\"_blank\">Accept</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/header/AcceptCharset.html\" target=\"_blank\">Ac [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/part/package-summary.html\" target=\"_blank\">org.apache.juneau.http.part</a> package contains implementations of\n`org.apache.http.NameValuePair` to be used for query/form-data/path parts and part lists.\n\n<tree>\n<node-0><java-interface><a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/NameValuePair.html\" target=\"_blank\">NameValuePair</a></java-interface></node-0>\n< [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/entity/package-summary.html\" target=\"_blank\">org.apache.juneau.http.entity</a> package contains implementations of\n`org.apache.http.HttpEntity`.\nThese are entities that can be sent or received with an HTTP message.\nThey consist of a message body and the headers `Content-Type`, `Content-Length`, and `Content-Encoding`.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/http/resource/package-summary.html\" target=\"_bl [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/response/package-summary.html\" target=\"_blank\">org.apache.juneau.http.response</a> package contains predefined\n`org.apache.http.HttpResponse` implementations for most standard HTTP responses.\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/Accepted.html\" target=\"_blank\">Accepted</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/AlreadyRep [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/package-summary.html\" target=\"_blank\">org.apache.juneau.http.remote</a> package contains the annotations used for defining\nclient-side remote proxies.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">Remote</a></java-annotation></node-0>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteGet.html\" targe [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-server</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-server-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.server_0.0.0.jar\n```\n\nThe `juneau-rest-server` library allows you to quickly wrap POJOs and expose them as full-fledged REST resources served up\nin a [...]
+{"description": "A REST resource is simply a Java class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">@Rest</a>.\nThe most common case is a class that extends <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a>, which itself is simply an extension of <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html\" target=\"_blan [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">@Rest</a> annotation is the primary way of defining and\nconfiguring REST resource classes.\n\nThe functionality of the class itself is covered in detail in the topics later.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/sit [...]
+{"description": "The following example represents the bare-minimum needed for deploying a top-level REST endpoint with basic JSON\nmarshalling support:\n\n```java\n@Rest(\n path=\"/mypath\",\n serializers=JsonSerializer.class,\n parsers=JsonParser.class\n)\npublic class MyResource extends RestServlet {\n\n @RestGet(path=\"/\")\n public Object getPojo() {\n ...\n }\n}\n```\n\nThe <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/RestServlet.html\" target=\"_b [...]
+{"description": "Child Resources are REST servlets or objects that are linked to parent resources through the <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#children()\" target=\"_blank\">@Rest(children)</a> annotation.\n\n:::tip Example\n```java\n/** Parent Resource */\n@Rest(\n path=\"/parent\",\n children={MyChildResource.class}\n)\npublic MyRootResources extends BasicRestServletGroup {...}\n```\n\n```java\n/** Child Resource */\n@Rest(\n path=\"/child\" [...]
+{"description": "The path can contain variables that get resolved to <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Path.html\" target=\"_blank\">@Path</a>\nparameters or access through the <a href=\"/site/apidocs/org/apache/juneau/rest/RestRequest.html#getPathParams()\" target=\"_blank\">RestRequest.getPathParams()</a> method.\n\n:::tip Example\n```java\n@Rest(\n path=\"/myResource/{foo}/{bar}\"\n)\npublic class MyResource extends BasicRestServlet {\n\n @RestPost(\"/{ba [...]
+{"description": "REST resources are deployed in the following ways:\n\n- Deployed in a J2EE container as a servlet.\n- Deployed in a Spring Boot environment as a servlet.\n- Deployed as a child of another REST resource.\n\nWhen deployed in a J2EE container, you MUST extend from one of the servlet classes.\n\n:::note\nWhen deployed as a child of another resource, you MAY extend from one of the servlet classes but it's not necessary.\nThe only requirement is that the class be annotated wit [...]
+{"description": "Lifecycle hooks allow you to hook into lifecycle events of the servlet/resource creation and REST calls.\n\nFor example, if you want to add an initialization method to your resource:\n\n```java\n@Rest(...)\npublic class MyResource extends BasicRestObject {\n\n // Our database.\n private Map myDatabase;\n\n @RestInit\n public void initMyDatabase() throws Exception {\n myDatabase = new LinkedHashMap();\n }\n}\n```\n\n:::note 9.5 change\nAny lifecycle [...]
+{"description": "REST Java methods are identified on REST servlets using the <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestOp</a> annotation.\n\nThe annotation allows the framework to identify the available REST methods through reflection.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">RestOp</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a hr [...]
+{"description": "When the `name` and/or `path` values are not specified, their values are inferred from the Java method name.\n\nThe HTTP method can be inferred from the Java method by starting the method name with any of the following:\n\n- `get`\n- `put`\n- `post`\n- `delete`\n- `options`\n- `head`\n- `trace`\n- `patch`\n\nIf `path` is not defined, it's inferred from the Java method name (minus the prefix above).\n\n:::tip Examples\n```java\n// Method=\"GET\", path=\"/foo\"\n@RestOp\np [...]
+{"description": "Java methods can contain any of the following parameters in any order:\n\n<tree>\n<node-0>**Parameters based on class types:**</node-0>\n<node-1>**Request objects:**</node-1>\n<node-2><javac-class>`AsyncContext`</javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/arg/CookieList.html\" target=\"_blank\">CookieList</a></javac-class> <javac-class>`DispatcherType`</javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/httppart/HttpPartPars [...]
+{"description": "The return type of the Java method can be any serializable POJO as defined in [POJO Categories](/docs/topics/PojoCategories).\n\nIt can also be void if the method is not sending any output (e.g a request redirect) or is setting the output using the <a href=\"/site/apidocs/org/apache/juneau/rest/RestResponse.html#setContent(java.lang.Object)\" target=\"_blank\">RestResponse.setContent(Object)</a> method.\n\n:::tip Example\n```java\n@RestGet\npublic String doGet() {\n [...]
+{"description": "Annotated Java methods can throw any of the following:\n\n#### Standard HTTP response beans:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/BadRequest.html\" target=\"_blank\">BadRequest</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/Conflict.html\" target=\"_blank\">Conflict</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/ExpectationFailed.html\" targe [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html#path()\" target=\"_blank\">@RestOp(path)</a> annotation allows you to define\nURL path patterns to match against.\nThese patterns can contain variables of the form `{xxx}` that can be passed in directly to the Java methods as extra\nparameters.\n\nIn the following example, 3 separate GET request handlers are defined with different path patterns.\nNote how the variables are passed in as additional a [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/matcher/RestMatcher.html\" target=\"_blank\">RestMatchers</a> are used to allow multiple Java methods to\nbe tied to the same HTTP method and path but differentiated by some request attribute such as a specific header value.\n\n:::tip Example\n```java\n// GET method that gets invoked for administrators\n@RestGet(path=\"/*\", matchers=IsAdminMatcher.class)\npublic Object doGetForAdmin() {\n ...\n}\n\n// GET method that get [...]
+{"description": "Through the use of the built-in `method` GET parameter, you can implement requests beyond the basic REST http method\ntypes.\n\nFor example, the URL `/sample/foo?method=BAR` will cause the following method to be invoked...\n\n```java\n@RestOp(method=\"BAR\")\npublic void doBar(RestRequest req, RestResponse res) {\n // Handle BAR requests\n}\n```\n\nTo support overloaded methods, the <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#allowedMethodParam [...]
+{"description": "Refer to the following Javadocs for more information:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/RestRequest.html\" target=\"_blank\">RestRequest</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/RestResponse.html\" target=\"_blank\">RestResponse</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/httppart/RequestContent.html\" target=\"_blank\">Reques [...]
+{"description": "In previous examples we showed the ability to pass in annotated parameters on <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">RestOp</a>-annotated methods to parse standard HTTP parts:\n\n:::tip Example\n```java\n@RestGet(\"/example1/{a1}/*\")\npublic String doGetExample1(\n @Path(\"a1\") String a1,\n @Query(\"p1\") int p1,\n @HasQuery(\"p2\") boolean hasP3,\n @Path(\"/*\") String remainder,\n @Header(\"Accept-Lang [...]
+{"description": "Juneau comes with three basic marshaller types for serializing and parsing Header, Query, Form, and Path parts:\n\n<tree>\n<node-0><java-interface><a href=\"/site/apidocs/org/apache/juneau/httppart/HttpPartSerializer.html\" target=\"_blank\">HttpPartSerializer</a></java-interface></node-0>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/httppart/SimplePartSerializer.html\" target=\"_blank\">SimplePartSerializer</a></java-class> - Serializes directly to str [...]
+{"description": "The following annotations allow for defining part schemas based on the OpenAPI standard.\n\n#### Request annotations:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Request.html\" target=\"_blank\">Request</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Request.html#on()\" target=\"_blank\">on</a></javac-method-annotation> <javac-method-annotation><a [...]
+{"description": "By default, HTTP parts that don't have value (such as missing query parameters) end up with null values:\n\n```java\n@RestPost(\"/example\")\npublic String doGetExample1(\n @Query(\"p1\") int p1,\n @FormData(\"f1\") MyBean f1,\n @Header(\"Accept-Language\") AcceptLanguage h1\n) {\n if (p1 == null) p1 = -1;\n if (f1 == null) f1 = DEFAULT_BEAN;\n if (h1 == null) h1 = AcceptLanguage.of(\"en\");\n}\n```\n\nYou have several options to provide default values [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Request.html\" target=\"_blank\">@Request</a> annotation can used to define proxy\ninterfaces against HTTP requests in combination with the following annotations used on methods:\n\n<tree>\n<node-0><javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Header.html\" target=\"_blank\">Header</a></javac-annotation> <javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Q [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Response.html\" target=\"_blank\">Response</a> annotation can be used to define beans that\nreturn HTTP response parts via annotations and methods.\n\nThey are used in combination with the following annotations:\n\n<tree>\n<node-0><javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/StatusCode.html\" target=\"_blank\">StatusCode</a></javac-annotation> <javac-annotation><a href=\"/site/ap [...]
+{"description": "Request HTTP parts can also be retrieved programmatically through the following classes that can be passed in as\nparameters or access through <a href=\"/site/apidocs/org/apache/juneau/rest/RestRequest.html\" target=\"_blank\">RestRequest</a> bean:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/httppart/RequestHeaders.html\" target=\"_blank\">RequestHeaders</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/httpp [...]
+{"description": "HTTP parts can be automatically validated against their schema definitions using format validation and Jakarta Bean Validation constraints.\n\n## Format Validation\n\nJuneau supports comprehensive format validation for HTTP parts based on JSON Schema Draft 2020-12 and OpenAPI 3.x specifications. When a `format` is specified in a `@Schema` annotation, the value is automatically validated against that format.\n\n### Supported Formats\n\nThe following format types are suppo [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` is pre-9.5 and kept only for historical context.\nUse `@Rest(...serializers/parsers...)`, `@RestOp(...)`, or `@RestInject(name=\"serializers\"|\"parsers\")`\nwith fully built sets. See the [v9.5 Migration Guide](/docs/topics/V9.5MigrationGuide).\n:::\n\nJuneau uses <a href=\"/site/apidocs/org/apache/juneau/parser/Parser.html\" target=\"_blank\">Parsers</a> and <a href=\"/site/apidocs/or [...]
+{"description": "HTTP form posts can be handled two ways:\n\n- By parsing the entire HTTP body into a POJO using the registered <a href=\"/site/apidocs/org/apache/juneau/urlencoding/UrlEncodingParser.html\" target=\"_blank\">UrlEncodingParser</a>\n- By access the form post entries as HTTP parts.\n\nThe following example shows the first approach of handling an `application/x-www-form-urlencoded` request of the form `aString=foo&aNumber=123&aDate=2001-07-04T15:30:45Z` and loading it into a [...]
+{"description": "Guards control access to REST classes and methods.\n\nWhen guards are associated at the class-level, it's equivalent to associating guards on all Java methods on the servlet.\n\nIf multiple guards are present, ALL guards must pass.\n(Note that this is different in behavior to Matchers which require only one matcher to pass.) \n\nGuards are associated with resource classes and methods via the following:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apach [...]
+{"description": "Converters can be thought of as \"post-processors\" for response POJOs before they get passed to the serializer.\n\nConverters are associated with resource classes and methods via the following:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#converters()\" targ [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#messages()\" target=\"_blank\">@Rest(messages)</a> annotation identifies the\nlocation of the resource bundle for a <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">@Rest</a>-annotated class if it's different from the class name.\n\nBy default, the resource bundle name is assumed to match the class name.\nFor example, given the class `MyClass.java`, the resource [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#encoders()\" target=\"_blank\">@Rest(encoders)</a> annotation can be used to\nassociate character encoders with a servlet class.\nEncoders can be used to enable various kinds of compression (e.g. `gzip`) on requests and responses based on the request\n`Accept-Encoding` and `Content-Encoding` headers.\n\n:::tip Example\n```java\n// Servlet with automated support for GZIP compression\n@Rest(encoders={G [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` is pre-9.5 and kept only for historical context.\nUse `Config` parameter injection in `@RestOp` methods, `@RestInject` beans, or `RestContext.getConfig()`\nfrom a supported `@RestInit` parameter. See the [v9.5 Migration Guide](/docs/topics/V9.5MigrationGuide).\n:::\n\nThe Server API provides methods for associating configuration files with REST servlets so that configuration properties\ [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` / `builder.vars(...)` is pre-9.5 and kept only\nfor historical context. Register custom vars through `@RestInject(name=\"varResolver\")` with a\n`VarResolver` (or `VarResolver.Builder`) supplier. See the\n[v9.5 Migration Guide](/docs/topics/V9.5MigrationGuide).\n:::\n\nIn the previous examples, there were several cases where embedded variables were contained within annotation values:\n\ [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a> and <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestObject.html\" target=\"_blank\">BasicRestObject</a> classes come with built-in support for serving up static files through the following REST operation:\n\n```java\n@RestGet(path=\"/htdocs/*\")\npublic HttpResource getHtdoc(@Path(\"/*\") String path, Locale locale) throws NotFound {\n [...]
+{"description": "Client version headers are used to support backwards compatibility for breaking REST interface changes.\nUsing them, you're able to return different responses based on which client is making a request.\n\nThe APIs involved with defining client version headers are:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/a [...]
+{"description": "One of the most useful features of Juneau is the ability to generate Swagger-based OPTIONS pages for self-documenting\ndesigns (i.e.\nREST interfaces that document themselves).\n\nAs described previously, the `PetStore` example provides an example of auto-generated Swagger JSON:\n\n\n\nUsing <a href=\"/site/apidocs/org/apache/juneau/bean/swagger/ui/SwaggerUI.html\" target=\"_blank\">SwaggerUI</a>, we're able to render t [...]
+{"description": "Any subclass of <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a> and <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestObject.html\" target=\"_blank\">BasicRestObject</a> gets an auto-generated Swagger UI when performing an `OPTIONS` request with `Accept:text/html` due to the following method:\n\n```java\n@RestGet(\n path=\"/api/*\",\n summary=\"Swagger documentation\",\n descript [...]
+{"description": "Let's look at the various parts of the `Petstore` application Swagger UI to see how they are defined.\n\nThe top part of the page shows general information about the REST interface:\n\n\n\nThe information is pulled from the <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#swagger()\" target=\"_blank\">@Rest(swagger)</a>\nannotation.\n\n#### org.apache.juneau.examples.rest.petstore.PetStoreRes [...]
+{"description": "Tags allow you to group operations into general categories.\nIn the user interface, these can be expanded/collapsed by clicking on the tag sections.\n\nIn the example below, the `pet` and `store` tag sections are collapsed and the `user` section is not:\n\n\n\nTags are also defined in the <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Swagger.html\" target=\"_blank\">@Swagger</a> annotation\n\n#### PetStoreReso [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestOp</a>-annotated methods automatically get rendered as Swagger operations.\n\nThe following shows the annotations defined on the `GET /pet` operation:\n\n#### PetStoreResource.getPets()\n\n```java\n@RestGet(\n path=\"/pet\",\n summary=\"All pets in the store\",\n swagger=@OpSwagger(\n tags=\"pet\",\n ...\n ),\n ...\n)\npublic Collection getPets() th [...]
+{"description": "Expanding operations shows you a list of parameters.\n\nParameter information can be defined in a couple of ways.\nThe typical way is through annotations on parameters being passed to your <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestOp</a>-annotated method, like so:\n\n```java\n@RestGet\npublic Collection getPets(\n @Query(\n name=\"s\",\n schema=@Schema(\n description={\n [...]
+{"description": "Under the input parameters are listed the possible responses for the resource.\n\nThe `200` response is determined by the return type on the method, in this case a collection of `Pet` objects:\n\n```java\n@RestGet(\n path=\"/pet\",\n summary=\"All pets in the store\",\n ...\n)\npublic Collection getPets() throws NotAcceptable {\n return store.getPets();\n}\n```\n\nNote that additional responses can be specified by throwing exceptions annotated with the <a hre [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `@HookEvent(INIT)` or `RestContext.Builder` is pre-9.5 and kept only\nfor historical context. Configure schema generation through\n`@RestInject(name=\"jsonSchemaGenerator\")` with a fully built `JsonSchemaGenerator`. See the\n[v9.5 Migration Guide](/docs/topics/V9.5MigrationGuide).\n:::\n\nThe <a href=\"/site/apidocs/org/apache/juneau/jsonschema/JsonSchemaGenerator.Builder.html#useBeanDefs()\" target=\"_blan [...]
+{"description": "The look-and-feel of the Swagger UI is controlled via a single CSS file: `SwaggerUI.css`.\n\nIn the microservice template, this file is located in the `files/htdocs/styles` directory.\n\nIt's a simple straightforward file consisting of less than 350 lines.\n\nThis file can be modified to change the look-and-feel of your Swagger UI.", "id": "topic:aa9b6c602259", "module": "16", "related_ids": [], "source_path": "pages/topics/10.16.09.SwaggerStylesheet.md", "source_type": [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">Rest</a>-annotated classes get automated timing and error\nstatistic information for all <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestOp</a> and lifecycle-event annotated methods on the class.\nIf you extend from <a href=\"/site/apidocs/org/apache/juneau/rest/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a> or <a [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/html/annotation/HtmlDocConfig.html\" target=\"_blank\">@HtmlDocConfig</a> annotation is used to customize\nthe HTML view of POJOs serialized by <a href=\"/site/apidocs/org/apache/juneau/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a>.\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/html/annotation/HtmlDocConfig.html\" target=\"_blank\">HtmlDocConfig</a></java-annotation></node [...]
+{"description": "An important distinction needs to be made about the HTML representations produced by the REST API.\nThese should not be considered User Interfaces but rather Developer Interfaces.\nUIs should hide the end-user from the underlying architecture.\nThe audience generally consists of non-technical people not interested in how the UI works.\nDIs, on the other hand, should NOT hide the end-user from the underlying architecture.\nInstead, it's a thin veneer over the REST interfa [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/widget/Widget.html\" target=\"_blank\">Widget</a> class allows you to add arbitrary HTML, CSS, and\nJavascript to HTML pages.\n\nThey are registered in the following location:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/html/annotation/HtmlDocConfig.html\" target=\"_blank\">HtmlDocConfig</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/ju [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/widget/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.widget</a> package contains predefined reusable widgets.\n\n<tree>\n<node-0><java-package><a href=\"/site/apidocs/org/apache/juneau/rest/widget/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.widget</a></java-package></node-0>\n<node-1><javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/widget/Widget.html\" target=\"_blank\">Wi [...]
+{"description": "The HTML views of POJOs can somewhat be considered a rudimentary User Interface.\nIn reality, a better term for them would be a Developer Interface as they're meant to be used primarily by developers\nand not end users.\nDespite that distinction, it is possible to 'brand' the HTML page to whatever you desire.\n\nThe sample root page below includes some default branding for Juneau and Apache:\n\n```text\nhttp://localhost:10000/helloWorld\n```\n\nThe Juneau REST framework [...]
+{"description": "The sample root page renders in the default \"devops\" look-and-feel:\n\n\n\n```text\nhttp://localhost:10000\n```\n\nThe sample root page provides a dropdown widget to try out the other default look-and-feels: For example, the \"light\"\nlook-and-feel:\n\n\n\n```text\nhttp://localhost:10000/?stylesheet=styles%2Flight.css\n```\n\nAnd the \"dark\" look-and-fee [...]
+{"description": "The REST APIs provides supports enabling logging of HTTP requests and responses through the following annotations:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#debug()\" target=\"_blank\">debug</a></java-method-annotation></node-1>\n<node-1><java-method-annot [...]
+{"description": "By default, a `200 (OK)` status is automatically set as the HTTP status when a Java method executes successfully.\n\nOther status codes can be generated by throwing a <a href=\"/site/apidocs/org/apache/juneau/http/response/BasicHttpException.html\" target=\"_blank\">BasicHttpException</a> with a specific HTTP status code, or calling <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServletResponse.html#setStatus(int)\" target=\"_bla [...]
+{"description": "The following URL parameters have special meaning and can be passed in through the URL of the request:\n\n| GET Parameter | Description |\n|---------------|-------------|\n| `&plainText=true` | Response will always be `Content-Type: text/plain` and the returned text will be human-readable (<a href=\"/site/apidocs/org/apache/juneau/serializer/WriterSerializer.Builder.html#useWhitespace()\" target=\"_blank\">WriterSerializer.Builder.useWhitespace()</a> enabled).<br />Usefu [...]
+{"description": "Juneau REST supports overriding serializer and parser session properties on a per-request basis via HTTP headers or query parameters. This allows clients to control aspects of marshalling (such as whitespace formatting, bean type annotations, etc.) without server-side code changes.\n\n## Overview\n\nThe feature works at two levels:\n\n1. **Server-side**: Configure which properties clients are allowed to override using `@Rest` or `@RestOp` annotations.\n2. **Client-side** [...]
+{"description": "Since REST servlets are basically just `HttpServlets`, incorporating them into an OSGi environment is pretty\nstraightforward.\n\nThe following code shows how to register your REST servlets in an OSGi Activator:\n\n```java\npackage org.apache.juneau.examples.rest;\n\nimport org.osgi.framework.*;\nimport org.osgi.service.http.*;\nimport org.osgi.util.tracker.*;\n\nimport org.apache.juneau.rest.samples.*;\n\n/**\n* Activator class used when running samples as a bundle in a [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` (constructor injection or `@RestInit` parameter\ninjection) is pre-9.5 and kept only for historical context. The Builder-injection protocol was\nremoved; migrate to `@Rest(...)` / `@RestOp(...)` attributes, `@RestInject(name=\"...\")` bean\nsuppliers, and `new RestContext(RestContextInit)` for programmatic bootstrap. See the\n[v9.5 Migration Guide](/docs/topics/V9.5MigrationGuide).\n::: [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/RestOpContext.html\" target=\"_blank\">RestOpContext</a> object is the workhorse class for an\nindividual <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">RestOp</a>-annotated method.\nEvery class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestOp</a> ends up with an instance of this object.\n\nSimilar to <a href=\"/sit [...]
+{"description": "The REST Server API uses the concept of registered response processors for converting objects returned by REST methods\nor set through <a href=\"/site/apidocs/org/apache/juneau/rest/RestResponse.html#setContent(java.lang.Object)\" target=\"_blank\">RestResponse.setContent(Object)</a> into appropriate HTTP responses.\nBy default, REST resource classes are registered with the following response processors:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/j [...]
+{"description": "The REST/RPC (RPC over REST) API allows the creation of client-side remote proxy interfaces for calling methods on\nserver-side POJOs using entirely REST.\n\n:::note\nThis is not to be confused with REST Proxies which are entirely client-side driven Java interfaces\nagainst arbitrary backend REST interfaces.\n:::\n\n#### Remote Interfaces\n\nThe following example shows a remote interface:\n\n```java\n@RemoteInterface // Annotation is optional\npublic interface IAddressBo [...]
+{"description": "As mention earlier [here](/docs/topics/SerializingUris), Juneau serializers have sophisticated support for transforming relative URIs\nto absolute form.\nThe following example shows a REST method that returns a list of URIs of various forms:\n\n```java\n@Rest(\n uriAuthority=\"http://foo.com:123\",\n uriContext=\"/myContext\"\n)\npublic class MyResource {\n\n @RestGet\n public URI[] getURIs() {\n return new URI[] {\n URI.create(\"http://www. [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/beans/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.beans</a> package contains a set of reusable utility beans meant to\nhelp with putting together explorable REST interfaces.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html\" target=\"_blank\">UtilityBeansResource</a> class shows how these\nbeans are used.\n\nThe resource class is hosted in the example REST appli [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/examples/rest/HtmlBeansResource.html\" target=\"_blank\">HtmlBeansResource</a> class shows how <a href=\"/site/apidocs/org/apache/juneau/bean/html5/package-summary.html\" target=\"_blank\">HTML5 beans</a> can be used to generate arbitrary HTML on REST endpoints.\n\n##### table\n\nThe <a href=\"/site/apidocs/org/apache/juneau/examples/rest/HtmlBeansResource.html#aTable()\" target=\"_blank\">aTable()</a> method shows an example [...]
+{"description": "- Subclasses can use either <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html#init(ServletConfig)\" target=\"_blank\">HttpServlet.init(ServletConfig)</a> or <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html#init()\" target=\"_blank\">HttpServlet.init()</a> for initialization just like any other servlet.\n- The `X-Response-Headers` header can be used to pass through hea [...]
+{"description": "The REST API uses Java logging by default.\n\nIf you wish to use LOG4J logging, you simple need to add the following to your JVM arguments and maven dependencies:\n\n#### Command-line argument\n\n```text\n-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager\n```\n\n#### Maven dependency\n\n```xml\n<dependency>\n <groupId>org.apache.logging.log4j</groupId>\n <artifactId>log4j-jul</artifactId>\n</dependency>\n```", "id": "topic:0cbb6cae0620", "module": [...]
+{"description": "# juneau-rest-server-mcp\n\nThe `juneau-rest-server-mcp` module exposes a stateless [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) JSON-RPC endpoint built on `juneau-rest-server` and the [`juneau-bean-mcp`](/docs/topics/JuneauBeanMcp) wire beans.\n\n## Overview\n\nMCP is a JSON-RPC 2.0 protocol that lets AI assistants discover and invoke external **tools**, **prompts**, and **resources**. This module provides:\n\n- A transport-agnostic **dispatcher** th [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-server-springboot</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-server-springboot-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.server.springboot_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-rest-server-springboot` library provides classes to make i [...]
+{"description": "The Juneau REST servlet APIs are designed to work seemlessly with the Spring Boot framework.\n\nThe only restriction is that your top-level REST resource must extend from one of the following classes:\n\n<tree>\n<node-0><java-package><a href=\"/site/apidocs/org/apache/juneau/rest/springboot/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.springboot</a></java-package></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/rest/spr [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-client-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.client_0.0.0.jar\n```\n\n#### Contents/Features\n\nBuilt upon the feature-rich Apache HttpClient library, the Juneau RestClient API adds support for fluen [...]
+{"description": "By default, JSON support is provided for HTTP request and response bodies.\n\nOther languages can be specified using any of the following builder methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#json()\" target=\"_blank\">json()</a></java-me [...]
+{"description": "Per-client or per-request HTTP parts (headers, query/form data, path parameters) can be manipulated via the following\nmethods that return back builders for those parts:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><javac-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#headers()\" target=\"_blank\"> [...]
+{"description": "The request body can either be passed in with the client creator method (e.g. <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html#post(java.lang.Object)\" target=\"_blank\">post(uri,body)</a>), or can be specified via the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestRequest.html\" target=\"_blank\">RestRequest</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache [...]
+{"description": "After execution using <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestRequest.html#run()\" target=\"_blank\">RestRequest.run()</a> or <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestRequest.html#complete()\" target=\"_blank\">RestRequest.complete()</a>, the following methods can be used to get the response status:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html\" target=\"_blank\">RestResponse</a> [...]
+{"description": "Response headers are accessed through the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html\" target=\"_blank\">RestResponse</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html#getHeader(java.lang.String)\" target=\"_blank\">getHeader(String)</a></java-method> \u2192 <a href=\"/site/apidocs/org/apache/juneau/rest/client/ResponseHeade [...]
+{"description": "The response body is accessed through the following method:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html\" target=\"_blank\">RestResponse</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html#getContent()\" target=\"_blank\">getContent()</a></java-method> \u2192 <a href=\"/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html\" target=\"_b [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestCallHandler.html\" target=\"_blank\">RestCallHandler</a> interface provides the ability to\nprovide custom handling of requests.\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#callHandle [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestCallInterceptor.html\" target=\"_blank\">RestCallInterceptor</a> API provides a quick way\nof intercepting and manipulating requests and responses beyond the existing <a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/HttpRequestInterceptor.html\" target=\"_blank\">HttpRequestInterceptor</a> and <a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/ht [...]
+{"description": "One of the more powerful features of the REST client class is the ability to produce Java interface proxies against\narbitrary 3rd party REST resources.\n\nThe methods to retrieve remote interfaces are:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html\" target=\"_blank\">RestClient</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html#getRemote(java.lang.Cl [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">@Remote</a> annotation is used on your interface class to\nidentify it as a REST proxy interface.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">Remote</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html#path()\" target=\"_blank\"> [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a> annotation is applied to methods of\n@Remote-annotated interfaces to identify REST endpoints.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">RemoteOp</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html#method()\" [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Content.html\" target=\"_blank\">@Content</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are the HTTP body of the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Content.html\" target=\"_blank\">Content</a></java-annot [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/FormData.html\" target=\"_blank\">@FormData</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are form-data parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/FormData.html\" target=\"_blank\">@FormData</a> [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Query.html\" target=\"_blank\">@Query</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are query parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Query.html\" target=\"_blank\">@Query</a></java-annotatio [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Header.html\" target=\"_blank\">@Header</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are header parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Header.html\" target=\"_blank\">@Header</a></java-anno [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Path.html\" target=\"_blank\">@Path</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are path parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Path.html\" target=\"_blank\">@Path</a></java-annotation></n [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Request.html\" target=\"_blank\">@Request</a> annotation can be applied to a type of a\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated method to identify it as a bean for setting HTTP parts through a bean-like interface.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Request.html\" target=\"_blank\"> [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/annotation/Response.html\" target=\"_blank\">@Response</a> annotation can be applied to types\nreturned by <a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/annotation/Response.html\" target=\"_blank\">Response</a></java-annotation></node-0>\n<node-1><java-method-annota [...]
+{"description": "A common coding practice is to use the same Java interface to define both your server and client side REST interfaces.\nThe advantage to this approach is that changes that you make to your REST interface can be reflected in both places at\nthe same time, reducing the chances for compatibility mistakes.\n\nWhat makes this possible is that method-level annotations such as <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestOp</a> [...]
+{"description": "The following methods provide logging of requests and responses:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#logger(java.util.logging.Logger)\" target=\"_blank\">logger(Logger)</a></java-method></node-1>\n<node-1><java-method><a href=\"/site/api [...]
+{"description": "Several methods are provided for customizing the underlying HTTP client and client builder classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#httpClientBuilder(org.apache.http.impl.client.HttpClientBuilder)\" target=\"_blank\">httpClientBuilde [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html\" target=\"_blank\">RestClient</a> API has been designed to allow for the ability to be easily extended.\n\nThe following example that overrides the primary run method shows how this can be done.\n\n:::tip Example\n```java\npublic class MyRestClient extends RestClient {\n\n // Must provide this constructor!\n public MyRestClient(ContextProperties ps) {\n super(ps);\n }\n\n @Overr [...]
+{"description": "The Juneau REST client itself does not implement any support for authentication.\n\nInstead, it delegates it to the underlying Apache HTTP Client interface.\n\nThe following sections show how some common authentication mechanisms can be set up using HTTP Client APIs.", "id": "topic:a36ca8ff5783", "module": "14", "related_ids": [], "source_path": "pages/topics/12.14.01.AuthenticationBasics.md", "source_type": "topic", "summary": "The Juneau REST client itself does not imp [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#basicAuth(java.lang.String,int,java.lang.String,java.lang.String)\" target=\"_blank\">basicAuth()</a> method can be used to quickly enable BASIC authentication support.\n\n:::tip Example\n```java\n// Create a client that performs BASIC authentication using the specified user/pw.\nRestClient client = RestClient.create()\n .basicAuth(HOST, PORT, USER, PW)\n .build();\n```\n:::\n\nThis i [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a> class does not itself\nprovide FORM-based authentication since there is no standard way of providing such support.\nTypically, to perform FORM-based or other types of authentication, you'll want to create your own subclass of <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a> and [...]
+{"description": "The following example shows an implementation of a client that performs OIDC authentication against the IBM Jazz\nplatform.\n\n```java\n/**\n* Constructor.\n*/\npublic JazzRestClient.Builder(URI jazzUri, String user, String pw) throws IOException {\n ...\n}\n\n/**\n* Override the createHttpClient() method to return an authenticated client.\n*/\n@Override /* RestClient.Builder */\nprotected CloseableHttpClient createHttpClient() throws Exception {\n CloseableHttpCli [...]
+{"description": ":::warning Beta API\nAll public types under `org.apache.juneau.ng.*` are **beta**. Source- and binary-incompatible changes\nmay appear in the next major Juneau release. For production deployments that require strict\nbinary stability, continue using the classic `RestClient` / `juneau-rest-common` APIs until the\nNG stack is declared stable in a future release.\n:::\n\nJuneau 9.5.0 introduces a next-generation REST client and HTTP type stack under\n`org.apache.juneau.ng.* [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-mock</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-mock-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.mock_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-rest-mock` module contains convenience APIs for performing serverless unit testing of your REST A [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html\" target=\"_blank\">MockRestClient</a> class is used for performing\nserverless unit testing of <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html\" target=\"_blank\">@Rest</a>-annotated and <a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">@Remote</a>-annotated classes.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/rest/mock/MockRestClient. [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice-core</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-microservice-core-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.microservice.core_0.0.0.jar\n```\n\n#### Contents/Features\n\nJuneau Microservice is an API for creating stand-alone executable jars with automatic [...]
+{"description": "The Microservice API consists of a base class for defining executable microservices.\n\nFeatures include:\n\n- A builder-based API for defining and starting microservices.\n- An extensible API that allows you to hook into various lifecycle events.\n- Simple-to-use APIs for accessing manifest file entries, command-line arguments, and external configuration file properties.\n\nThe Microservice API consists of the following packages and classes:\n\n<tree>\n<node-0>Microserv [...]
+{"description": "Command-line arguments can be associated with a microservice using the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#args(java.lang.String...)\" target=\"_blank\">args()</a> method.\n\n:::tip Example\n```java\npublic static void main(String[] args) {\n Microservice\n .create() // Create builder.\n .args(args) // Pass in args.\n .build() // Create microservice.\n .start() [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#manifest(java.lang.Object)\" target=\"_blank\">Microservice.Builder.manifest(Object)</a>\nmethod can be used to specify the contents or location of of the main manifest file of the executable jar.\nIf you do not specify the location/contents of the manifest file, the microservice will attempt to resolve it through\nthe following methods: - Looking on the file system for a file at `META-I [...]
+{"description": "As a convenience, the `SystemProperties` section of your configuration file can be used to define system properties to\nset during initialization of your microservice:\n\n```ini\n#=======================================================================================================================\n# System properties\n#-----------------------------------------------------------------------------------------------------------------------\n# These are arbitrary system pr [...]
+{"description": "The Microservice API incorporates the [Simple Variable Language](/docs/topics/SimpleVariableLanguageBasics) API.\nThe variable resolver can be augmented through the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_blank\">Microservice.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#vars(java [...]
+{"description": "The Microservice API provides support for simple console commands.\n\n```java\npublic static void main(String[] args) {\n Microservice\n .create()\n .args(args)\n .build()\n .start()\n .startConsole() // Start console.\n .join()\n ;\n}\n```\n\nWhen started, the console renders the following output:\n\n```bash\nRunning class 'Microservice' using config file 'my-microservice.cfg'.\n\nList of available commands:\n exit - [...]
+{"description": "As mentioned previously, the lifecycle methods for the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a> class are explicitly defined as non-final so that they can be overridden by subclasses.\nIn addition to this support, an interface for defining event listeners for your microservice:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_bla [...]
+{"description": "Starting with **9.5.0**, the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a>\nclass is **inject-aware**. Every microservice owns an internal\n<a href=\"/site/apidocs/org/apache/juneau/commons/inject/WritableBeanStore.html\" target=\"_blank\">WritableBeanStore</a> (accessible via\n<a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html#getBeanStore()\" target=\"_blank\">getBeanStore()</a>),\np [...]
+{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice-jetty</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-microservice-jetty-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.microservice.jetty_0.0.0.jar\n```\n\n#### Contents/Features\n\nJuneau Microservice Jetty is an API for creating stand-alone executable jars that [...]
+{"description": "The Jetty Microservice API consists of a combination of the Juneau Core, Server, and Client APIs and an embedded Eclipse\nJetty Servlet Container.\n\nThe API builds upon the Core Microservices classes to produce easy-to-create and easy-to-use microservices in a standard\nJava 1.8+ environment.\n\nThe `juneau-microservice-jetty` library consists of the following classes:\n\n<tree>\n<node-0><a href=\"/site/apidocs/org/apache/juneau/microservice/jetty/package-summary.html\" [...]
+{"description": "The lifecycle methods of the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a> class\nconsists of the following:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a></java-class></node-0>\n<node-1><javac-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html#start()\" target=\"_blank\">start()</a></ja [...]
+{"description": "This section describes how to define a top-level REST resource page and deploy it in our microservice.\nThe example is a router page that serves as a jumping off page to child resources.\n\n```java\n@Rest(\n path=\"/*\",\n title=\"My Microservice\",\n description=\"Top-level resources page\",\n htmldoc=@HtmlDoc(\n navlinks={\n \"options: servlet:/?method=OPTIONS\"\n }\n ),\n children={\n HelloWorldResource.class,\n [...]
+{"description": "The following predefined resource classes are also provided for easy inclusion into your microservice:\n\n<tree>\n<node-0>Predefined Resource Classes</node-0>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/resources/ConfigResource.html\" target=\"_blank\">ConfigResource</a></java-class> - View and modify the external INI config file</node-1>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/resources/DirectoryResourc [...]
+{"description": "The following methods can be used to define the configuration for your microservice using the powerful `Config` API:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_blank\">Microservice.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#config(org.apache.juneau.config.Config)\" target=\"_blank\">config(Config)</ [...]
+{"description": "The Jetty microservice comes with a bare-bones `jetty.xml` file which can be modified to suite any needs.\n\nThe `jetty.xml` can be located in either the `.` or `files` working directory or classpath.\n\nIt can also be specified in any of the following ways:\n\n- Using the <a href=\"/site/apidocs/org/apache/juneau/microservice/jetty/JettyMicroservice.Builder.html#jettyXml(java.lang.Object,boolean)\" target=\"_blank\">JettyMicroservice.Builder.jettyXml(Object,boolean)</a> [...]
+{"description": "The Microservice project contains a `files/htdocs` folder with predefined stylesheets and images.\nThese files can be used to tailor the look-and-feel of your microservice.\n\n```text\nhttp://localhost:10000/helloWorld\n```\n\nThe REST configuration section of your microservice configuration file can be used to tailor the header and footer on\nthe pages:\n\n```ini\n#========================================================================================================== [...]
+{"description": "This example shows how the <a href=\"/site/apidocs/org/apache/juneau/microservice/jetty/JettyMicroservice.html\" target=\"_blank\">JettyMicroservice</a>\nclass can be extended to implement lifecycle listener methods or override existing methods.\nWe'll create a new class `com.foo.MyJettyMicroservice`.\n\n```java\n/**\n* Sample subclass of a JettyMicroservice that provides customized behavior.\n*/\npublic class MyJettyMicroservice extends JettyMicroservice {\n\n public [...]
+{"description": "#### Starter Project Zip\n\nThe `my-jetty-microservice.zip` file is a predefined starter Eclipse project for developing REST microservices using the\njuneau-microservice-jetty package.\n\nIt includes a combination of the Juneau Core, Server, and Client APIs and all libraries needed to execute in a Java 1.8+\nenvironment.", "id": "topic:abaff88702e0", "module": "01", "related_ids": [], "source_path": "pages/topics/16.01.MyJettyMicroserviceBasics.md", "source_type": "topic [...]
+{"description": "Follow these instructions to create a new template project in Eclipse.\n\n- Download the `my-jetty-microservice-9.1.0.zip` file from the downloads page (located in the binaries) and import it into your workspace as an existing project:\n\n\n\n- Select the archive file and import the project:\n\n\n\n- In your workspace, you shou [...]
+{"description": "The mjm.launch file is already provided to allow you to quickly start your new microservice.\nGo to **Run -> Run Configurations -> Java Application -> my-jetty-microservice** and click **Run**.\nIn your console view, you should see the following output:\n\n```bash\nRunning class 'JettyMicroservice' using config file 'mjm.cfg'.\nServer started on port 10000\n\nList of available commands:\n exit -- Shut down service\n restart -- Restarts service\n help -- Commands [...]
+{"description": "The pom.xml file is a basic Maven build script for creating your microservice as an executable uber-jar.\nThe easiest way to build your microservice is to run the following from the project root.\n\n```bash\nmvn clean install\n```\n\nYour `target` directory should now contain the following files:\n\n- `my-jetty-microservice-1.0.jar`\n- `mjm.cfg`\n\nTo start from a command line, run the following command from inside your `target` directory:\n\n```bash\njava -jar my-jetty- [...]
+{"description": "#### Starter Project Zip\n\nThe `my-springboot-microservice.zip` file is a predefined starter Eclipse project for developing REST microservices\nusing the [juneau-rest-server-springboot](/docs/topics/JuneauRestServerSpringbootBasics) package with Spring Boot.\n\nIt includes a combination of the Juneau Core, Server, and Client APIs and all libraries needed to execute in a Java 1.8+\nenvironment.\n\nOne significant difference is that we are not using the Juneau <a href=\"/ [...]
+{"description": "Follow these instructions to create a new template project in Eclipse.\n\n- Download the `my-springboot-microservice-9.1.0.zip` file from the downloads page (located in the binaries) and import it into your workspace as an existing project:\n\n\n\n- Select the archive file and import the project:\n\n\n\n- In your work [...]
+{"description": "The msm.launch file is already provided to allow you to quickly start your new microservice.\nGo to **Run -> Run Configurations -> Java Application -> my-springboot-microservice** and click **Run**.\nIn your console view, you should see the following output:\n\n```bash\n. ____ _ __ _ _\n/\\\\ / ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\\n( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\\n\\\\/ ___)| |_)| | | | | || (_| | ) ) ) )\n' |____| .__|_| |_|_| | [...]
+{"description": "The pom.xml file is a basic Maven build script for creating your microservice as an executable uber-jar.\nThe easiest way to build your microservice is to run the following from the project root.\n\n```bash\nmvn clean install\n```\n\nYour `target` directory should now contain the following files:\n\n- `my-springboot-microservice-1.0.jar`\n\nTo start from a command line, run the following command from inside your `target` directory:\n\n```bash\njava -jar my-springboot-mic [...]
+{"description": "The [PetStore](https://github.com/apache/juneau-petstore/blob/master/juneau-petstore-api/src/main/java/org/apache/juneau/petstore/PetStore.java) application is an functional application meant to demonstrate using Juneau with Spring Boot to create an\nend-to-end client/server REST API.\n\nWhat makes Juneau unique is the ability to create Java interfaces that behave just like RPC but using REST as the\nunderlying protocol.\n\nAnd the technology it not tied to any platform [...]
+{"description": "The Pet Store app is a Spring Boot application that can be started up by running the [App](https://github.com/apache/juneau-petstore/blob/master/juneau-petstore-server/src/main/java/org/apache/juneau/petstore/server/App.java) class.\n\nThis starts the application on port 5000.\n\nIt can also be started in a docker container using the following instructions:\n\n- Install docker on your machine.\n\n- Clone the Petstore project on your machine.\n\n```bash\ngit clone https:/ [...]
+{"description": "The [juneau-petstore-api](https://github.com/apache/juneau-petstore/tree/master/juneau-petstore-api) module contains the Java interface of our application and the DTO beans that go along with it.\n\nThese classes are meant to be shared between the server and client side code.\n\nThe [PetStore](https://github.com/apache/juneau-petstore/blob/master/juneau-petstore-api/src/main/java/org/apache/juneau/petstore/PetStore.java) class is our primary class for defining our applic [...]
+{"description": "The [juneau-petstore-client](https://github.com/apache/juneau-petstore/tree/master/juneau-petstore-client) module contains a single [Main](https://github.com/apache/juneau-petstore/blob/master/juneau-petstore-client/src/main/java/org/apache/juneau/petstore/client/Main.java) class used to instantiate the proxy against our remote REST\ninterface using the Java interface described above.\n\n#### [Main.java](https://github.com/apache/juneau-petstore/blob/master/juneau-petsto [...]
+{"description": "The [juneau-petstore-server](https://github.com/apache/juneau-petstore/tree/master/juneau-petstore-server) module contains all of the guts of the application.\nIt's a standard Spring Boot application with Juneau integration support.\n\nFor brevity, the app and configuration classes are combined into the following [App](https://github.com/apache/juneau-petstore/blob/master/juneau-petstore-server/src/main/java/org/apache/juneau/petstore/server/App.java) class:\n\n#### [App [...]
+{"description": "# juneau-examples-core\n\nThe [juneau-examples-core](https://github.com/apache/juneau/tree/master/juneau-examples/juneau-examples-core) module provides practical examples demonstrating how to use Apache Juneau's core marshalling capabilities for serialization and deserialization of Plain Old Java Objects (POJOs).\n\n## Overview\n\nThis module focuses on the fundamental serialization and deserialization features of Juneau Core, showing developers how to:\n\n- Convert POJO [...]
+{"description": "# juneau-examples-rest\n\nThe [juneau-examples-rest](https://github.com/apache/juneau/tree/master/juneau-examples/juneau-examples-rest) module provides comprehensive examples demonstrating how to build REST APIs using Apache Juneau's REST server capabilities.\n\n## Overview\n\nThis module showcases practical examples of building REST services with Juneau, including:\n\n- REST resource implementation\n- HTTP method handling\n- Request/response serialization\n- Error handl [...]
+{"description": "# juneau-examples-rest-jetty\n\nThe [juneau-examples-rest-jetty](https://github.com/apache/juneau/tree/master/juneau-examples/juneau-examples-rest-jetty) module demonstrates how to deploy Juneau REST servers using embedded Jetty server for standalone microservice applications.\n\n## Overview\n\nThis example shows how to create a lightweight, self-contained REST microservice using Apache Juneau's Jetty integration. It's perfect for scenarios where you need a standalone ap [...]
+{"description": "# juneau-examples-rest-springboot\n\nThe [juneau-examples-rest-springboot](https://github.com/apache/juneau/tree/master/juneau-examples/juneau-examples-rest-springboot) module demonstrates how to integrate Apache Juneau REST servers with Spring Boot for enterprise-grade microservice applications.\n\n## Overview\n\nThis example shows how to leverage Spring Boot's powerful features while using Juneau's REST capabilities. It demonstrates Spring Boot integration patterns, de [...]
+{"description": "Juneau provides **shaded (uber) JAR artifacts** that bundle multiple Juneau modules into single JAR files. These artifacts simplify dependency management and are especially useful for build systems like Bazel that require explicit dependency declarations.\n\n## What Are Shaded Artifacts?\n\nShaded artifacts use the [Maven Shade Plugin](https://maven.apache.org/plugins/maven-shade-plugin/) to:\n- Bundle multiple Juneau modules into a single JAR\n- Merge service provider f [...]
+{"description": "The `juneau-shaded-core` artifact bundles all core Juneau modules for general marshalling and configuration work. At 2.0 MB, it's the smallest shaded artifact and ideal for applications that don't need REST functionality.\n\n## What's Included\n\nThis artifact includes the following Juneau modules:\n\n- **juneau-commons** - Core utilities and common classes\n- **juneau-assertions** - Fluent-style assertions API\n- **juneau-bct** - Bean-Centric Testing framework\n- **june [...]
+{"description": "The `juneau-shaded-rest-client` artifact bundles all core Juneau modules plus REST client functionality. At 3.8 MB, it provides everything needed for building REST client applications.\n\n## What's Included\n\nThis artifact includes:\n\n- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)** (marshalling, config, testing)\n- **juneau-rest-common** - REST APIs common to client and server\n- **juneau-rest-client** - Full-featured REST client API\n- **jun [...]
+{"description": "The `juneau-shaded-rest-server` artifact bundles all core Juneau modules plus REST server functionality. At 3.8 MB, it provides everything needed for building REST server applications.\n\n## What's Included\n\nThis artifact includes:\n\n- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)** (marshalling, config, testing)\n- **juneau-rest-common** - REST APIs common to client and server\n- **juneau-rest-server** - Full-featured REST servlet API\n- **ju [...]
+{"description": "The `juneau-shaded-rest-server-springboot` artifact bundles REST server functionality plus Spring Boot integration. At 3.8 MB, it provides everything needed for building Juneau REST services with Spring Boot.\n\n## What's Included\n\nThis artifact includes:\n\n- **All modules from [juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer)** (core + REST server)\n- **juneau-rest-server-springboot** - Spring Boot auto-configuration and integration\n\n## Use Cases\n\n [...]
+{"description": "The `juneau-shaded-all` artifact is the complete Juneau framework bundled in a single 4.0 MB JAR file. It includes all core modules, REST client, REST server, Spring Boot integration, bean DTOs, and microservice modules.\n\n## What's Included\n\nThis artifact includes **everything**:\n\n### Core Modules\n- **juneau-commons** - Core utilities\n- **juneau-assertions** - Fluent assertions API\n- **juneau-bct** - Bean-Centric Testing framework\n- **juneau-config** - Configur [...]
+{"description": "Security is always an ongoing concern in any library.\n\nIf you discover any security vulnerabilities in this code, please refer to the instructions found here: [SECURITY](https://github.com/apache/juneau/blob/master/SECURITY.md)", "id": "topic:d97f8256180a", "module": "01", "related_ids": [], "source_path": "pages/topics/21.01.SecurityBasics.md", "source_type": "topic", "summary": "Security is always an ongoing concern in any library.", "tags": ["topic", "01"], "title": [...]
+{"description": "#### Demarshalling vulnerabilities\n\nOne common security vulnerability is the ability to create arbitrary Java object instances through crafted user input.\n\nFor example, support for constructing POJOs based on an input attribute defining a fully-qualified class name like\n`{class:'com.foo.MyBean',...}`\n\nFortunately, Juneau does not support an open-ended `class` attribute.\n\nAs a rule, it should not be possible to create arbitrary POJOs by any of the parsers.\n\nThe [...]
+{"description": "Care must be used when defining new <a href=\"/site/apidocs/org/apache/juneau/commons/svl/Var.html\" target=\"_blank\">Vars</a> using the SVL API since mistakes\ncould potentially expose system properties, environment variables, or even file system files.\n\nFor recap, the SVL support allows you to embed variables of the form `$X{key}` inside strings that get resolved to other\nstrings.\n\nThe resolved strings themselves can also contain variables that also get recursive [...]
+{"description": "Denial of service attacks can be alleviated through the <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/Rest.html#maxInput()\" target=\"_blank\">maxInput()</a> setting.\n\nArbitrarily-large input will trigger an exception before causing out-of-memory errors.\n\nThe default value for this setting is 100MB.\n\nSince the parsers do not use intermediate DOMs and instead parse directly into Java objects, deeply nested data\nstructures will almost always trigger stac [...]
+{"description": "The following guide can be used to help migrate your code to v9.0.\nNote that you can also refer to the Release Notes for changes as well.\n| Old | New |\n|-----|-----|\n| <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">@RestMethod</a> annotation. | Has been replaced with <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/RestOp.html\" target=\"_blank\">RestOp</a>, <a href=\"/site/apidocs/org/apache/juneau/rest/annotation/ [...]
+{"description": "The following guide can be used to help migrate your code to v9.5.\nNote that you can also refer to the Release Notes for changes as well.\n\nThis guide also captures breaking changes introduced during the 9.2.x line so that\nteams jumping from 9.1 (or earlier) directly to 9.5 have a single reference.\n\n| Old | New |\n|-----|-----|\n| `@Rest(allowedHeaderParams=\"NONE\")` / `@Rest(allowedMethodHeaders=\"NONE\")` / `@Rest(allowedMethodParams=\"NONE\")` \u2014 the literal [...]
+{"description": "# Test deployment Mon Sep 29 09:39:50 EDT 2025", "id": "topic:e04ccc8e339d", "module": "general", "related_ids": [], "source_path": "pages/topics/README.md", "source_type": "topic", "summary": "Test deployment Mon Sep 29 09:39:50 EDT 2025", "tags": ["topic", "general"], "title": "Test deployment Mon Sep 29 09:39:50 EDT 2025", "updated_at": "source-controlled", "version": "9.5.0"}
diff --git a/static/ai/manifest.json b/static/ai/manifest.json
new file mode 100644
index 0000000000..57c64f4493
--- /dev/null
+++ b/static/ai/manifest.json
@@ -0,0 +1,10 @@
+{
+ "generated_at": "content-hash:31615e466e43",
+ "record_count": 428,
+ "schema_version": "1.0.0",
+ "source_commit": {
+ "juneau": "aeec23af210d89c31d6c88d6c699f523c69a9ac1",
+ "juneau_docs": "79d3ab6d95ec5bbb373e62aa6980e347cb673461"
+ },
+ "version": "9.5.0"
+}
diff --git a/static/ai/taxonomy.json b/static/ai/taxonomy.json
new file mode 100644
index 0000000000..7ec57a80ba
--- /dev/null
+++ b/static/ai/taxonomy.json
@@ -0,0 +1,58 @@
+{
+ "modules": {
+ "01": 24,
+ "02": 28,
+ "03": 30,
+ "04": 35,
+ "05": 18,
+ "06": 10,
+ "07": 12,
+ "08": 9,
+ "09": 7,
+ "10": 15,
+ "11": 16,
+ "12": 4,
+ "13": 5,
+ "14": 7,
+ "15": 4,
+ "16": 10,
+ "17": 2,
+ "17a": 1,
+ "18": 7,
+ "19": 2,
+ "20": 2,
+ "21": 6,
+ "21a": 1,
+ "22": 2,
+ "23": 2,
+ "24": 7,
+ "25": 2,
+ "26": 9,
+ "27": 10,
+ "28": 2,
+ "29": 5,
+ "30": 6,
+ "31": 4,
+ "32": 4,
+ "33": 2,
+ "34": 6,
+ "35": 3,
+ "36": 1,
+ "37": 1,
+ "38": 1,
+ "39": 1,
+ "40": 1,
+ "41": 1,
+ "42": 1,
+ "Module-juneau-marshall-rdf": 1,
+ "api-metadata": 16,
+ "general": 1,
+ "release-notes": 84
+ },
+ "schema_version": "1.0.0",
+ "source_types": {
+ "api-metadata": 16,
+ "release-note": 84,
+ "topic": 328
+ }
+}