# `MishkaCmsCore.Runtime.Layout`
[🔗](https://github.com/mishka-group/mishka_cms_core/blob/v0.0.1/lib/mishka_cms_core/runtime/resources/layout.ex#L5)

Manages layout templates in the MishkaCMS runtime system.

This resource handles the creation and management of layout templates that provide consistent
structure and styling across pages. Layouts serve as wrappers for page content, defining
common elements like headers, footers, navigation, and resource links. Each layout can be
scoped to a specific site or made globally available, with path-based matching determining
which layout applies to which pages based on URL patterns.

Layouts support dynamic content sections, external resource management (CSS, JavaScript),
and comprehensive SEO tag configuration. They integrate with the runtime compiler to generate
optimized template modules that render efficiently. The resource implements helper functions
for dynamic behavior, precompilation options for performance optimization, and priority-based
matching when multiple layouts could apply to the same path.

Database-level constraints ensure data integrity including path validation and prevention
of modifications to archived layouts. The resource provides soft deletion through archival,
allowing layouts to be temporarily disabled and later restored. Multi-tenant support ensures
proper isolation between sites while allowing shared global layouts for common functionality.

# `t`

```elixir
@type t() :: %MishkaCmsCore.Runtime.Layout{
  __lateral_join_source__: term(),
  __meta__: term(),
  __metadata__: term(),
  __order__: term(),
  active: term(),
  aggregates: term(),
  archived_at: term(),
  calculations: term(),
  content: term(),
  description: term(),
  example: term(),
  extra: term(),
  format: term(),
  helpers: term(),
  id: term(),
  inserted_at: term(),
  is_global: term(),
  latest_version: term(),
  layout_module: term(),
  name: term(),
  pages: term(),
  paper_trail_versions: term(),
  path: term(),
  permissions: term(),
  precompile: term(),
  preview_token: term(),
  priority: term(),
  recent_versions: term(),
  resource_links: term(),
  seo_tags: term(),
  site: term(),
  site_id: term(),
  sorted_versions: term(),
  template: term(),
  updated_at: term(),
  version_count: term(),
  version_preview: term()
}
```

# `__guarded_change__`

Apply the full GuardedStruct pipeline (sanitize → validate → derive →
main_validator) to `attrs` and return either `{:ok, transformed_attrs}`
or `{:error, errors}`. Wire this into an `Ash.Resource.Change` to plug
guardedstruct rules into Ash's changeset pipeline.

The function is named `__guarded_change__` because it does more than
validate — it can also transform values (trim, downcase, slugify,
auto-fill, etc.) before they reach the data layer.

# `__guarded_field_meta__`

O(1) lookup of a field's compile-time metadata by name. Returns
`nil` for unknown fields.

# `__guarded_field_name_set__`

Compile-time-baked `MapSet` of every field name owned by the
`guardedstruct` block. Used by `GuardedStruct.AshResource.Change`
to decide, in O(1), whether a key in `changeset.atomics`
belongs to the pipeline.

# `default_short_name`

# `format_badge_config`

Format → badge colours and labels, in the shape the Gervaz `:badge` column type expects. Shared by the
Format table column and the layout detail modal so both draw the same badge from one definition.

# `generate_token`

Unguessable token for the shareable preview URL (generated on create).

# `input`

```elixir
@spec input(values :: map() | Keyword.t()) :: map() | no_return()
```

Validates that the keys in the provided input are valid for at least one action on the resource.

Raises a KeyError error at compile time if not. This exists because generally a struct should only ever
be created by Ash as a result of a successful action. You should not be creating records manually in code,
e.g `%MyResource{value: 1, value: 2}`. Generally that is fine, but often with embedded resources it is nice
to be able to validate the keys that are being provided, e.g

```elixir
Resource
|> Ash.Changeset.for_create(:create, %{embedded: EmbeddedResource.input(foo: 1, bar: 2)})
|> Ash.create()
```

# `input`

```elixir
@spec input(values :: map() | Keyword.t(), action :: atom()) :: map() | no_return()
```

Same as `input/1`, except restricts the keys to values accepted by the action provided.

# `json_api_match_route`

# `primary_key_matches?`

---

*Consult [api-reference.md](api-reference.md) for complete listing*