🥮 mooncakes.io

moonbit-brandbook

Import, audit, benchmark, and export production-ready brand systems from MoonBit design tokens.

brand
design-system
markdown
html
generator
moon add cyypyhon123/moonbit-brandbook@0.2.1
Download zip
Version
0.2.1
License
Apache-2.0
Repository
Last updated
4 hours ago
Downloads
3

Dependencies

README

#moonbit-brandbook

moonbit-brandbook is a MoonBit library and CLI for turning structured design tokens into a reviewable, portable brand system. It combines JSON/YAML import, schema and accessibility audits, deterministic Markdown/HTML/CSS/theme exports, and a measurable validation pipeline.

#Project positioning

The project sits between a design-token source of truth and the documentation and code artifacts consumed by product teams. Its core promise is traceability: semantic tokens, component contracts, asset rules, and rendered guides are handled by one typed pipeline.

#Core capabilities

  • Parse a strict, useful subset of JSON and YAML with source diagnostics.
  • Model semantic colors, typography, assets, components, misuse rules, aliases, and token provenance.
  • Run schema, contrast, asset-safety, typography-rhythm, content, and component contract audits with actionable findings.
  • Export Markdown, static HTML, CSS custom properties, theme JSON/YAML, Tailwind-compatible tokens, Figma-style tokens, and an artifact manifest.
  • Generate deterministic light/dark/minimal templates, theme diffs, catalog queries, release readiness checks, and a real parser/render benchmark.

#Quick start

moon update
moon run cmd/main -- demo
moon run cmd/main -- benchmark
moon test --target all

///|
test {
  let book = moonbit_brandbook()
  let report = book.validate_with_policy(ValidationPolicy::strict())
  assert_false(report.has_errors())
  assert_true(book.to_theme_json().contains("colors"))
}

#CLI

moon run cmd/main -- help
moon run cmd/main -- demo --format html
moon run cmd/main -- validate --input examples/brandbook.json
moon run cmd/main -- render --format tailwind --text <document>
moon run cmd/main -- render --format html --input examples/brandbook.json --output _build/brandbook.html
moon run cmd/main -- benchmark

--text and --input are mutually exclusive. File input is UTF-8 JSON/YAML; --output writes the rendered artifact instead of standard output. Validation and rendering errors return a non-zero process exit code.

#Architecture

input -> parser + diagnostics -> BrandBook -> audits -> RenderBundle ->exporters. The root package is reusable; cmd/main is a thin CLI adapter.

#Benchmark

See docs/benchmarks/latest.md for the latest measured small/medium/large parser and renderer run. Values are clock units from moonbitlang/core/env.now() and must be rerun for a different machine.

#Testing and CI

moon fmt --check
moon check --deny-warn --target all
moon test --deny-warn --target all
moon test --enable-coverage --target native
moon coverage report -f summary
moon info
git diff --exit-code

GitHub Actions runs these gates on Ubuntu, macOS, and Windows. Publishing is a manual workflow that runs the preflight before moon publish.

#License

Apache-2.0. See LICENSE.

#
AccessibilityPolicy

source
pub struct AccessibilityPolicy {
  normal_min_x100 : Int
  large_min_x100 : Int
  error_below_x100 : Int
  require_text_surface_pairs : Bool
} derive(Eq, 
Debug)

#
AccessibilityPolicy::for_thresholds

source
fn AccessibilityPolicy::for_thresholds(normal_min_x100 : Int, large_min_x100 : Int) -> AccessibilityPolicy

#
AccessibilityPolicy::wcag_aa

source

#
AccessibilityPolicy::wcag_aaa

source

#
ApiContract

source
pub struct ApiContract {
  module_name : String
  version : String
  entries : Array[ApiEntry]
} derive(Eq, 
Debug)

#
ApiContract::brandbook

source
fn ApiContract::brandbook() -> ApiContract

#
ApiContract::contains

source
fn ApiContract::contains(self : ApiContract, name : String) -> Bool

#
ApiContract::entry

source
fn ApiContract::entry(self : ApiContract, name : String) -> ApiEntry?

#
ApiContract::kinds

source
fn ApiContract::kinds(self : ApiContract) -> Array[String]

#
ApiContract::len

source
fn ApiContract::len(self : ApiContract) -> Int

#
ApiContract::names

source
fn ApiContract::names(self : ApiContract) -> Array[String]

#
ApiContract::release_notes

source
fn ApiContract::release_notes(self : ApiContract, previous : ApiContract) -> Array[String]

#
ApiContract::to_json

source
fn ApiContract::to_json(self : ApiContract) -> String

#
ApiContract::to_markdown

source
fn ApiContract::to_markdown(self : ApiContract) -> String

#
ApiEntry

source
pub struct ApiEntry {
  name : String
  kind : String
  description : String
  since : String
} derive(Eq, 
Debug)

A small machine-readable description of the stable public surface.

#
ApiEntry::new

source
fn ApiEntry::new(name : String, kind : String, description : String, since : String) -> ApiEntry

#
ApiEntry::to_json

source
fn ApiEntry::to_json(self : ApiEntry) -> String

#
ApiEntry::to_markdown

source
fn ApiEntry::to_markdown(self : ApiEntry) -> String

#
AssetPolicy

source
pub struct AssetPolicy {
  allowed_extensions : Array[String]
  min_width_px : Int
  max_path_length : Int
  reject_parent_segments : Bool
  require_primary_asset : Bool
} derive(Eq, 
Debug)

#
AssetPolicy::default

source
fn AssetPolicy::default() -> AssetPolicy

#
AssetPolicy::strict

source
fn AssetPolicy::strict() -> AssetPolicy

#
AssetPolicy::with_min_width

source
fn AssetPolicy::with_min_width(self : AssetPolicy, width : Int) -> AssetPolicy

#
AssetSet

source
pub struct AssetSet {
  primary_logo : Logo
  alternate_logos : Array[Logo]
  imagery_style : String
} derive(Eq, 
Debug)

#
AssetSet::all_paths

source
fn AssetSet::all_paths(self : AssetSet) -> Array[String]

#
AssetSet::audit

source
fn AssetSet::audit(self : AssetSet, policy : AssetPolicy) -> AuditReport

#
AssetSet::to_asset_index

source
fn AssetSet::to_asset_index(self : AssetSet) -> String

#
AssetSet::to_asset_manifest

source
fn AssetSet::to_asset_manifest(self : AssetSet) -> String

#
AssetSet::to_html

source
fn AssetSet::to_html(self : AssetSet) -> String

#
AuditReport

source
pub struct AuditReport {
  findings : Array[Finding]
} derive(Eq, 
Debug)

#
AuditReport::contains_path

source
fn AuditReport::contains_path(self : AuditReport, path : String) -> Bool

#
AuditReport::error_count

source
fn AuditReport::error_count(self : AuditReport) -> Int

#
AuditReport::from_findings

source
fn AuditReport::from_findings(findings : Array[Finding]) -> AuditReport

#
AuditReport::has_errors

source
fn AuditReport::has_errors(self : AuditReport) -> Bool

#
AuditReport::info_count

source
fn AuditReport::info_count(self : AuditReport) -> Int

#
AuditReport::paths

source
fn AuditReport::paths(self : AuditReport) -> Array[String]

#
AuditReport::summary

source
fn AuditReport::summary(self : AuditReport) -> String

#
AuditReport::to_markdown

source
fn AuditReport::to_markdown(self : AuditReport) -> String

#
AuditReport::warning_count

source
fn AuditReport::warning_count(self : AuditReport) -> Int

#
BackgroundRule

source
pub enum BackgroundRule {
  LightOnly
  DarkOnly
  LightOrDark
  Monochrome
} derive(Eq, 
Debug)

#
BackgroundRule::describe

source
fn BackgroundRule::describe(self : BackgroundRule) -> String

#
BackgroundRule::light_or_dark

source
fn BackgroundRule::light_or_dark() -> BackgroundRule

#
BenchmarkMeasurement

source
pub struct BenchmarkMeasurement {
  name : String
  operations : Int
  token_count : Int
  input_bytes : Int
  output_bytes : Int
  elapsed_units : UInt64
} derive(Eq, 
Debug)

#
BenchmarkReport

source
pub struct BenchmarkReport {
  toolchain : String
  measurements : Array[BenchmarkMeasurement]
} derive(Eq, 
Debug)

#
BenchmarkReport::is_comparable

source
fn BenchmarkReport::is_comparable(self : BenchmarkReport) -> Bool

#
BenchmarkReport::largest_input

source

#
BenchmarkReport::measurement_named

source
fn BenchmarkReport::measurement_named(self : BenchmarkReport, name : String) -> BenchmarkMeasurement?

#
BenchmarkReport::scenario_names

source
fn BenchmarkReport::scenario_names(self : BenchmarkReport) -> Array[String]

#
BenchmarkReport::slowest

source

#
BenchmarkReport::summary

source

#
BenchmarkReport::summary_json

source
fn BenchmarkReport::summary_json(self : BenchmarkReport) -> String

#
BenchmarkReport::summary_markdown

source
fn BenchmarkReport::summary_markdown(self : BenchmarkReport) -> String

#
BenchmarkReport::to_markdown

source
fn BenchmarkReport::to_markdown(self : BenchmarkReport) -> String

#
BenchmarkSummary

source
pub struct BenchmarkSummary {
  scenarios : Int
  total_operations : Int
  total_tokens : Int
  total_input_bytes : Int
  total_output_bytes : Int
  total_elapsed_units : UInt64
  fastest_scenario : String
  largest_scenario : String
} derive(Eq, 
Debug)

Derived benchmark statistics used in human-readable performance reports.

#
BenchmarkSummary::average_input_bytes

source
fn BenchmarkSummary::average_input_bytes(self : BenchmarkSummary) -> Int

#
BenchmarkSummary::average_output_bytes

source
fn BenchmarkSummary::average_output_bytes(self : BenchmarkSummary) -> Int

#
BenchmarkSummary::average_tokens

source
fn BenchmarkSummary::average_tokens(self : BenchmarkSummary) -> Int

#
BenchmarkSummary::is_measured

source
fn BenchmarkSummary::is_measured(self : BenchmarkSummary) -> Bool

#
BenchmarkSummary::output_expansion_percent

source
fn BenchmarkSummary::output_expansion_percent(self : BenchmarkSummary) -> Int

#
BenchmarkSummary::to_json

source
fn BenchmarkSummary::to_json(self : BenchmarkSummary) -> String

#
BenchmarkSummary::to_markdown

source
fn BenchmarkSummary::to_markdown(self : BenchmarkSummary) -> String

#
BoundaryCase

source
pub struct BoundaryCase {
  name : String
  input : String
  expected_valid : Bool
  focus : String
} derive(Eq, 
Debug)

Reusable boundary cases for callers that want a predictable preflight suite.

#
BoundaryCase::is_empty

source
fn BoundaryCase::is_empty(self : BoundaryCase) -> Bool

#
BoundaryCase::new

source
fn BoundaryCase::new(name : String, input : String, expected_valid : Bool, focus : String) -> BoundaryCase

#
BoundaryCase::to_markdown

source
fn BoundaryCase::to_markdown(self : BoundaryCase) -> String

#
BoundaryResult

source
pub struct BoundaryResult {
  case_name : String
  expected_valid : Bool
  actual_valid : Bool
  diagnostics : String
} derive(Eq, 
Debug)

#
BoundaryResult::passed

source
fn BoundaryResult::passed(self : BoundaryResult) -> Bool

#
BoundaryResult::to_markdown

source
fn BoundaryResult::to_markdown(self : BoundaryResult) -> String

#
BoundarySuite

