All Classes and Interfaces
Class
Description
Which declarations contribute to a component's abstractness denominator.
Content-addressed cache identity covering inputs, runtime target, options, and versions.
Opaque deterministic model bytes and whether they came from a validated cache entry.
Reviewable result of a safe cache lookup.
Trusted library-side production of a deterministic imported-model payload.
Distinct annotation relationships; no mode silently includes another.
Immutable annotation target, relationship, visibility, traversal bound, and unknown policy.
Required and forbidden annotation moods evaluated by one assertion implementation.
Annotation rules over declarations, parameters, packages, and exact type-use sites.
Immutable annotation relationship, mood, typed values, and traversal-gap policy.
Exact owner and sub-location of an annotation occurrence.
Distinct declaration and type-use locations for imported annotations.
One typed condition over an explicitly encoded annotation element.
Deterministic operations over explicitly encoded, typed annotation elements.
Class-file visibility channel, independent from runtime reflection.
Assertion failure caused by incomplete or failed analysis rather than policy violations.
Dependency-free assertions recognized naturally by JUnit Jupiter and other Java test runners.
Execution-scoped cache hook for expensive, immutable architecture imports.
Assertion failure caused by architecture policy violations, not analysis failure.
Immutable, inspectable preset that expands into ordinary architecture rules.
Explicit-selector factories for common architecture dependency directions.
Immutable architecture rule with uniform metadata decoration.
Factory for immutable rule values; later rule DSLs share this metadata behavior.
Marks a static, no-argument method that supplies one immutable architecture rule.
Framework-neutral executable case that can be adapted to a JUnit Jupiter DynamicTest.
Creates isolated executable cases for ordinary or dynamic architecture tests.
Optional JUnit Platform engine for
ArchitectureTest methods.Root namespace for the ArchUnitJava public API.
Process entry point; all testable behavior lives in
CliRunner.Honest tri-state result for hierarchy evidence.
Explicit, side-effect-free commands for freezing and proposing baseline updates.
Deterministic classification of current findings against a reviewed baseline.
Stable line-oriented baseline diff intended for code review.
Reviewable snapshot and two-part stable fingerprint for one rule violation.
Strict baseline input that is malformed, unsupported, or outside configured limits.
Bounded, dependency-free reader for the canonical reviewed-baseline JSON schema.
Canonical JSON rendering for storing a reviewed baseline in version control.
Resource limits applied before and during baseline JSON ingestion.
Proposed explicit baseline update plus its reviewable comparison.
Shared CLI operation exposed through build tools.
Clear configuration or lifecycle failure reported to the hosting build tool.
Lossless mapping from build-tool inputs to the shared CLI/library contract.
Build-host result retaining the deterministic compiled-output order.
Executes the shared contract against already-compiled outputs.
Build metadata that determined a discovered project layout.
Supported build hosts for the first-party integration bridge.
Exact bytecode evidence location with optional, non-fabricated debug metadata.
Stable input identity and byte-content digest; timestamps are intentionally absent.
Shared terminal contract for architecture rules.
Immutable policies applied uniformly by architecture-rule terminals.
Mutable construction state; built options never retain a reference to it.
Structured parser failure with resource, origin, and traversal context.
Machine-readable failures produced while reading untrusted class files.
A caller-approved source of class-file resources.
Enumerates class resources without loading target classes or following symbolic links.
Stable provenance for one class-file resource.
Reads untrusted class bytes through a model-neutral JDK Class-File API boundary.
Immutable safety bounds for reading individual class resources.
Immutable result of reading one or more class-file resources.
A class-file resource discovered at a caller-approved input.
The bounded reader phase in which a class resource failed.
Lossless JVM class-file version tuple.
Applies explicit Java lookup precedence without loading any target class.
Resource lookup namespace.
Explicit lookup mode, traversal bounds, and opt-in manifest expansion policy.
Immutable deterministic output of Java resource lookup assembly.
Resolves selected class files and gaps without class loading or runtime lookup.
Safe class-resource provenance that never contains a machine-specific absolute path.
Shared immutable output used identically by CLI and direct Java callers.
Direct Java API for the same bounded import and rule evaluation performed by the CLI.
Fully validated, immutable CLI configuration with resolved approved inputs.
Safe validation failure for declarative CLI input.
Strict bounded parser for the non-executable ArchUnitJava properties format.
Stable process outcomes shared by all CLI entry points and build integrations.
Built-in graph projections available from declarative configuration.
Supported graph report encodings.
Bounded exact or glob pattern; arbitrary regular expressions are intentionally unsupported.
Supported result report encodings.
Whitelisted declarative configuration for the supported dependency-rule subset.
Public Java API counterpart to the CLI's fixed dependency-rule mapping.
Stable command dispatcher with no process, plugin, reflection, or target-code execution hooks.
Computes LCOM only from retained instance-member bytecode evidence, never from target loading.
Cohesion policy; static members are always outside class-instance cohesion.
Formula-specific cohesion results plus only the threshold-safe computed samples.
One LCOM result with explicit evidence availability and formula population.
Explicit treatment of accesses originating in synthetic types, methods, or bridges.
Presentation-only compiler-artifact filters.
Builds presentation views without deleting bytecode evidence from hidden compiler artifacts.
Compiler-artifact flags inherited by bytecode evidence from its declaring type and member.
Source- or bytecode-oriented presentation with complete dependency evidence kept separately.
Type inventory used only for abstractness; dependency counts always come from the projection.
Deterministic type grouping for package or explicit module/classpath projections.
Robert C.
Bounded, deterministic plain-text output for people and terminal CI logs.
Exhaustive, exactly-one assignment checks over imported types, packages, or modules.
Typed-row CSV rendering of query metadata, nodes, edges, provenance, and evidence.
Lakos metrics. dependsOn includes the subject itself; CCD is their sum, ACD=CCD/N,
RACD=ACD/N, and NCCD=CCD divided by a same-size complete-level balanced binary tree's CCD.
Deterministic, graph-generic SCC and bounded elementary-cycle algorithms.
Pure cycle-analysis output, including whether diagnostic enumeration hit a bound.
Explicit resource bounds for optional elementary-cycle diagnostics.
Explicit dependency semantics and output bounds for type and package cycle rules.
Cycle-free type and package rules with induced selections and bounded representative evidence.
Deterministic D2 rendering with generated identifiers and quoted target strings.
One type dependency with every duplicate-free declaration source that supports it.
Whether a dependency comes from erased, generic-only, annotation, or relationship evidence.
Extracts declaration-only type dependencies without loading target classes.
Exact declaration that owns dependency evidence.
Declaration extraction output plus explicit normalization accounting.
One exact class-file value and owning declaration that produced a dependency.
Resource and optional source-file location for a type or declared member.
One directed, typed dependency with all duplicate-free evidence.
Provenance for one observed dependency.
An immutable graph whose nodes, edges, and evidence have canonical iteration order.
The bytecode or declaration relationship that caused a dependency.
Metrics over an explicit projection.
Projection-scoped component and cumulative metrics with threshold-ready samples.
Shared dependency assertion moods evaluated by one graph engine.
Positive and negative dependency rules over deterministic type or package projections.
Immutable dependency mood and edge-boundary policies.
Structured analysis or execution information that renderers may later turn into prose.
Match policy for a boolean JPMS directive modifier.
Qualified-target shape required of an exports or opens directive.
A selected project root and its declared or conventional compiled-output layout.
Structured project-discovery information, independent from human rendering.
Stable diagnostic categories emitted by project discovery.
Deterministic DOT rendering with quoted attributes and generated identifiers only.
One omitted raw edge and its deterministic reason.
A directed elementary cycle, stored once with its lowest stable node first.
Uniform rule-terminal response when a selector matches no subjects.
Base class for execution errors, carrying a stable code and deterministic context.
Treatment of graph targets absent from the imported type/package model.
Caller-supplied hierarchy facts for a type that was not imported.
One deterministic comparison entry, retaining both sides when a finding moved.
Adoption state assigned by comparing current findings to a reviewed baseline.
Conservative generated-code decision with reviewable supporting signals.
Opt-in classifier that deliberately cannot classify from a lone annotation.
Immutable opt-in settings for conservative generated-code classification.
Independent evidence groups used by the opt-in generated-code classifier.
Parsed generic signature of a class or interface.
Erased class hierarchy plus independently parsed optional generic evidence.
Erased field type plus independently parsed optional generic evidence.
Parsed generic signature of a method or constructor.
Erased method type plus independently parsed optional generic evidence.
Non-fatal malformed generic metadata retained alongside its erased fallback.
Strict, bounded parser for JVMS class, method, and field generic signatures.
A type expressed by a JVM generic signature, independent of its erased descriptor.
A possibly parameterized class.
One exact or wildcard generic class type argument.
A declared generic type parameter, including its class and interface bounds.
Gradle-facing entry point intended for a check task after classes/testClasses.
A node retained independently of whether any dependencies touch it.
Versioned immutable graph snapshot consumed verbatim by all report renderers.
Deterministic output bounds; omitted counts remain in snapshot metadata.
Immutable filtering and collapse query that produces one detached graph snapshot.
Indicates that graph topology refers to a node absent from the graph.
Whether a hierarchy rule inspects only declarations or the complete reachable hierarchy.
Bounded transitive hierarchy result with explicit gaps and cycle evidence.
Java hierarchy relationship kept distinct instead of being flattened into dependencies.
One direct, typed hierarchy relationship.
Direct JVM hierarchy relationship without conflating interface roles.
Positive and negative moods evaluated by the same hierarchy assertion.
Immutable relationship, traversal, mood, and unknown-ancestor policy.
Bounded self-contained HTML report with constant inline CSS/JS and escaped graph data.
Refusal to build an interactive report larger than caller-approved bounds.
Explicit bounds for self-contained interactive HTML generation.
Caller policy for packaging failures that may otherwise be collected as diagnostics.
Immutable import semantics shared by directory and archive inputs.
Stable packaging-resolution diagnostic.
Policy-selected terminal packaging failure with no target exception leakage.
Complete static import result with selected, external, and diagnostic state separated.
One immutable, reviewable include/exclude rule for a root-relative resource path.
Ordered resource-rule outcome.
Hard import boundary; later include rules cannot escape it.
Raised only when a selector's explicit unknown policy is
UnknownHierarchyPolicy.FAIL.Deterministic inheritance, implementation, assignability, and sealed-hierarchy rules.
Structured enumeration diagnostic; renderers decide how it is presented.
Machine-readable failures and exclusions produced while enumerating inputs.
Immutable safety bounds for class-file input traversal.
Immutable deterministic output of class-file input enumeration.
Reports a deterministic location and reason for malformed JVM generic metadata.
A local descriptor parse failure with the exact failing offset.
A user-supplied pattern that cannot be compiled under its declared syntax.
Rejection of input outside the bounded, non-executable PlantUML subset.
Java/JVM access classification kept separate from JPMS package exports.
Annotation type and explicitly encoded values; defaults are kept on annotation methods.
One explicitly stored annotation element.
One annotation and its exact visibility and class-file site.
Lossless annotation value vocabulary independent from the JDK parser API.
Ordered generic bootstrap argument with optional structured direct-handle data.
One field or method bytecode access with exact caller, opcode, and location.
Exact JVM opcode; no runtime dispatch target is inferred from it.
Unresolved constant-pool member target.
Typed, unresolved evidence for a relevant constant-pool entry.
Exact member and bytecode location that loaded a class literal.
Bounded typed constant-pool evidence for one imported type.
One unresolved invokedynamic call site with narrowly classified bootstrap evidence.
An unresolved dynamic constant with bounded bootstrap provenance.
Exact EnclosingMethod evidence; the method is absent when the attribute names only a class.
One exception declaration or bytecode fact, without inferred runtime types.
One library-owned InnerClasses entry; it is evidence, not inferred source nesting.
One immutable named layer; only optional layers may be empty.
Immutable declared field, method, constructor, or static initializer.
The JVM declaration role of a field or code unit.
JVM member modifiers, including compiler-oriented flags relevant to architecture analysis.
Stable owner/name/descriptor identity for an overloaded JVM member.
Unresolved direct method-handle constant used as bootstrap or implementation evidence.
Source-relevant modifiers represented by the initial type model.
Immutable module identity and its explicit, unresolved JPMS directives.
JPMS identity that never conflates explicit, automatic, and unnamed modules.
One unresolved exports or opens directive, qualified when targets are present.
One unresolved service-provider declaration.
One unresolved JPMS requires directive with its exact modifier mask.
Lexical and JVM nestmate evidence kept as separate, immutable concepts.
Aggregated Java package with metadata carriers separated from ordinary types.
Deterministic package aggregation over an imported type collection.
A named Java package or the distinct unnamed package.
Safe identity of one classpath input contributing to a package.
One descriptor parameter with optional MethodParameters name and exact flags.
JVM MethodParameters flags, including compiler-created parameter evidence.
An immutable pattern compiled once for repeated matching.
Immutable record component, distinct from its generated field and accessor.
One non-empty, immutable, deterministically ordered type group.
Caller-supplied source text; source files are never located or executed implicitly.
Immutable top-level Java type description backed only by library-owned values.
The declaration kind of an imported top-level Java type.
Canonical binary name plus honest top-level source-name derivations.
Lossless type-annotation target tag, payload, and ordered path.
Canonical JSON rendering of the versioned graph-snapshot schema.
Deterministic JUnit XML rendering with policy failures and analysis errors kept separate.
Canonical multidimensional JVM array with a non-array, non-void element type.
Strict, stateless field and method descriptor parser.
Ordered JVM method parameters and return type.
The eight non-void primitive JVM types.
A reference type identified canonically by its Java binary name.
Lossless library-owned representation of a JVM field or return type.
The JVM void return type, which is not legal as a field or parameter type.
Reusable required and optional named layer definitions.
Stable identity of a named layer, including an internal unassigned boundary identity.
Missing required layer or ambiguous membership under the configured policy.
Immutable non-overlapping named layer memberships and retained unassigned imported types.
Resolution of a type selected by multiple differently named layers.
Whether an empty resolved layer is permitted.
Named-layer access policies sharing one deterministic type/member evidence projection.
Immutable exact-name layer selection.
Supported, explicitly distinct lack-of-cohesion formulas.
One exact line-number-table transition.
Immutable deterministic line table preserving repeated lines and offsets.
A relative, forward-slash-separated class-path resource location.
Maven-facing entry point intended for the verify phase after all module outputs exist.
Negative, constrained, group-positive, and per-caller member-access policies.
Policies over exact bytecode member references without runtime dispatch inference.
Immutable access mood, independently selected opcode kinds, and compiler-artifact policy.
A field or method identity consisting of owner, JVM unqualified name, and descriptor.
Selected members with overload-safe identities and retained import diagnostics.
Immutable selectors for fields, methods, constructors, and static initializers.
Mutually exclusive declared-member visibility states.
Deterministic Mermaid rendering without directives, links, or target-controlled identifiers.
Resolves meta-annotations from imported values without loading annotation classes.
Bounded meta-annotation traversal with explicit gaps, depth limits, and cycles.
Exact decimal metric amount paired with its non-interchangeable unit.
Whether a formula was evaluated or deliberately withheld.
Direction of an inclusive metric threshold.
Stable metric identifiers with one mandatory unit each.
One deterministic metric observation for one typed architecture subject.
Threshold subject representing one complete filtered projection.
Typed inclusive threshold; construction rejects a limit expressed in the wrong unit.
Architecture rules that emit one structured violation for every subject outside a typed limit.
Units carried by metric values and limits so unlike quantities cannot be compared.
A named, inspectable policy assignment for imported JPMS module identities.
Detached comparison of declared readability and bytecode-observed module dependencies.
Pure comparison of Module-attribute requires declarations and observed graph edges.
One detached declared or observed module dependency with its evidence domain kept explicit.
JPMS Module-attribute policies, deliberately separate from observed bytecode dependencies.
JPMS export classification for a resolved cross-boundary access.
A named JPMS module.
Stable result identity that cannot collapse explicit, automatic, and unnamed modules.
Exports/opens mode with qualification and optional qualified target matching.
Requires-directive mode plus exact transitive/static-phase modifier constraints.
Negative, allow-list, or existence semantics for module descriptor declarations.
Selected JPMS descriptors with retained import/model diagnostics.
Immutable selection of explicit, automatic, or unnamed JPMS module identities.
Explicit opt-ins for subjects commonly created by compilers or generators.
Deterministic positive and negative conventions over distinct Java name/location targets.
Distinct Java naming and provenance values; each has one required pattern domain.
Explicit caller decision for automatic and unnamed modules, which have no Module attribute.
A named, inspectable policy assignment for imported Java packages.
A Java package name, including an explicit value for the unnamed package.
Selected packages without discarding diagnostics from the underlying type model.
Immutable, reusable selection of Java package aggregates.
Backend-neutral annotation descriptor and explicitly stored element values.
Default annotation value attached to one annotation-interface method.
One named annotation element value.
Exact declaration, parameter, record-component, or type-use annotation site.
Backend-neutral, lossless annotation element value.
Stable generic bootstrap argument plus an optional structured direct handle.
Backend-neutral class header extracted from an untrusted class resource.
Backend-neutral field or method access extracted from one Code attribute.
Backend-neutral typed evidence for a relevant constant-pool entry.
Member and bytecode offset that loaded a constant-pool entry.
Bounded relevant constant-pool evidence for one class file.
One invokedynamic instruction and its unresolved bootstrap evidence.
Unresolved CONSTANT_Dynamic value and its bounded bootstrap provenance.
One EnclosingMethod attribute value.
Backend-neutral exception declaration, handler, or throw instruction.
One InnerClasses table entry, retained as evidence rather than source-level truth.
Backend-neutral line-table entry using an exact bytecode offset.
Backend-neutral declared field or method extracted from a class file.
Backend-neutral direct method-handle constant.
Backend-neutral MethodParameters entry, including compiler-created flags.
Backend-neutral explicit JPMS Module attribute.
One exports or opens directive, including an empty or qualified target list.
One provides directive and all provider binary names.
One requires directive exactly as declared in a Module attribute.
Raw nesting and nestmate attributes retained without inferring source ownership.
Backend-neutral record component extracted from a Record attribute.
Immutable, deterministic metadata describing a compiled matcher.
The semantic text domain in which a pattern is evaluated.
A pattern evaluation that exceeds a documented safety boundary.
Positive and negative pattern assertions sharing one implementation.
The syntax used to construct a compiled architecture pattern.
Explicit strictness choices for diagram-to-code comparison.
Safe directed-arrow forms supported by the bounded parser.
One safely parsed component with a unique alias and display name.
Stable result identity for a diagram component alias.
Immutable deterministic output of the bounded parser.
One declared directed component edge.
Byte-stable PlantUML export of current layer or slice dependencies.
Hard parser bounds applied before and during parsing.
Non-executing parser for a deliberately small PlantUML component grammar.
Adheres selected layer or slice components to a safely parsed PlantUML graph.
One explicitly named layer selector in a transparent architecture preset.
Inspectable recipe that expands to one ordinary
ArchitectureRule.Ordinary rule shapes available to transparent presets.
Read-only, bounded discovery of explicit, Maven, and Gradle Java project roots.
Immutable bounds and caller overrides for project discovery.
Immutable project-discovery outcome with deterministic diagnostics.
Target identity domain for one deterministic graph projection.
Why a raw edge did not appear in a projected graph.
Exact raw edge selector for an explicit, reviewable exclusion.
Explicit source-to-projected identity mapping used by classpath and module views.
Immutable, pure projection value shared by package, type, member, classpath, and module views.
Projected graph plus complete accounting for omitted raw edges.
Rules that keep cross-package consumers on an explicitly approved public interface.
Declared interpretation of configured graph entry points.
Explicit dependency semantics and finding bounds for reachability rules.
Bounded graph reachability rules that never claim whole-program runtime liveness.
Supported node-collapse domains for renderer-independent graph snapshots.
Winning imported type within one lookup scope plus all conflicting definitions.
Canonical, lossless JSON rendering of architecture-rule results.
Explicit bounds for human-oriented result renderers.
Immutable, deterministically ordered results from one architecture evaluation.
Immutable reviewed baseline; creation and updates are explicit operations.
Pure rule terminal supplied with the immutable metadata that must be attached to its result.
Immutable rule metadata carried losslessly into every result and renderer.
Immutable result of one rule evaluation, with an explicit non-overlapping terminal state.
Builds the ordinary result while retaining diagnostics supplied by the shared terminal.
One named selector/count pair inspected by the shared rule terminal.
Mutually exclusive terminal states of one architecture rule evaluation.
The single empty-selection gate shared by every architecture-rule terminal.
Bounded, content-addressed analysis cache with a fixed binary envelope.
Deterministic SARIF 2.1.0 rendering with repository-relative artifact locations.
One bounded inconsistency or gap in declared sealed-hierarchy evidence.
Declared and observed evidence for one possibly sealed type.
One selected logical class resource plus every lower-precedence alternative.
Deterministic evidence that selection encountered an incomplete imported model.
Reasons a selector could not evaluate a Java semantic name completely.
Whether a selector is known without inspecting candidates or is genuinely conditional.
Stable, human-readable selector metadata used by diagnostics and later rule descriptions.
Whether an edge whose projected origin equals its target participates in a rule.
Machine-readable importance assigned to violations and diagnostics.
One parsed lower-precedence definition retained for conflict evidence.
Safe package template with one
{slice} segment and an optional final ...Builder for capture-based and explicit slice memberships.
Stable identity of one architecture slice.
Invalid or ambiguous slice membership under the requested policies.
Immutable, non-overlapping slice memberships plus explicitly retained unmatched types.
Stable resolution when one type is offered to multiple differently named slices.
Directional and pairwise independence rules over stable, non-overlapping slices.
Immutable selection of named slices for directional and pairwise rules.
One detached aggregated edge with retained source-edge and evidence counts.
Detached evidence value retained for report drill-down.
One detached collapsed node and the source nodes it represents.
Complete deterministic query and truncation metadata shared by every renderer.
Aggregate counts; missing source never removes an otherwise included type or member.
Package-qualified source identity; a bare SourceFile attribute is never treated as a path.
A sanitized source-file label, never an absolute or parent-relative path.
Physical Java line counts.
Deterministic aggregation over imported declarations and caller-supplied source text.
Explicit source-count policy.
Aggregate counts plus threshold-ready subject samples and explicit omissions.
An identifier with a typed, deterministic representation suitable for ordering.
One deterministic maximal set of mutually reachable graph nodes.
Reviewed, rationalized suppression with composable exact scope and optional expiry.
A bytecode member reference that deliberately does not claim a resolved runtime declaration.
Whether evidence owned only by synthetic types, synthetic members, or bridge methods is used.
An unexpected infrastructure or analysis failure that prevented a reliable rule result.
A named, inspectable policy assignment for imported Java types.
Immutable hierarchy resolver that never loads classes and never guesses across gaps.
A JVM type identified by its Java binary name (for example
p.Outer$Inner).Converts backend-neutral class headers into immutable Java type descriptions.
Structured type-model adaptation diagnostic.
Machine-readable failures while adapting parsed class headers into Java types.
Immutable type-model output, retaining reader and adaptation diagnostics separately.
Package ownership for a top-level type; an empty name denotes the unnamed package.
Selects which class-file evidence contributes referenced types to a later rule.
Selected types plus the import and selector diagnostics needed to interpret the result.
Immutable, reusable selection of imported Java types.
Whether declaration/signature and other non-call type-use edges participate in cycle rules.
Legal top-level type visibility states in a class file.
Treatment of a meta-annotation or inherited-annotation traversal gap.
Caller-selected treatment of a semantic match that incomplete model evidence cannot decide.
Policy for a transitive conclusion whose external inheritance is not fully known.
Treatment of Java dependencies whose other endpoint has no diagram component.
Treatment of imported types that no capture pattern or explicit selector assigns.
Invalid user input or API usage that can be corrected without changing the analyzer.
Structured architecture-rule failure data, with no renderer-owned prose.
Stable machine identity for a violation, independent of rendered prose.
A typed architecture subject and its machine-readable role in a violation.