source
pub struct BoundarySuite {
  name : String
  cases : Array[BoundaryCase]
} derive(Eq, 
Debug)

#
BoundarySuite::case_names

source
fn BoundarySuite::case_names(self : BoundarySuite) -> Array[String]

#
BoundarySuite::document_edges

source
fn BoundarySuite::document_edges() -> BoundarySuite

#
BoundarySuite::failures

source

#
BoundarySuite::len

source
fn BoundarySuite::len(self : BoundarySuite) -> Int

#
BoundarySuite::new

source
fn BoundarySuite::new(name : String, cases : Array[BoundaryCase]) -> BoundarySuite

#
BoundarySuite::parser_edges

source
fn BoundarySuite::parser_edges() -> BoundarySuite

#
BoundarySuite::passed

source
fn BoundarySuite::passed(self : BoundarySuite) -> Bool

#
BoundarySuite::run

source

#
BoundarySuite::to_json

source
fn BoundarySuite::to_json(self : BoundarySuite) -> String

#
BoundarySuite::to_markdown

source
fn BoundarySuite::to_markdown(self : BoundarySuite) -> String

#
BrandBook

source
pub struct BrandBook {
  name : String
  tagline : String
  voice : Voice
  assets : AssetSet
  palette : Palette
  typography : Typography
  components : Array[ComponentSpec]
  forbidden : Array[MisuseRule]
  metadata : Meta
} derive(Eq, 
Debug)

#
BrandBook::accessibility_score

source
fn BrandBook::accessibility_score(self : BrandBook) -> Int

#
BrandBook::asset_health

source
fn BrandBook::asset_health(self : BrandBook) -> Int

#
BrandBook::audit

source
fn BrandBook::audit(self : BrandBook) -> AuditReport

#
BrandBook::audit_components

source
fn BrandBook::audit_components(self : BrandBook, policy : ComponentPolicy) -> AuditReport

#
BrandBook::audit_content

source
fn BrandBook::audit_content(self : BrandBook, policy : ContentPolicy) -> ContentReport

#
BrandBook::component_contracts_markdown

source
fn BrandBook::component_contracts_markdown(self : BrandBook) -> String

#
BrandBook::component_names

source
fn BrandBook::component_names(self : BrandBook) -> Array[String]

#
BrandBook::component_score

source
fn BrandBook::component_score(self : BrandBook) -> Int

#
BrandBook::component_state_names

source
fn BrandBook::component_state_names(self : BrandBook) -> Array[String]

#
BrandBook::component_token_names

source
fn BrandBook::component_token_names(self : BrandBook) -> Array[String]

#
BrandBook::components_using_token

source
fn BrandBook::components_using_token(self : BrandBook, token : String) -> Array[String]

#
BrandBook::content_is_ready

source
fn BrandBook::content_is_ready(self : BrandBook) -> Bool

#
BrandBook::content_json

source
fn BrandBook::content_json(self : BrandBook) -> String

#
BrandBook::content_markdown

source
fn BrandBook::content_markdown(self : BrandBook) -> String

#
BrandBook::content_score

source
fn BrandBook::content_score(self : BrandBook) -> Int

#
BrandBook::diff_theme

source
fn BrandBook::diff_theme(self : BrandBook, other : BrandBook) -> ThemeDiff

#
BrandBook::export_manifest_json

source
fn BrandBook::export_manifest_json(self : BrandBook) -> String

#
BrandBook::export_manifest_markdown

source
fn BrandBook::export_manifest_markdown(self : BrandBook) -> String

#
BrandBook::find_component

source
fn BrandBook::find_component(self : BrandBook, name : String) -> ComponentSpec?

#
BrandBook::find_components_by_state

source
fn BrandBook::find_components_by_state(self : BrandBook, state : String) -> Array[ComponentSpec]

#
BrandBook::find_components_by_token

source
fn BrandBook::find_components_by_token(self : BrandBook, token : String) -> Array[ComponentSpec]

#
BrandBook::find_misuse

source
fn BrandBook::find_misuse(self : BrandBook, title : String) -> MisuseRule?

#
BrandBook::guide_outline

source
fn BrandBook::guide_outline(self : BrandBook) -> GuideOutline

#
BrandBook::guide_toc

source
fn BrandBook::guide_toc(self : BrandBook) -> String

#
BrandBook::is_publishable

source
fn BrandBook::is_publishable(self : BrandBook) -> Bool

#
BrandBook::is_release_ready

source
fn BrandBook::is_release_ready(self : BrandBook) -> Bool

#
BrandBook::missing_references

source
fn BrandBook::missing_references(self : BrandBook) -> Array[String]

#
BrandBook::misuse_titles

source
fn BrandBook::misuse_titles(self : BrandBook) -> Array[String]

#
BrandBook::pipeline

source
fn BrandBook::pipeline(self : BrandBook) -> PipelineResult

#
BrandBook::principles

source
fn BrandBook::principles(self : BrandBook) -> Array[String]

#
BrandBook::quality_score

source
fn BrandBook::quality_score(self : BrandBook) -> Int

#
BrandBook::reference_graph

source
fn BrandBook::reference_graph(self : BrandBook) -> ReferenceGraph

#
BrandBook::release_markdown

source
fn BrandBook::release_markdown(self : BrandBook) -> String

#
BrandBook::release_report

source
fn BrandBook::release_report(self : BrandBook, policy : ReleasePolicy) -> ReleaseReport

#
BrandBook::render_bundle

source
fn BrandBook::render_bundle(self : BrandBook) -> RenderBundle

#
BrandBook::render_code_examples

source
fn BrandBook::render_code_examples(self : BrandBook) -> String

#
BrandBook::render_color_section

source
fn BrandBook::render_color_section(self : BrandBook) -> String

#
BrandBook::render_component_catalog

source
fn BrandBook::render_component_catalog(self : BrandBook) -> String

#
BrandBook::render_component_section

source
fn BrandBook::render_component_section(self : BrandBook) -> String

#
BrandBook::render_css_layers

source
fn BrandBook::render_css_layers(self : BrandBook) -> String

#
BrandBook::render_css_reset

source
fn BrandBook::render_css_reset() -> String

#
BrandBook::render_full_markdown

source
fn BrandBook::render_full_markdown(self : BrandBook) -> String

#
BrandBook::render_html_accessibility_panel

source
fn BrandBook::render_html_accessibility_panel(self : BrandBook) -> String

#
BrandBook::render_html_component_catalog

source
fn BrandBook::render_html_component_catalog(self : BrandBook) -> String

#
BrandBook::render_html_manifest_panel

source
fn BrandBook::render_html_manifest_panel(self : BrandBook) -> String

#
BrandBook::render_html_reference_tables

source
fn BrandBook::render_html_reference_tables(self : BrandBook) -> String

#
BrandBook::render_html_theme_panel

source
fn BrandBook::render_html_theme_panel(self : BrandBook) -> String

#
BrandBook::render_html_voice_panel

source
fn BrandBook::render_html_voice_panel(self : BrandBook) -> String

#
BrandBook::render_json_example

source
fn BrandBook::render_json_example(self : BrandBook) -> String

#
BrandBook::render_logo_section

source
fn BrandBook::render_logo_section(self : BrandBook) -> String

#
BrandBook::render_metadata_panel

source
fn BrandBook::render_metadata_panel(self : BrandBook) -> String

#
BrandBook::render_misuse_section

source
fn BrandBook::render_misuse_section(self : BrandBook) -> String

#
BrandBook::render_reference_tables

source
fn BrandBook::render_reference_tables(self : BrandBook) -> String

#
BrandBook::render_section

source
fn BrandBook::render_section(self : BrandBook, section : String) -> String

#
BrandBook::render_typography_section

source
fn BrandBook::render_typography_section(self : BrandBook) -> String

#
BrandBook::render_voice_section

source
fn BrandBook::render_voice_section(self : BrandBook) -> String

#
BrandBook::render_yaml_example

source
fn BrandBook::render_yaml_example(self : BrandBook) -> String

#
BrandBook::search_tokens

source
fn BrandBook::search_tokens(self : BrandBook, query : String) -> Array[CatalogEntry]

#
BrandBook::theme_document

source
fn BrandBook::theme_document(self : BrandBook) -> ThemeDocument

#
BrandBook::to_accessibility_markdown

source
fn BrandBook::to_accessibility_markdown(self : BrandBook) -> String

#
BrandBook::to_css

source
fn BrandBook::to_css(self : BrandBook) -> String

#
BrandBook::to_figma_tokens

source
fn BrandBook::to_figma_tokens(self : BrandBook) -> String

#
BrandBook::to_html

source
fn BrandBook::to_html(self : BrandBook) -> String

#
BrandBook::to_html_navigation

source
fn BrandBook::to_html_navigation(self : BrandBook) -> String

#
BrandBook::to_markdown

source
fn BrandBook::to_markdown(self : BrandBook) -> String

#
BrandBook::to_markdown_toc

source
fn BrandBook::to_markdown_toc(self : BrandBook) -> String

#
BrandBook::to_tailwind_theme

source
fn BrandBook::to_tailwind_theme(self : BrandBook) -> String

#
BrandBook::to_theme_json

source
fn BrandBook::to_theme_json(self : BrandBook) -> String

#
BrandBook::to_theme_yaml

source
fn BrandBook::to_theme_yaml(self : BrandBook) -> String

#
BrandBook::token_catalog_markdown

source
fn BrandBook::token_catalog_markdown(self : BrandBook) -> String

#
BrandBook::token_catalog_stats

source
fn BrandBook::token_catalog_stats(self : BrandBook) -> CatalogStats

#
BrandBook::validate_with_policy

source
fn BrandBook::validate_with_policy(self : BrandBook, policy : ValidationPolicy) -> AuditReport

#
BrandDocumentResult

source
pub struct BrandDocumentResult {
  value : BrandBook?
  diagnostics : DiagnosticBag
} derive(Eq, 
Debug)

#
BrandQualityReport

source
pub struct BrandQualityReport {
  score : Int
  dimensions : Array[QualityDimension]
  audit : AuditReport
} derive(Eq, 
Debug)

#
BrandQualityReport::action_items

source
fn BrandQualityReport::action_items(self : BrandQualityReport) -> Array[String]

#
BrandQualityReport::audit_markdown

source
fn BrandQualityReport::audit_markdown(self : BrandQualityReport) -> String

#
BrandQualityReport::dimension

source
fn BrandQualityReport::dimension(self : BrandQualityReport, name : String) -> QualityDimension?

#
BrandQualityReport::dimension_names

source
fn BrandQualityReport::dimension_names(self : BrandQualityReport) -> Array[String]

#
BrandQualityReport::from_brand_book

source
fn BrandQualityReport::from_brand_book(book : BrandBook) -> BrandQualityReport

#
BrandQualityReport::passed

source
fn BrandQualityReport::passed(self : BrandQualityReport, threshold : Int) -> Bool

#
BrandQualityReport::score_label

source
fn BrandQualityReport::score_label(self : BrandQualityReport) -> String

#
BrandQualityReport::strongest_dimension

source
fn BrandQualityReport::strongest_dimension(self : BrandQualityReport) -> QualityDimension?

#
BrandQualityReport::to_badges

source
fn BrandQualityReport::to_badges(self : BrandQualityReport) -> Array[String]

#
BrandQualityReport::to_json

source
fn BrandQualityReport::to_json(self : BrandQualityReport) -> String

#
BrandQualityReport::to_markdown

source
fn BrandQualityReport::to_markdown(self : BrandQualityReport) -> String

#
BrandQualityReport::weakest_dimension

source
fn BrandQualityReport::weakest_dimension(self : BrandQualityReport) -> QualityDimension?

#
BrandTemplate

source
pub struct BrandTemplate {
  name : String
  description : String
  tags : Array[String]
} derive(Eq, 
Debug)

Deterministic, reusable starter brand books for examples and integration tests.

#
BrandTemplate::dark_variant

source
fn BrandTemplate::dark_variant(book : BrandBook) -> BrandBook

#
BrandTemplate::describe

source
fn BrandTemplate::describe() -> String

#
BrandTemplate::is_named

source
fn BrandTemplate::is_named(self : BrandTemplate, name : String) -> Bool

#
BrandTemplate::light_variant

source
fn BrandTemplate::light_variant(book : BrandBook) -> BrandBook

#
BrandTemplate::metadata

source
fn BrandTemplate::metadata() -> BrandTemplate

#
BrandTemplate::minimal

source
fn BrandTemplate::minimal() -> BrandBook

#
BrandTemplate::new

source
fn BrandTemplate::new(name : String, description : String, tags : Array[String]) -> BrandTemplate

#
BrandTemplate::tagged

source
fn BrandTemplate::tagged(self : BrandTemplate, tag : String) -> Bool

#
BrandTemplate::template_names

source
fn BrandTemplate::template_names() -> Array[String]

#
BrandTemplate::to_json

source
fn BrandTemplate::to_json(self : BrandTemplate) -> String

#
BrandTemplate::to_markdown

source
fn BrandTemplate::to_markdown(self : BrandTemplate) -> String

#
BrandTemplate::with_accent

source
fn BrandTemplate::with_accent(book : BrandBook, name : String, value : String, role : String) -> BrandBook

#
BrandTemplate::with_name

source
fn BrandTemplate::with_name(book : BrandBook, name : String) -> BrandBook

#
BrandTemplate::with_palette

source
fn BrandTemplate::with_palette(book : BrandBook, palette : Palette) -> BrandBook

#
BrandTemplate::with_tagline

source
fn BrandTemplate::with_tagline(book : BrandBook, tagline : String) -> BrandBook

#
CatalogEntry

source
pub struct CatalogEntry {
  path : String
  name : String
  kind : TokenKind
  value : ThemeValue
  description : String
} derive(Eq, 
Debug)

#
CatalogEntry::from_theme_token

source
fn CatalogEntry::from_theme_token(token : ThemeToken) -> CatalogEntry

#
CatalogStats

source
pub struct CatalogStats {
  total : Int
  color_count : Int
  number_count : Int
  text_count : Int
  boolean_count : Int
  described_count : Int
} derive(Eq, 
Debug)

#
CatalogStats::documentation_rate

source
fn CatalogStats::documentation_rate(self : CatalogStats) -> Int

#
CatalogStats::summary

source
fn CatalogStats::summary(self : CatalogStats) -> String

#
CliCommand

source
pub enum CliCommand {
  Help
  Version
  Demo
  Validate
  Render
  Benchmark
} derive(Eq, 
Debug)

#
CliCommand::render

source
fn CliCommand::render() -> CliCommand

#
CliFormat

source
pub enum CliFormat {
  Markdown
  Html
  Css
  Json
  Yaml
  Tailwind
  Figma
} derive(Eq, 
Debug)

#
CliFormat::css

source
fn CliFormat::css() -> CliFormat

#
CliFormat::figma

source
fn CliFormat::figma() -> CliFormat

#
CliFormat::html

source
fn CliFormat::html() -> CliFormat

#
CliFormat::json

source
fn CliFormat::json() -> CliFormat

#
CliFormat::markdown

source
fn CliFormat::markdown() -> CliFormat

#
CliFormat::tailwind

source
fn CliFormat::tailwind() -> CliFormat

#
CliFormat::yaml

source
fn CliFormat::yaml() -> CliFormat

#
CliParseResult

source
pub struct CliParseResult {
  request : CliRequest?
  errors : Array[String]
} derive(Eq, 
Debug)

#
CliRequest

source
pub struct CliRequest {
  command : CliCommand
  format : CliFormat
  input : String
  input_path : String
  output : String
} derive(Eq, 
Debug)

#
CliRequest::new

source
fn CliRequest::new(command : CliCommand, format : CliFormat, input : String, output : String) -> CliRequest

#
CliResult

source
pub struct CliResult {
  output : String
  errors : Array[String]
  exit_code : Int
} derive(Eq, 
Debug)

#
ColorToken

source
pub struct ColorToken {
  name : String
  value : String
  role : String
} derive(Eq, 
Debug)

#
ColorToken::blend_with

source
fn ColorToken::blend_with(self : ColorToken, other : ColorToken, percent : Int) -> ColorToken

#
ColorToken::can_be_text_on

source
fn ColorToken::can_be_text_on(self : ColorToken, background : ColorToken) -> Bool

#
ColorToken::contrast_against

source
fn ColorToken::contrast_against(self : ColorToken, background : ColorToken) -> ContrastPair

#
ColorToken::css_var

source
fn ColorToken::css_var(self : ColorToken) -> String

#
ColorToken::darken

source
fn ColorToken::darken(self : ColorToken, percent : Int) -> ColorToken

#
ColorToken::hex

source
fn ColorToken::hex(name : String, value : String, role~ : String) -> ColorToken

#
ColorToken::is_dark

source
fn ColorToken::is_dark(self : ColorToken) -> Bool

#
ColorToken::is_light

source
fn ColorToken::is_light(self : ColorToken) -> Bool

#
ColorToken::lighten

source
fn ColorToken::lighten(self : ColorToken, percent : Int) -> ColorToken

#
ColorToken::relative_luminance_x10000

source
fn ColorToken::relative_luminance_x10000(self : ColorToken) -> Int

#
ColorToken::rgb

source
fn ColorToken::rgb(self : ColorToken) -> RgbColor?

#
ComponentPolicy

source
pub struct ComponentPolicy {
  min_anatomy_parts : Int
  min_states : Int
  min_tokens : Int
  require_purpose : Bool
  require_focus_state : Bool
  require_disabled_state : Bool
} derive(Eq, 
Debug)

Validation policy for component contracts.

#
ComponentPolicy::default

source

#
ComponentPolicy::requiring_disabled

source
fn ComponentPolicy::requiring_disabled(self : ComponentPolicy, required : Bool) -> ComponentPolicy

#
ComponentPolicy::requiring_focus

source
fn ComponentPolicy::requiring_focus(self : ComponentPolicy, required : Bool) -> ComponentPolicy

#
ComponentPolicy::strict

source

#
ComponentPolicy::with_minimums

source
fn ComponentPolicy::with_minimums(self : ComponentPolicy, anatomy : Int, states : Int, tokens : Int) -> ComponentPolicy

#
ComponentSpec

source
pub struct ComponentSpec {
  name : String
  purpose : String
  anatomy : Array[String]
  tokens : Array[String]
  states : Array[String]
} derive(Eq, 
Debug)

#
ComponentSpec::anatomy_names

source
fn ComponentSpec::anatomy_names(self : ComponentSpec) -> Array[String]

#
ComponentSpec::audit

source
fn ComponentSpec::audit(self : ComponentSpec, policy : ComponentPolicy, path : String) -> AuditReport

#
ComponentSpec::contract_json

source
fn ComponentSpec::contract_json(self : ComponentSpec) -> String

#
ComponentSpec::contract_markdown

source
fn ComponentSpec::contract_markdown(self : ComponentSpec) -> String

#
ComponentSpec::has_state

source
fn ComponentSpec::has_state(self : ComponentSpec, state : String) -> Bool

#
ComponentSpec::has_token

source
fn ComponentSpec::has_token(self : ComponentSpec, token : String) -> Bool

#
ComponentSpec::is_documented

source
fn ComponentSpec::is_documented(self : ComponentSpec) -> Bool

#
ComponentSpec::quality_score

source
fn ComponentSpec::quality_score(self : ComponentSpec) -> Int

#
ComponentSpec::render_anatomy_list

source
fn ComponentSpec::render_anatomy_list(self : ComponentSpec) -> String

#
ComponentSpec::render_state_matrix

source
fn ComponentSpec::render_state_matrix(self : ComponentSpec) -> String

#
ComponentSpec::render_token_checklist

source
fn ComponentSpec::render_token_checklist(self : ComponentSpec) -> String

#
ComponentSpec::render_usage_card

source
fn ComponentSpec::render_usage_card(self : ComponentSpec) -> String

#
ComponentSpec::slug

source
fn ComponentSpec::slug(self : ComponentSpec) -> String

#
ComponentSpec::state_matrix

source
fn ComponentSpec::state_matrix(self : ComponentSpec) -> Array[String]

#
ComponentSpec::state_names

source
fn ComponentSpec::state_names(self : ComponentSpec) -> Array[String]

#
ComponentSpec::to_html

source
fn ComponentSpec::to_html(self : ComponentSpec) -> String

#
ComponentSpec::to_html_card

source
fn ComponentSpec::to_html_card(self : ComponentSpec) -> String

#
ComponentSpec::to_html_state_list

source
fn ComponentSpec::to_html_state_list(self : ComponentSpec) -> String

#
ComponentSpec::to_markdown

source
fn ComponentSpec::to_markdown(self : ComponentSpec) -> String

#
ComponentSpec::token_names

source
fn ComponentSpec::token_names(self : ComponentSpec) -> Array[String]

#
ComponentSpec::token_usage

source
fn ComponentSpec::token_usage(self : ComponentSpec, token : String) -> String

#
ContentPolicy

source
pub struct ContentPolicy {
  min_principles : Int
  min_misuse_rules : Int
  require_imagery_guidance : Bool
  require_tagline : Bool
  forbid_placeholder_words : Bool
} derive(Eq, 
Debug)

A focused content-health check for brand guidance that is not captured by token schema validation alone.

#
ContentPolicy::allowing_placeholders

source
fn ContentPolicy::allowing_placeholders(self : ContentPolicy, allowed : Bool) -> ContentPolicy

#
ContentPolicy::default

source
fn ContentPolicy::default() -> ContentPolicy

#
ContentPolicy::requiring_imagery

source
fn ContentPolicy::requiring_imagery(self : ContentPolicy, required : Bool) -> ContentPolicy

#
ContentPolicy::strict

source

#
ContentPolicy::with_minimums

source
fn ContentPolicy::with_minimums(self : ContentPolicy, principles : Int, misuse_rules : Int) -> ContentPolicy

#
ContentReport

source
pub struct ContentReport {
  score : Int
  findings : Array[Finding]
  suggestions : Array[String]
} derive(Eq, 
Debug)

#
ContentReport::has_errors

source
fn ContentReport::has_errors(self : ContentReport) -> Bool

#
ContentReport::summary

source
fn ContentReport::summary(self : ContentReport) -> String

#
ContentReport::to_json

source
fn ContentReport::to_json(self : ContentReport) -> String

#
ContentReport::to_markdown

source
fn ContentReport::to_markdown(self : ContentReport) -> String

#
ContrastGrade

source
pub enum ContrastGrade {
  Fail
  AaLarge
  Aa
  Aaa
} derive(Eq, 
Debug)

#
ContrastGrade::label

source
fn ContrastGrade::label(self : ContrastGrade) -> String

#
ContrastPair

source
pub struct ContrastPair {
  foreground : ColorToken
  background : ColorToken
  ratio_x100 : Int
  grade : ContrastGrade
} derive(Eq, 
Debug)

#
ContrastPair::describe

source
fn ContrastPair::describe(self : ContrastPair) -> String

#
ContrastPair::passes

source
fn ContrastPair::passes(self : ContrastPair, policy : AccessibilityPolicy) -> Bool

#
ContrastPair::passes_large_text

source
fn ContrastPair::passes_large_text(self : ContrastPair, policy : AccessibilityPolicy) -> Bool

#
ContrastPair::ratio_text

source
fn ContrastPair::ratio_text(self : ContrastPair) -> String

#
CssExportOptions

source
pub struct CssExportOptions {
  selector : String
  include_comment : Bool
} derive(Eq, 
Debug)

#
CssExportOptions::default

source

#
Diagnostic

source
pub struct Diagnostic {
  severity : DiagnosticSeverity
  path : String
  message : String
  location : SourceLocation?
} derive(Eq, 
Debug)

#
Diagnostic::error

source
fn Diagnostic::error(path : String, message : String, location : SourceLocation?) -> Diagnostic

#
Diagnostic::location_text

source
fn Diagnostic::location_text(self : Diagnostic) -> String

#
Diagnostic::note

source
fn Diagnostic::note(path : String, message : String) -> Diagnostic

#
Diagnostic::to_json

source
fn Diagnostic::to_json(self : Diagnostic) -> String

#
Diagnostic::to_markdown

source
fn Diagnostic::to_markdown(self : Diagnostic) -> String

#
Diagnostic::to_text

source
fn Diagnostic::to_text(self : Diagnostic) -> String

#
Diagnostic::warning

source
fn Diagnostic::warning(path : String, message : String, location : SourceLocation?) -> Diagnostic

#
DiagnosticBag

source
pub struct DiagnosticBag {
  items : Array[Diagnostic]
} derive(Eq, 
Debug)

#
DiagnosticBag::empty

source

#
DiagnosticBag::errors

source

#
DiagnosticBag::has_errors

source
fn DiagnosticBag::has_errors(self : DiagnosticBag) -> Bool

#
DiagnosticBag::merge

source

#
DiagnosticBag::notes

source

#
DiagnosticBag::push

source
fn DiagnosticBag::push(self : DiagnosticBag, diagnostic : Diagnostic) -> DiagnosticBag

#
DiagnosticBag::sorted

source

#
DiagnosticBag::summary

source
fn DiagnosticBag::summary(self : DiagnosticBag) -> String

#
DiagnosticBag::to_json

source
fn DiagnosticBag::to_json(self : DiagnosticBag) -> String

#
DiagnosticBag::to_markdown

source
fn DiagnosticBag::to_markdown(self : DiagnosticBag) -> String

#
DiagnosticBag::to_text

source
fn DiagnosticBag::to_text(self : DiagnosticBag) -> String

#
DiagnosticBag::warnings

source
fn DiagnosticBag::warnings(self : DiagnosticBag) -> Array[Diagnostic]

#
DiagnosticSeverity

source
pub enum DiagnosticSeverity {
  Note
  Warning
  Error
} derive(Eq, 
Debug)

#
DiagnosticSeverity::label

source
fn DiagnosticSeverity::label(self : DiagnosticSeverity) -> String

#
DocumentFormat

source
pub enum DocumentFormat {
  Auto
  Json
  Yaml
} derive(Eq, 
Debug)

#
DocumentFormat::auto

source

#
DocumentFormat::json

source

#
DocumentFormat::yaml

source

#
ExportEntry

source
pub struct ExportEntry {
  name : String
  format : String
  extension : String
  output_bytes : Int
  description : String
} derive(Eq, 
Debug)

#
ExportEntry::new

source
fn ExportEntry::new(name : String, format : String, extension : String, output_bytes : Int, description : String) -> ExportEntry

#
ExportManifest

source
pub struct ExportManifest {
  project : String
  version : String
  entries : Array[ExportEntry]
} derive(Eq, 
Debug)

#
ExportManifest::add

source

#
ExportManifest::empty

source
fn ExportManifest::empty(project : String, version : String) -> ExportManifest

#
ExportManifest::for_brand_book

source
fn ExportManifest::for_brand_book(book : BrandBook) -> ExportManifest

#
ExportManifest::formats

source
fn ExportManifest::formats(self : ExportManifest) -> Array[String]

#
ExportManifest::len

source
fn ExportManifest::len(self : ExportManifest) -> Int

#
ExportManifest::to_json

source
fn ExportManifest::to_json(self : ExportManifest) -> String

#
ExportManifest::to_markdown

source
fn ExportManifest::to_markdown(self : ExportManifest) -> String

#
ExportManifest::total_bytes

source
fn ExportManifest::total_bytes(self : ExportManifest) -> Int

#
Finding

source
pub struct Finding {
  severity : Severity
  path : String
  message : String
} derive(Eq, 
Debug)

#
Finding::info

source
fn Finding::info(path : String, message : String) -> Finding

#
FontToken

source
pub struct FontToken {
  name : String
  fallback : String
  usage : String
} derive(Eq, 
Debug)

#
FontToken::css_family

source
fn FontToken::css_family(self : FontToken) -> String

#
FontToken::css_variable_name

source
fn FontToken::css_variable_name(self : FontToken) -> String

#
FontToken::fallback_chain

source
fn FontToken::fallback_chain(self : FontToken) -> Array[String]

#
FontToken::has_fallback

source
fn FontToken::has_fallback(self : FontToken) -> Bool

#
FontToken::usage_label

source
fn FontToken::usage_label(self : FontToken) -> String

#
GradientToken

source
pub struct GradientToken {
  name : String
  stops : Array[String]
  angle : Int
  usage : String
} derive(Eq, 
Debug)

#
GradientToken::to_css_value

source
fn GradientToken::to_css_value(self : GradientToken) -> String

#
GuideOutline

source
pub struct GuideOutline {
  title : String
  sections : Array[GuideSection]
} derive(Eq, 
Debug)

#
GuideOutline::add

source
fn GuideOutline::add(self : GuideOutline, section : GuideSection) -> GuideOutline

#
GuideOutline::empty

source
fn GuideOutline::empty(title : String) -> GuideOutline

#
GuideOutline::find

source
fn GuideOutline::find(self : GuideOutline, id : String) -> GuideSection?

#
GuideOutline::for_brand_book

source
fn GuideOutline::for_brand_book(book : BrandBook) -> GuideOutline

#
GuideOutline::ids

source
fn GuideOutline::ids(self : GuideOutline) -> Array[String]

#
GuideOutline::len

source
fn GuideOutline::len(self : GuideOutline) -> Int

#
GuideOutline::non_empty

source
fn GuideOutline::non_empty(self : GuideOutline) -> Array[GuideSection]

#
GuideOutline::to_json

source
fn GuideOutline::to_json(self : GuideOutline) -> String

#
GuideOutline::to_markdown

source
fn GuideOutline::to_markdown(self : GuideOutline) -> String

#
GuideOutline::to_toc

source
fn GuideOutline::to_toc(self : GuideOutline) -> String

#
GuideSection

source
pub struct GuideSection {
  id : String
  title : String
  summary : String
  body : String
  order : Int
} derive(Eq, 
Debug)

A structured outline for generated brand guides and documentation consumers.

#
GuideSection::anchor

source
fn GuideSection::anchor(self : GuideSection) -> String

#
GuideSection::is_empty

source
fn GuideSection::is_empty(self : GuideSection) -> Bool

#
GuideSection::new

source
fn GuideSection::new(id : String, title : String, summary : String, body : String, order : Int) -> GuideSection

#
GuideSection::to_json

source
fn GuideSection::to_json(self : GuideSection) -> String

#
GuideSection::to_markdown

source
fn GuideSection::to_markdown(self : GuideSection) -> String

#
JsonPair

source
pub struct JsonPair {
  key : String
  value : JsonValue
} derive(Eq, 
Debug)

#
JsonPair::new

source
fn JsonPair::new(key : String, value : JsonValue) -> JsonPair

#
JsonParseResult

source
pub struct JsonParseResult {
  value : JsonValue?
  diagnostics : DiagnosticBag
} derive(Eq, 
Debug)

#
JsonValue

source
pub enum JsonValue {
  JNull
  JBool(Bool)
  JNumber(String)
  JString(String)
  JArray(Array[JsonValue])
  JObject(Array[JsonPair])
} derive(Eq, 
Debug)

#
JsonValue::array_value

source
fn JsonValue::array_value(self : JsonValue) -> Array[JsonValue]?

#
JsonValue::number_value

source
fn JsonValue::number_value(self : JsonValue) -> String?

#
JsonValue::object_field

source
fn JsonValue::object_field(self : JsonValue, key : String) -> JsonValue?

#
JsonValue::object_value

source
fn JsonValue::object_value(self : JsonValue) -> Array[JsonPair]?

#
JsonValue::string

source
fn JsonValue::string(value : String) -> JsonValue

#
JsonValue::string_value

source
fn JsonValue::string_value(self : JsonValue) -> String?

pub struct Logo {
  name : String
  path : String
  min_width_px : Int
  clear_space : Space
  background : BackgroundRule
} derive(Eq, 
Debug)

#
Logo::audit

source
fn Logo::audit(self : Logo, policy : AssetPolicy) -> AuditReport

#
Logo::extension

source
fn Logo::extension(self : Logo) -> String

#
Logo::is_raster

source
fn Logo::is_raster(self : Logo) -> Bool

#
Logo::is_vector

source
fn Logo::is_vector(self : Logo) -> Bool

#
Logo::new

source
fn Logo::new(name : String, path : String, min_width_px : Int, clear_space : Space, background : BackgroundRule) -> Logo

#
Logo::to_html

source
fn Logo::to_html(self : Logo) -> String

#
Logo::to_markdown

source
fn Logo::to_markdown(self : Logo) -> String

#
Meta

source
pub struct Meta {
  source : String
  maintainer : String
  license : String
} derive(Eq, 
Debug)

#
Meta::is_complete

source
fn Meta::is_complete(self : Meta) -> Bool

#
Meta::is_publishable

source
fn Meta::is_publishable(self : Meta) -> Bool

#
Meta::summary

source
fn Meta::summary(self : Meta) -> String

#
Meta::to_json

source
fn Meta::to_json(self : Meta) -> String

#
MisuseRule

source
pub struct MisuseRule {
  title : String
  reason : String
  replacement : String
} derive(Eq, 
Debug)

#
MisuseRule::is_actionable

source
fn MisuseRule::is_actionable(self : MisuseRule) -> Bool

#
MisuseRule::to_html

source
fn MisuseRule::to_html(self : MisuseRule) -> String

#
MisuseRule::to_json

source
fn MisuseRule::to_json(self : MisuseRule) -> String

#
MisuseRule::to_markdown

source
fn MisuseRule::to_markdown(self : MisuseRule) -> String

#
Palette

source
pub struct Palette {
  colors : Array[ColorToken]
  gradients : Array[GradientToken]
} derive(Eq, 
Debug)

#
Palette::audit_contrast

source
fn Palette::audit_contrast(self : Palette, policy : AccessibilityPolicy) -> AuditReport

#
Palette::color_named

source
fn Palette::color_named(self : Palette, name : String) -> ColorToken?

#
Palette::color_names

source
fn Palette::color_names(self : Palette) -> Array[String]

#
Palette::contrast_matrix_markdown

source
fn Palette::contrast_matrix_markdown(self : Palette) -> String

#
Palette::contrast_pairs

source
fn Palette::contrast_pairs(self : Palette) -> Array[ContrastPair]

#
Palette::dark_colors

source
fn Palette::dark_colors(self : Palette) -> Array[ColorToken]

#
Palette::dark_variant

source
fn Palette::dark_variant(self : Palette, percent : Int) -> Palette

#
Palette::hex_values

source
fn Palette::hex_values(self : Palette) -> Array[String]

#
Palette::light_colors

source
fn Palette::light_colors(self : Palette) -> Array[ColorToken]

#
Palette::light_variant

source
fn Palette::light_variant(self : Palette, percent : Int) -> Palette

#
Palette::nearest_color

source
fn Palette::nearest_color(self : Palette, value : RgbColor) -> ColorToken?

#
Palette::recommended_text_color

source
fn Palette::recommended_text_color(self : Palette, background : ColorToken) -> ColorToken?

#
Palette::render_color_table

source
fn Palette::render_color_table(self : Palette) -> String

#
Palette::render_css_layer

source
fn Palette::render_css_layer(self : Palette) -> String

#
Palette::render_gradient_table

source
fn Palette::render_gradient_table(self : Palette) -> String

#
Palette::render_html_color_table

source
fn Palette::render_html_color_table(self : Palette) -> String

#
Palette::to_css

source
fn Palette::to_css(self : Palette, options? : CssExportOptions) -> String

#
Palette::to_html

source
fn Palette::to_html(self : Palette) -> String

#
Palette::to_markdown

source
fn Palette::to_markdown(self : Palette) -> String

#
Palette::validate_colors

source
fn Palette::validate_colors(self : Palette) -> AuditReport

#
PipelineEvent

source
pub struct PipelineEvent {
  stage : PipelineStage
  passed : Bool
  message : String
} derive(Eq, 
Debug)

#
PipelineEvent::new

source
fn PipelineEvent::new(stage : PipelineStage, passed : Bool, message : String) -> PipelineEvent

#
PipelineEvent::status

source
fn PipelineEvent::status(self : PipelineEvent) -> String

#
PipelineResult

source
pub struct PipelineResult {
  value : BrandBook?
  events : Array[PipelineEvent]
  diagnostics : DiagnosticBag
  exports : RenderBundle?
} derive(Eq, 
Debug)

#
PipelineResult::event

source

#
PipelineResult::event_count

source
fn PipelineResult::event_count(self : PipelineResult) -> Int

#
PipelineResult::failed_events

source
fn PipelineResult::failed_events(self : PipelineResult) -> Array[PipelineEvent]

#
PipelineResult::succeeded

source
fn PipelineResult::succeeded(self : PipelineResult) -> Bool

#
PipelineResult::summary

source
fn PipelineResult::summary(self : PipelineResult) -> String

#
PipelineResult::to_json

source
fn PipelineResult::to_json(self : PipelineResult) -> String

#
PipelineResult::to_markdown

source
fn PipelineResult::to_markdown(self : PipelineResult) -> String

#
PipelineStage

source
pub enum PipelineStage {
  ReadInput
  ParseDocument
  ValidateSchema
  ValidateAccessibility
  ValidateContent
  BuildExports
} derive(Eq, 
Debug)

The import pipeline keeps parsing, policy validation, and rendering as explicit stages so callers can inspect partial failures.

#
PipelineStage::label

source
fn PipelineStage::label(self : PipelineStage) -> String

#
PipelineStage::ordinal

source
fn PipelineStage::ordinal(self : PipelineStage) -> Int

#
PolicyCatalog

source
pub struct PolicyCatalog {
  name : String
  rules : Array[PolicyRule]
} derive(Eq, 
Debug)

#
PolicyCatalog::all_ids_non_empty

source
fn PolicyCatalog::all_ids_non_empty(self : PolicyCatalog) -> Bool

#
PolicyCatalog::all_rationales_non_empty

source
fn PolicyCatalog::all_rationales_non_empty(self : PolicyCatalog) -> Bool

#
PolicyCatalog::brandbook

source
fn PolicyCatalog::brandbook() -> PolicyCatalog

#
PolicyCatalog::checklist

source
fn PolicyCatalog::checklist(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::ci_message

source
fn PolicyCatalog::ci_message(self : PolicyCatalog) -> String

#
PolicyCatalog::compact_json

source
fn PolicyCatalog::compact_json(self : PolicyCatalog) -> String

#
PolicyCatalog::contains

source
fn PolicyCatalog::contains(self : PolicyCatalog, id : String) -> Bool

#
PolicyCatalog::coverage_label

source
fn PolicyCatalog::coverage_label(self : PolicyCatalog) -> String

#
PolicyCatalog::coverage_score

source
fn PolicyCatalog::coverage_score(self : PolicyCatalog) -> Int

#
PolicyCatalog::critical_ids

source
fn PolicyCatalog::critical_ids(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::error_count

source
fn PolicyCatalog::error_count(self : PolicyCatalog) -> Int

#
PolicyCatalog::errors

source

#
PolicyCatalog::filter_severity

source
fn PolicyCatalog::filter_severity(self : PolicyCatalog, severity : String) -> Array[PolicyRule]

#
PolicyCatalog::first_error

source
fn PolicyCatalog::first_error(self : PolicyCatalog) -> PolicyRule?

#
PolicyCatalog::first_rule

source
fn PolicyCatalog::first_rule(self : PolicyCatalog) -> PolicyRule?

#
PolicyCatalog::has_errors

source
fn PolicyCatalog::has_errors(self : PolicyCatalog) -> Bool

#
PolicyCatalog::has_required_sections

source
fn PolicyCatalog::has_required_sections(self : PolicyCatalog) -> Bool

#
PolicyCatalog::has_rule_with_title

source
fn PolicyCatalog::has_rule_with_title(self : PolicyCatalog, title : String) -> Bool

#
PolicyCatalog::has_warnings

source
fn PolicyCatalog::has_warnings(self : PolicyCatalog) -> Bool

#
PolicyCatalog::ids_markdown

source
fn PolicyCatalog::ids_markdown(self : PolicyCatalog) -> String

#
PolicyCatalog::is_complete

source
fn PolicyCatalog::is_complete(self : PolicyCatalog) -> Bool

#
PolicyCatalog::is_empty

source
fn PolicyCatalog::is_empty(self : PolicyCatalog) -> Bool

#
PolicyCatalog::json_rule_ids

source
fn PolicyCatalog::json_rule_ids(self : PolicyCatalog) -> String

#
PolicyCatalog::last_rule

source
fn PolicyCatalog::last_rule(self : PolicyCatalog) -> PolicyRule?

#
PolicyCatalog::len

source
fn PolicyCatalog::len(self : PolicyCatalog) -> Int

#
PolicyCatalog::markdown_checklist

source
fn PolicyCatalog::markdown_checklist(self : PolicyCatalog) -> String

#
PolicyCatalog::name_text

source
fn PolicyCatalog::name_text(self : PolicyCatalog) -> String

#
PolicyCatalog::note_count

source
fn PolicyCatalog::note_count(self : PolicyCatalog) -> Int

#
PolicyCatalog::rationales

source
fn PolicyCatalog::rationales(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::rationales_markdown

source
fn PolicyCatalog::rationales_markdown(self : PolicyCatalog) -> String

#
PolicyCatalog::ready

source
fn PolicyCatalog::ready(self : PolicyCatalog) -> Bool

#
PolicyCatalog::ready_for_ci

source
fn PolicyCatalog::ready_for_ci(self : PolicyCatalog) -> Bool

#
PolicyCatalog::ready_summary

source
fn PolicyCatalog::ready_summary(self : PolicyCatalog) -> String

#
PolicyCatalog::rule

source
fn PolicyCatalog::rule(self : PolicyCatalog, id : String) -> PolicyRule?

#
PolicyCatalog::rule_at

source
fn PolicyCatalog::rule_at(self : PolicyCatalog, index : Int) -> PolicyRule?

#
PolicyCatalog::rule_count_for

source
fn PolicyCatalog::rule_count_for(self : PolicyCatalog, severity : String) -> Int

#
PolicyCatalog::rule_for_path

source
fn PolicyCatalog::rule_for_path(self : PolicyCatalog, path : String) -> PolicyRule?

#
PolicyCatalog::rule_ids

source
fn PolicyCatalog::rule_ids(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::rule_ids_csv

source
fn PolicyCatalog::rule_ids_csv(self : PolicyCatalog) -> String

#
PolicyCatalog::rule_titles_csv

source
fn PolicyCatalog::rule_titles_csv(self : PolicyCatalog) -> String

#
PolicyCatalog::rule_titles_markdown

source
fn PolicyCatalog::rule_titles_markdown(self : PolicyCatalog) -> String

#
PolicyCatalog::search

source
fn PolicyCatalog::search(self : PolicyCatalog, text : String) -> Array[PolicyRule]

#
PolicyCatalog::search_ids

source
fn PolicyCatalog::search_ids(self : PolicyCatalog, text : String) -> Array[String]

#
PolicyCatalog::severity_counts

source
fn PolicyCatalog::severity_counts(self : PolicyCatalog) -> Array[Int]

#
PolicyCatalog::severity_labels

source
fn PolicyCatalog::severity_labels(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::severity_summary

source
fn PolicyCatalog::severity_summary(self : PolicyCatalog) -> String

#
PolicyCatalog::status

source
fn PolicyCatalog::status(self : PolicyCatalog) -> String

#
PolicyCatalog::status_line

source
fn PolicyCatalog::status_line(self : PolicyCatalog) -> String

#
PolicyCatalog::summary

source
fn PolicyCatalog::summary(self : PolicyCatalog) -> String

#
PolicyCatalog::titles

source
fn PolicyCatalog::titles(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::to_json

source
fn PolicyCatalog::to_json(self : PolicyCatalog) -> String

#
PolicyCatalog::to_markdown

source
fn PolicyCatalog::to_markdown(self : PolicyCatalog) -> String

#
PolicyCatalog::unique_severities

source
fn PolicyCatalog::unique_severities(self : PolicyCatalog) -> Array[String]

#
PolicyCatalog::warning_count

source
fn PolicyCatalog::warning_count(self : PolicyCatalog) -> Int

#
PolicyCatalog::warnings

source
fn PolicyCatalog::warnings(self : PolicyCatalog) -> Array[PolicyRule]

#
PolicyRule

source
pub struct PolicyRule {
  id : String
  title : String
  rationale : String
  severity : String
} derive(Eq, 
Debug)

Explainable policy metadata keeps CI failures actionable for humans.

#
PolicyRule::new

source
fn PolicyRule::new(id : String, title : String, rationale : String, severity : String) -> PolicyRule

#
PolicyRule::to_json

source
fn PolicyRule::to_json(self : PolicyRule) -> String

#
PolicyRule::to_markdown

source
fn PolicyRule::to_markdown(self : PolicyRule) -> String

#
QualityDimension

source
pub struct QualityDimension {
  name : String
  score : Int
  summary : String
} derive(Eq, 
Debug)

One independently scored health dimension in a brand book review.

#
QualityDimension::label

source
fn QualityDimension::label(self : QualityDimension) -> String

#
QualityDimension::new

source
fn QualityDimension::new(name : String, score : Int, summary : String) -> QualityDimension

#
QualityDimension::passed

source
fn QualityDimension::passed(self : QualityDimension, threshold : Int) -> Bool

#
QualityDimension::to_json

source
fn QualityDimension::to_json(self : QualityDimension) -> String

#
ReferenceEdge

source
pub struct ReferenceEdge {
  source : String
  target : String
  kind : ReferenceKind
} derive(Eq, 
Debug)

#
ReferenceGraph

source
pub struct ReferenceGraph {
  edges : Array[ReferenceEdge]
} derive(Eq, 
Debug)

#
ReferenceGraph::add

source
fn ReferenceGraph::add(self : ReferenceGraph, source : String, target : String, kind : ReferenceKind) -> ReferenceGraph

#
ReferenceGraph::add_alias

source
fn ReferenceGraph::add_alias(self : ReferenceGraph, source : String, target : String) -> ReferenceGraph

#
ReferenceGraph::edge_count

source
fn ReferenceGraph::edge_count(self : ReferenceGraph) -> Int

#
ReferenceGraph::edges_of

source

#
ReferenceGraph::empty

source

#
ReferenceGraph::missing_targets

source
fn ReferenceGraph::missing_targets(self : ReferenceGraph, known : Array[String]) -> Array[String]

#
ReferenceGraph::node_count

source
fn ReferenceGraph::node_count(self : ReferenceGraph) -> Int

#
ReferenceGraph::sources_for

source
fn ReferenceGraph::sources_for(self : ReferenceGraph, target : String) -> Array[String]

#
ReferenceGraph::targets_for

source
fn ReferenceGraph::targets_for(self : ReferenceGraph, source : String) -> Array[String]

#
ReferenceGraph::to_markdown

source
fn ReferenceGraph::to_markdown(self : ReferenceGraph) -> String

#
ReferenceKind

source
pub enum ReferenceKind {
  ComponentToken
  ComponentState
  PaletteRole
  ThemeAlias
} derive(Eq, 
Debug)

#
ReleaseCheck

source
pub struct ReleaseCheck {
  name : String
  passed : Bool
  message : String
} derive(Eq, 
Debug)

#
ReleaseCheck::new

source
fn ReleaseCheck::new(name : String, passed : Bool, message : String) -> ReleaseCheck

#
ReleaseCheck::status

source
fn ReleaseCheck::status(self : ReleaseCheck) -> String

#
ReleasePolicy

source
pub struct ReleasePolicy {
  minimum_score : Int
  require_accessibility : Bool
  require_content : Bool
  require_non_empty_exports : Bool
  required_formats : Array[String]
} derive(Eq, 
Debug)

Release gates that combine validation, content, accessibility, and export checks.

#
ReleasePolicy::default

source
fn ReleasePolicy::default() -> ReleasePolicy

#
ReleasePolicy::strict

source

#
ReleasePolicy::with_content_requirement

source
fn ReleasePolicy::with_content_requirement(self : ReleasePolicy, required : Bool) -> ReleasePolicy

#
ReleasePolicy::with_formats

source
fn ReleasePolicy::with_formats(self : ReleasePolicy, formats : Array[String]) -> ReleasePolicy

#
ReleasePolicy::with_minimum_score

source
fn ReleasePolicy::with_minimum_score(self : ReleasePolicy, score : Int) -> ReleasePolicy

#
ReleaseReport

source
pub struct ReleaseReport {
  ready : Bool
  checks : Array[ReleaseCheck]
  score : Int
} derive(Eq, 
Debug)

#
ReleaseReport::check_named

source
fn ReleaseReport::check_named(self : ReleaseReport, name : String) -> ReleaseCheck?

#
ReleaseReport::failed_checks

source
fn ReleaseReport::failed_checks(self : ReleaseReport) -> Array[ReleaseCheck]

#
ReleaseReport::passed

source
fn ReleaseReport::passed(self : ReleaseReport) -> Bool

#
ReleaseReport::passed_checks

source
fn ReleaseReport::passed_checks(self : ReleaseReport) -> Array[ReleaseCheck]

#
ReleaseReport::summary

source
fn ReleaseReport::summary(self : ReleaseReport) -> String

#
ReleaseReport::to_json

source
fn ReleaseReport::to_json(self : ReleaseReport) -> String

#
ReleaseReport::to_markdown

source
fn ReleaseReport::to_markdown(self : ReleaseReport) -> String

#
RenderArtifact

source
pub struct RenderArtifact {
  name : String
  format : String
  content : String
} derive(Eq, 
Debug)

Named render artifacts allow integrations to consume one deterministic bundle.

#
RenderArtifact::bytes

source
fn RenderArtifact::bytes(self : RenderArtifact) -> Int

#
RenderArtifact::file_name

source
fn RenderArtifact::file_name(self : RenderArtifact) -> String

#
RenderArtifact::header

source
fn RenderArtifact::header(self : RenderArtifact) -> String

#
RenderArtifact::is_empty

source
fn RenderArtifact::is_empty(self : RenderArtifact) -> Bool

#
RenderArtifact::new

source
fn RenderArtifact::new(name : String, format : String, content : String) -> RenderArtifact

#
RenderBundle

source
pub struct RenderBundle {
  name : String
  artifacts : Array[RenderArtifact]
} derive(Eq, 
Debug)

#
RenderBundle::add

source
fn RenderBundle::add(self : RenderBundle, artifact : RenderArtifact) -> RenderBundle

#
RenderBundle::artifact

source
fn RenderBundle::artifact(self : RenderBundle, name : String, format : String) -> RenderArtifact?

#
RenderBundle::artifact_names

source
fn RenderBundle::artifact_names(self : RenderBundle) -> Array[String]

#
RenderBundle::empty

source
fn RenderBundle::empty(name : String) -> RenderBundle

#
RenderBundle::for_brand_book

source
fn RenderBundle::for_brand_book(book : BrandBook) -> RenderBundle

#
RenderBundle::formats

source
fn RenderBundle::formats(self : RenderBundle) -> Array[String]

#
RenderBundle::is_empty

source
fn RenderBundle::is_empty(self : RenderBundle) -> Bool

#
RenderBundle::len

source
fn RenderBundle::len(self : RenderBundle) -> Int

#
RenderBundle::manifest_json

source
fn RenderBundle::manifest_json(self : RenderBundle) -> String

#
RenderBundle::manifest_markdown

source
fn RenderBundle::manifest_markdown(self : RenderBundle) -> String

#
RenderBundle::non_empty

source
fn RenderBundle::non_empty(self : RenderBundle) -> Array[RenderArtifact]

#
RenderBundle::total_bytes

source
fn RenderBundle::total_bytes(self : RenderBundle) -> Int

#
Rgb

source

#
RgbColor

source
pub struct RgbColor {
  red : Int
  green : Int
  blue : Int
} derive(Eq, 
Debug)

An integer RGB value used for deterministic token analysis.

#
RgbColor::average

source
fn RgbColor::average(self : RgbColor, other : RgbColor) -> RgbColor

#
RgbColor::black

source
fn RgbColor::black() -> RgbColor

#
RgbColor::blend

source
fn RgbColor::blend(self : RgbColor, other : RgbColor, percent : Int) -> RgbColor

#
RgbColor::channel

source
fn RgbColor::channel(self : RgbColor, name : String) -> Int?

#
RgbColor::complementary

source
fn RgbColor::complementary(self : RgbColor) -> RgbColor

#
RgbColor::contrast_ratio_x100

source
fn RgbColor::contrast_ratio_x100(self : RgbColor, other : RgbColor) -> Int

#
RgbColor::darken

source
fn RgbColor::darken(self : RgbColor, percent : Int) -> RgbColor

#
RgbColor::describe

source
fn RgbColor::describe(self : RgbColor) -> String

#
RgbColor::distance_to

source
fn RgbColor::distance_to(self : RgbColor, other : RgbColor) -> Int

#
RgbColor::from_hex

source
fn RgbColor::from_hex(value : String) -> RgbColor?

#
RgbColor::inverted

source
fn RgbColor::inverted(self : RgbColor) -> RgbColor

#
RgbColor::is_dark

source
fn RgbColor::is_dark(self : RgbColor) -> Bool

#
RgbColor::is_grayscale

source
fn RgbColor::is_grayscale(self : RgbColor) -> Bool

#
RgbColor::is_light

source
fn RgbColor::is_light(self : RgbColor) -> Bool

#
RgbColor::lighten

source
fn RgbColor::lighten(self : RgbColor, percent : Int) -> RgbColor

#
RgbColor::luminance_x10000

source
fn RgbColor::luminance_x10000(self : RgbColor) -> Int

#
RgbColor::new

source
fn RgbColor::new(red : Int, green : Int, blue : Int) -> RgbColor

#
RgbColor::same_as

source
fn RgbColor::same_as(self : RgbColor, other : RgbColor) -> Bool

#
RgbColor::to_css_rgb

source
fn RgbColor::to_css_rgb(self : RgbColor) -> String

#
RgbColor::to_hex

source
fn RgbColor::to_hex(self : RgbColor) -> String

#
RgbColor::white

source
fn RgbColor::white() -> RgbColor

#
RgbColor::with_blue

source
fn RgbColor::with_blue(self : RgbColor, blue : Int) -> RgbColor

#
RgbColor::with_green

source
fn RgbColor::with_green(self : RgbColor, green : Int) -> RgbColor

#
RgbColor::with_red

source
fn RgbColor::with_red(self : RgbColor, red : Int) -> RgbColor

#
Severity

source
pub enum Severity {
  Info
  Warning
  Error
} derive(Eq, 
Debug)

#
Severity::label

source
fn Severity::label(self : Severity) -> String

#
SourceLocation

source
pub struct SourceLocation {
  line : Int
  column : Int
  offset : Int
} derive(Eq, 
Debug)

#
SourceLocation::new

source
fn SourceLocation::new(line : Int, column : Int, offset : Int) -> SourceLocation

#
SourceLocation::to_string

source
fn SourceLocation::to_string(self : SourceLocation) -> String

#
Space

source
pub enum Space {
  Pixels(Int)
  Multiplier(Double)
} derive(Eq, 
Debug)

#
Space::describe

source
fn Space::describe(self : Space) -> String

#
Space::multiplier

source
fn Space::multiplier(value : Double) -> Space

#
Space::pixels

source
fn Space::pixels(value : Int) -> Space

#
ThemeAlias

source
pub struct ThemeAlias {
  name : TokenPath
  target : TokenPath
} derive(Eq, 
Debug)

#
ThemeChange

source
pub struct ThemeChange {
  path : String
  before : ThemeToken
  after : ThemeToken
} derive(Eq, 
Debug)

#
ThemeDiff

source
pub struct ThemeDiff {
  added : Array[ThemeToken]
  removed : Array[ThemeToken]
  changed : Array[ThemeChange]
} derive(Eq, 
Debug)

#
ThemeDiff::between

source
fn ThemeDiff::between(before : ThemeDocument, after : ThemeDocument) -> ThemeDiff

#
ThemeDiff::change_count

source
fn ThemeDiff::change_count(self : ThemeDiff) -> Int

#
ThemeDiff::has_breaking_changes

source
fn ThemeDiff::has_breaking_changes(self : ThemeDiff) -> Bool

#
ThemeDiff::is_empty

source
fn ThemeDiff::is_empty(self : ThemeDiff) -> Bool

#
ThemeDiff::migration_steps

source
fn ThemeDiff::migration_steps(self : ThemeDiff) -> Array[String]

#
ThemeDiff::summary

source
fn ThemeDiff::summary(self : ThemeDiff) -> String

#
ThemeDiff::to_markdown

source
fn ThemeDiff::to_markdown(self : ThemeDiff) -> String

#
ThemeDocument

source
pub struct ThemeDocument {
  tokens : Array[ThemeToken]
  aliases : Array[ThemeAlias]
  provenance : Array[ThemeProvenance]
} derive(Eq, 
Debug)

#
ThemeDocument::add

source

#
ThemeDocument::audit_theme

source
fn ThemeDocument::audit_theme(self : ThemeDocument, policy : ThemePolicy) -> AuditReport

#
ThemeDocument::color_tokens

source
fn ThemeDocument::color_tokens(self : ThemeDocument) -> Array[ThemeToken]

#
ThemeDocument::description_rate

source
fn ThemeDocument::description_rate(self : ThemeDocument) -> Int

#
ThemeDocument::descriptions

source
fn ThemeDocument::descriptions(self : ThemeDocument) -> Array[String]

#
ThemeDocument::documentation_rate

source
fn ThemeDocument::documentation_rate(self : ThemeDocument) -> Int

#
ThemeDocument::empty

source

#
ThemeDocument::find

source
fn ThemeDocument::find(self : ThemeDocument, path : String) -> ThemeToken?

#
ThemeDocument::has_duplicate_paths

source
fn ThemeDocument::has_duplicate_paths(self : ThemeDocument) -> Bool

#
ThemeDocument::has_kind

source
fn ThemeDocument::has_kind(self : ThemeDocument, kind : TokenKind) -> Bool

#
ThemeDocument::has_only_documented_tokens

source
fn ThemeDocument::has_only_documented_tokens(self : ThemeDocument) -> Bool

#
ThemeDocument::kind_counts

source
fn ThemeDocument::kind_counts(self : ThemeDocument) -> Array[Int]

#
ThemeDocument::kind_label_counts

source
fn ThemeDocument::kind_label_counts(self : ThemeDocument) -> Array[String]

#
ThemeDocument::layer_for

source
fn ThemeDocument::layer_for(self : ThemeDocument, path : String) -> Int?

#
ThemeDocument::map_paths

source
fn ThemeDocument::map_paths(self : ThemeDocument, transform : ThemeTransform) -> ThemeDocument

#
ThemeDocument::merge_layers

source
fn ThemeDocument::merge_layers(layers : Array[ThemeDocument]) -> ThemeDocument

#
ThemeDocument::metric_json

source
fn ThemeDocument::metric_json(self : ThemeDocument) -> String

#
ThemeDocument::metric_markdown

source
fn ThemeDocument::metric_markdown(self : ThemeDocument) -> String

#
ThemeDocument::metrics

source

#
ThemeDocument::number_tokens

source
fn ThemeDocument::number_tokens(self : ThemeDocument) -> Array[ThemeToken]

#
ThemeDocument::only_kind

source
fn ThemeDocument::only_kind(self : ThemeDocument, kind : TokenKind) -> ThemeDocument

#
ThemeDocument::override_token

source
fn ThemeDocument::override_token(self : ThemeDocument, token : ThemeToken, source : String) -> ThemeDocument

#
ThemeDocument::paths

source
fn ThemeDocument::paths(self : ThemeDocument) -> Array[String]

#
ThemeDocument::paths_for_kind

source
fn ThemeDocument::paths_for_kind(self : ThemeDocument, kind : TokenKind) -> Array[String]

#
ThemeDocument::provenance

source
fn ThemeDocument::provenance(self : ThemeDocument, path : String) -> String?

#
ThemeDocument::rename_prefix

source
fn ThemeDocument::rename_prefix(self : ThemeDocument, from : String, to : String) -> ThemeDocument

#
ThemeDocument::select_prefix

source
fn ThemeDocument::select_prefix(self : ThemeDocument, prefix : String) -> ThemeDocument

#
ThemeDocument::select_prefix_kind

source
fn ThemeDocument::select_prefix_kind(self : ThemeDocument, prefix : String) -> ThemeDocument

#
ThemeDocument::sorted

source

#
ThemeDocument::to_figma

source
fn ThemeDocument::to_figma(self : ThemeDocument) -> String

#
ThemeDocument::to_json

source
fn ThemeDocument::to_json(self : ThemeDocument, pretty? : Bool) -> String

#
ThemeDocument::to_path_list

source
fn ThemeDocument::to_path_list(self : ThemeDocument) -> String

#
ThemeDocument::to_summary_markdown

source
fn ThemeDocument::to_summary_markdown(self : ThemeDocument) -> String

#
ThemeDocument::to_tailwind

source
fn ThemeDocument::to_tailwind(self : ThemeDocument) -> String

#
ThemeDocument::to_yaml

source
fn ThemeDocument::to_yaml(self : ThemeDocument) -> String

#
ThemeDocument::token_count

source
fn ThemeDocument::token_count(self : ThemeDocument) -> Int

#
ThemeDocument::undocumented_paths

source
fn ThemeDocument::undocumented_paths(self : ThemeDocument) -> Array[String]

#
ThemeDocument::value_for

source
fn ThemeDocument::value_for(self : ThemeDocument, path : String) -> ThemeValue?

#
ThemeDocument::values_for_kind

source
fn ThemeDocument::values_for_kind(self : ThemeDocument, kind : TokenKind) -> Array[ThemeValue]

#
ThemeDocument::with_alias

source
fn ThemeDocument::with_alias(self : ThemeDocument, name : String, target : String) -> ThemeDocument

#
ThemeDocument::with_prefix

source
fn ThemeDocument::with_prefix(self : ThemeDocument, prefix : String) -> ThemeDocument

#
ThemeDocument::with_source

source
fn ThemeDocument::with_source(self : ThemeDocument, source : String) -> ThemeDocument

#
ThemeDocument::without_prefix

source
fn ThemeDocument::without_prefix(self : ThemeDocument, prefix : String) -> ThemeDocument

#
ThemePolicy

source
pub struct ThemePolicy {
  require_descriptions : Bool
  require_unique_paths : Bool
  allowed_prefix : String
  min_color_tokens : Int
  reject_empty_values : Bool
} derive(Eq, 
Debug)

#
ThemePolicy::default

source
fn ThemePolicy::default() -> ThemePolicy

#
ThemePolicy::strict

source
fn ThemePolicy::strict() -> ThemePolicy

#
ThemePolicy::with_prefix

source
fn ThemePolicy::with_prefix(self : ThemePolicy, prefix : String) -> ThemePolicy

#
ThemeProvenance

source
pub struct ThemeProvenance {
  path : String
  layer : Int
  source : String
} derive(Eq, 
Debug)

#
ThemeProvenance::new

source
fn ThemeProvenance::new(path : String, layer : Int, source : String) -> ThemeProvenance

#
ThemeToken

source
pub struct ThemeToken {
  path : TokenPath
  kind : TokenKind
  value : ThemeValue
  description : String
} derive(Eq, 
Debug)

#
ThemeToken::boolean

source
fn ThemeToken::boolean(path : String, value : Bool, description : String) -> ThemeToken

#
ThemeToken::color

source
fn ThemeToken::color(path : String, value : String, description : String) -> ThemeToken

#
ThemeToken::is_empty

source
fn ThemeToken::is_empty(self : ThemeToken) -> Bool

#
ThemeToken::is_valid

source
fn ThemeToken::is_valid(self : ThemeToken) -> Bool

#
ThemeToken::number

source
fn ThemeToken::number(path : String, value : Int, description : String) -> ThemeToken

#
ThemeToken::text

source
fn ThemeToken::text(path : String, value : String, description : String) -> ThemeToken

#
ThemeTransform

source
pub enum ThemeTransform {
  Prefix(String)
  Rename(String, String)
  FilterKind(TokenKind)
  DropPrefix(String)
} derive(Eq, 
Debug)

Transformations for turning a theme document into stable variants without losing descriptions or aliases.

#
ThemeTransform::drop_prefix

source
fn ThemeTransform::drop_prefix(value : String) -> ThemeTransform

#
ThemeTransform::filter_kind

source
fn ThemeTransform::filter_kind(kind : TokenKind) -> ThemeTransform

#
ThemeTransform::prefix

source
fn ThemeTransform::prefix(value : String) -> ThemeTransform

#
ThemeTransform::rename

source
fn ThemeTransform::rename(from : String, to : String) -> ThemeTransform

#
ThemeValue

source
pub enum ThemeValue {
  ColorValue(String)
  NumberValue(Int)
  TextValue(String)
  BooleanValue(Bool)
} derive(Eq, 
Debug)

#
TokenCatalog

source
pub struct TokenCatalog {
  entries : Array[CatalogEntry]
} derive(Eq, 
Debug)

#
TokenCatalog::add

source

#
TokenCatalog::booleans

source
fn TokenCatalog::booleans(self : TokenCatalog) -> Array[CatalogEntry]

#
TokenCatalog::by_kind

source
fn TokenCatalog::by_kind(self : TokenCatalog, kind : TokenKind) -> Array[CatalogEntry]

#
TokenCatalog::by_prefix

source
fn TokenCatalog::by_prefix(self : TokenCatalog, prefix : String) -> Array[CatalogEntry]

#
TokenCatalog::colors

source

#
TokenCatalog::contains

source
fn TokenCatalog::contains(self : TokenCatalog, path : String) -> Bool

#
TokenCatalog::empty

source
fn TokenCatalog::empty() -> TokenCatalog

#
TokenCatalog::entries

source

#
TokenCatalog::find

source
fn TokenCatalog::find(self : TokenCatalog, path : String) -> CatalogEntry?

#
TokenCatalog::from_brand_book

source
fn TokenCatalog::from_brand_book(book : BrandBook) -> TokenCatalog

#
TokenCatalog::from_theme_document

source
fn TokenCatalog::from_theme_document(document : ThemeDocument) -> TokenCatalog

#
TokenCatalog::grouped_markdown

source
fn TokenCatalog::grouped_markdown(self : TokenCatalog) -> String

#
TokenCatalog::is_empty

source
fn TokenCatalog::is_empty(self : TokenCatalog) -> Bool

#
TokenCatalog::len

source
fn TokenCatalog::len(self : TokenCatalog) -> Int

#
TokenCatalog::names

source
fn TokenCatalog::names(self : TokenCatalog) -> Array[String]

#
TokenCatalog::names_for_query

source
fn TokenCatalog::names_for_query(self : TokenCatalog, query : String) -> Array[String]

#
TokenCatalog::numbers

source

#
TokenCatalog::paths

source
fn TokenCatalog::paths(self : TokenCatalog) -> Array[String]

#
TokenCatalog::paths_for_prefix

source
fn TokenCatalog::paths_for_prefix(self : TokenCatalog, prefix : String) -> Array[String]

#
TokenCatalog::query

source
fn TokenCatalog::query(self : TokenCatalog, query : TokenQuery) -> Array[CatalogEntry]

#
TokenCatalog::search

source
fn TokenCatalog::search(self : TokenCatalog, query : String) -> Array[CatalogEntry]

#
TokenCatalog::stats

source

#
TokenCatalog::texts

source

#
TokenCatalog::to_markdown

source
fn TokenCatalog::to_markdown(self : TokenCatalog) -> String

#
TokenKind

source
pub enum TokenKind {
  Color
  Number
  Text
  Boolean
} derive(Eq, 
Debug)

#
TokenMetrics

source
pub struct TokenMetrics {
  total : Int
  colors : Int
  numbers : Int
  texts : Int
  booleans : Int
  aliases : Int
  documented : Int
  empty_values : Int
} derive(Eq, 
Debug)

Distribution metrics for reviewing a theme before it is exported.

#
TokenMetrics::density_score

source
fn TokenMetrics::density_score(self : TokenMetrics) -> Int

#
TokenMetrics::documentation_rate

source
fn TokenMetrics::documentation_rate(self : TokenMetrics) -> Int

#
TokenMetrics::empty_rate

source
fn TokenMetrics::empty_rate(self : TokenMetrics) -> Int

#
TokenMetrics::is_healthy

source
fn TokenMetrics::is_healthy(self : TokenMetrics) -> Bool

#
TokenMetrics::kind_count

source
fn TokenMetrics::kind_count(self : TokenMetrics, kind : TokenKind) -> Int

#
TokenMetrics::to_json

source
fn TokenMetrics::to_json(self : TokenMetrics) -> String

#
TokenMetrics::to_markdown

source
fn TokenMetrics::to_markdown(self : TokenMetrics) -> String

#
TokenPath

source
pub struct TokenPath {
  segments : Array[String]
} derive(Eq, 
Debug)

#
TokenPath::canonical

source
fn TokenPath::canonical(self : TokenPath) -> String

#
TokenPath::css_name

source
fn TokenPath::css_name(self : TokenPath, prefix : String) -> String

#
TokenPath::from_string

source
fn TokenPath::from_string(text : String) -> TokenPath

#
TokenPath::is_empty

source
fn TokenPath::is_empty(self : TokenPath) -> Bool

#
TokenPath::new

source
fn TokenPath::new(segments : Array[String]) -> TokenPath

#
TokenQuery

source
pub struct TokenQuery {
  kind : TokenKind?
  prefix : String
  text : String
  value : String
} derive(Eq, 
Debug)

#
TokenQuery::empty

source
fn TokenQuery::empty() -> TokenQuery

#
TokenQuery::parse

source
fn TokenQuery::parse(text : String) -> TokenQuery

#
TokenQuery::with_kind

source
fn TokenQuery::with_kind(self : TokenQuery, kind : TokenKind) -> TokenQuery

#
TokenQuery::with_prefix

source
fn TokenQuery::with_prefix(self : TokenQuery, prefix : String) -> TokenQuery

#
TokenQuery::with_text

source
fn TokenQuery::with_text(self : TokenQuery, text : String) -> TokenQuery

#
TypeStep

source
pub struct TypeStep {
  name : String
  size_px : Int
  line_height_px : Int
} derive(Eq, 
Debug)

#
TypeStep::css_line_height

source
fn TypeStep::css_line_height(self : TypeStep) -> String

#
TypeStep::css_size

source
fn TypeStep::css_size(self : TypeStep) -> String

#
TypeStep::css_variable_name

source
fn TypeStep::css_variable_name(self : TypeStep) -> String

#
TypeStep::description

source
fn TypeStep::description(self : TypeStep) -> String

#
TypeStep::is_accessible

source
fn TypeStep::is_accessible(self : TypeStep) -> Bool

#
TypeStep::is_valid

source
fn TypeStep::is_valid(self : TypeStep, policy : TypographyPolicy) -> Bool

#
TypeStep::line_gap

source
fn TypeStep::line_gap(self : TypeStep) -> Int

#
TypeStep::ratio_to

source
fn TypeStep::ratio_to(self : TypeStep, other : TypeStep) -> Int

#
TypeStep::ratio_x100

source
fn TypeStep::ratio_x100(self : TypeStep) -> Int

#
Typography

source
pub struct Typography {
  families : Array[FontToken]
  scale : Array[TypeStep]
} derive(Eq, 
Debug)

#
Typography::accessible_step_count

source
fn Typography::accessible_step_count(self : Typography) -> Int

#
Typography::audit_rhythm

source
fn Typography::audit_rhythm(self : Typography, policy : TypographyPolicy) -> AuditReport

#
Typography::average_line_ratio

source
fn Typography::average_line_ratio(self : Typography) -> Int

#
Typography::css_variable_map

source
fn Typography::css_variable_map(self : Typography) -> String

#
Typography::family_for_usage

source
fn Typography::family_for_usage(self : Typography, usage : String) -> FontToken?

#
Typography::family_names

source
fn Typography::family_names(self : Typography) -> Array[String]

#
Typography::font_stack

source
fn Typography::font_stack(self : Typography, name : String) -> String

#
Typography::has_step

source
fn Typography::has_step(self : Typography, name : String) -> Bool

#
Typography::is_valid

source
fn Typography::is_valid(self : Typography) -> Bool

#
Typography::largest_step

source
fn Typography::largest_step(self : Typography) -> TypeStep?

#
Typography::render_family_table

source
fn Typography::render_family_table(self : Typography) -> String

#
Typography::render_html_scale_table

source
fn Typography::render_html_scale_table(self : Typography) -> String

#
Typography::render_scale_table

source
fn Typography::render_scale_table(self : Typography) -> String

#
Typography::scale_names

source
fn Typography::scale_names(self : Typography) -> Array[String]

#
Typography::smallest_step

source
fn Typography::smallest_step(self : Typography) -> TypeStep?

#
Typography::step_named

source
fn Typography::step_named(self : Typography, name : String) -> TypeStep?

#
Typography::to_css

source
fn Typography::to_css(self : Typography, selector? : String) -> String

#
Typography::to_html

source
fn Typography::to_html(self : Typography) -> String

#
Typography::to_markdown

source
fn Typography::to_markdown(self : Typography) -> String

#
Typography::to_scale_markdown

source
fn Typography::to_scale_markdown(self : Typography) -> String

#
Typography::total_rhythm_units

source
fn Typography::total_rhythm_units(self : Typography) -> Int

#
Typography::validate_scale

source
fn Typography::validate_scale(self : Typography) -> AuditReport

#
TypographyPolicy

source
pub struct TypographyPolicy {
  min_size_px : Int
  max_size_px : Int
  min_line_height_px : Int
  min_line_ratio_x100 : Int
  max_line_ratio_x100 : Int
  require_fallback : Bool
  require_monotonic_scale : Bool
} derive(Eq, 
Debug)

Policy used when checking a type scale for readable production output.

#
TypographyPolicy::default

source

#
TypographyPolicy::strict

source

#
TypographyPolicy::with_fallback_requirement

source
fn TypographyPolicy::with_fallback_requirement(self : TypographyPolicy, required : Bool) -> TypographyPolicy

#
TypographyPolicy::with_line_ratio_bounds

source
fn TypographyPolicy::with_line_ratio_bounds(self : TypographyPolicy, minimum_x100 : Int, maximum_x100 : Int) -> TypographyPolicy

#
TypographyPolicy::with_monotonic_requirement

source
fn TypographyPolicy::with_monotonic_requirement(self : TypographyPolicy, required : Bool) -> TypographyPolicy

#
TypographyPolicy::with_size_bounds

source
fn TypographyPolicy::with_size_bounds(self : TypographyPolicy, minimum : Int, maximum : Int) -> TypographyPolicy

#
ValidationPolicy

source
pub struct ValidationPolicy {
  min_colors : Int
  min_component_states : Int
  min_logo_width : Int
  require_metadata_license : Bool
  require_component_tokens : Bool
} derive(Eq, 
Debug)

#
ValidationPolicy::default

source

#
ValidationPolicy::strict

source

#
ValidationPolicy::with_min_colors

source
fn ValidationPolicy::with_min_colors(self : ValidationPolicy, count : Int) -> ValidationPolicy

#
ValidationPolicy::with_min_logo_width

source
fn ValidationPolicy::with_min_logo_width(self : ValidationPolicy, width : Int) -> ValidationPolicy

#
Voice

source
pub struct Voice {
  tone : String
  writing_principles : Array[String]
} derive(Eq, 
Debug)

#
Voice::has_principle

source
fn Voice::has_principle(self : Voice, phrase : String) -> Bool

#
Voice::is_complete

source
fn Voice::is_complete(self : Voice) -> Bool

#
Voice::principle_count

source
fn Voice::principle_count(self : Voice) -> Int

#
Voice::to_html

source
fn Voice::to_html(self : Voice) -> String

#
Voice::to_json

source
fn Voice::to_json(self : Voice) -> String

#
Voice::to_markdown

source
fn Voice::to_markdown(self : Voice) -> String

#
YamlParseResult

source
pub struct YamlParseResult {
  value : JsonValue?
  diagnostics : DiagnosticBag
} derive(Eq, 
Debug)

#
asset_extension

source
fn asset_extension(path : String) -> String

#
asset_has_supported_extension

source
fn asset_has_supported_extension(path : String, extensions : Array[String]) -> Bool

#
benchmark_fixture_json

source
fn benchmark_fixture_json(token_count : Int) -> String

#
boundary_report_json

source
fn boundary_report_json() -> String

#
boundary_report_markdown

source
fn boundary_report_markdown() -> String

#
cli_help

source
fn cli_help() -> String

#
cli_user_args

source
fn cli_user_args(args : Array[String]) -> Array[String]

#
compare_stable_names

source
fn compare_stable_names(left : String, right : String) -> Int

#
example_cli_commands

source
fn example_cli_commands() -> Array[String]

#
example_colors

source
fn example_colors() -> Array[String]

#
example_document_json

source
fn example_document_json(token_count : Int) -> String

#
example_document_sizes

source
fn example_document_sizes() -> Array[Int]

#
example_document_summary

source
fn example_document_summary(token_count : Int) -> String

#
example_document_yaml

source
fn example_document_yaml(token_count : Int) -> String

#
example_schema_document

source
fn example_schema_document() -> String

#
import_brand_book

source
fn import_brand_book(text : String, format : DocumentFormat) -> PipelineResult

#
import_brand_book_auto

source
fn import_brand_book_auto(text : String) -> PipelineResult

#
is_quoted

source
fn is_quoted(text : String) -> Bool

#
is_safe_asset_path

source
fn is_safe_asset_path(path : String) -> Bool

#
json_escape

source
fn json_escape(text : String) -> String

#
moonbit_brandbook

source
fn moonbit_brandbook() -> BrandBook

Build the bundled MoonBit brand book example.

#
moonbit_brandbook_with

source
fn moonbit_brandbook_with(name~ : String, tagline~ : String) -> BrandBook

Build the bundled example with a custom name and tagline.

#
normalize_asset_path

source
fn normalize_asset_path(path : String) -> String

#
normalize_identifier

source
fn normalize_identifier(text : String) -> String

#
parse_brand_document

source
fn parse_brand_document(text : String) -> BrandDocumentResult

#
parse_brand_document_as

source
fn parse_brand_document_as(text : String, format : DocumentFormat) -> BrandDocumentResult

#
parse_cli

source
fn parse_cli(args : Array[String]) -> CliParseResult

#
parse_json

source
fn parse_json(text : String) -> JsonParseResult

#
parse_json_with_limit

source
fn parse_json_with_limit(text : String, max_depth : Int) -> JsonParseResult

#
parse_yaml

source
fn parse_yaml(text : String) -> YamlParseResult

#
policy_catalog

source
fn policy_catalog() -> PolicyCatalog

#
policy_json

source
fn policy_json() -> String

#
policy_markdown

source
fn policy_markdown() -> String

#
public_api_contract

source
fn public_api_contract() -> ApiContract

#
public_api_json

source
fn public_api_json() -> String

#
public_api_markdown

source
fn public_api_markdown() -> String

#
run_benchmarks

source
fn run_benchmarks() -> BenchmarkReport

#
run_boundary_suites

source
fn run_boundary_suites() -> Bool

#
run_cli

source
fn run_cli(request : CliRequest, input : String?) -> CliResult

#
schema_child

source
fn schema_child(path : String, child : String) -> String

#
schema_index

source
fn schema_index(path : String, index : Int) -> String

#
schema_is_array_path

source
fn schema_is_array_path(path : String) -> Bool

#
schema_leaf

source
fn schema_leaf(path : String) -> String

#
schema_parent

source
fn schema_parent(path : String) -> String

#
schema_path

source
fn schema_path(parts : Array[String]) -> String

#
split_lines_preserve

source
fn split_lines_preserve(text : String) -> Array[String]

#
standard_boundary_suites

source
fn standard_boundary_suites() -> Array[BoundarySuite]

#
trim_ascii

source
fn trim_ascii(text : String) -> String

#
validate_angle_degrees

source
fn validate_angle_degrees(angle : Int) -> Bool

#
validate_hex_token

source
fn validate_hex_token(text : String) -> Bool

#
validate_identifier

source
fn validate_identifier(text : String) -> Bool

#
validate_name

source
fn validate_name(text : String, max_length : Int) -> Bool

#
validate_non_negative_integer

source
fn validate_non_negative_integer(value : Int) -> Bool

#
validate_pipeline

source
fn validate_pipeline(book : BrandBook) -> PipelineResult

#
validate_positive_integer

source
fn validate_positive_integer(value : Int) -> Bool

#
version

source
fn version() -> String

A compact semantic version for generated brand guides.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io