# `MishkaDocument.WorkspaceVersion`
[🔗](https://github.com/mishka-group/mishka_document/blob/v0.0.1/lib/mishka_document/resources/workspace_version.ex#L5)

Manages workspace versions in the MishkaDocument plugin.

This resource represents different versions of a workspace, allowing version control
and history tracking for workspace configurations. Each version belongs to a specific
workspace and can have various statuses (draft, alpha, beta, stable, archived).

Versions support semantic versioning patterns (e.g., "0.0.1", "1.0.0") and can be
cloned from existing versions. The resource tracks which version is the latest for
a given workspace and maintains publication timestamps.

Database-level constraints ensure data integrity with version number validation.
Multi-tenant isolation ensures versions are properly segregated between sites through
their parent workspace relationship.

# `t`

```elixir
@type t() :: %MishkaDocument.WorkspaceVersion{
  __lateral_join_source__: term(),
  __meta__: term(),
  __metadata__: term(),
  __order__: term(),
  aggregates: term(),
  calculations: term(),
  clone_numbers: term(),
  cloned_versions: term(),
  dated?: term(),
  description: term(),
  effective_permissions: term(),
  id: term(),
  inserted_at: term(),
  is_latest_for_version: term(),
  lineage_as_new: term(),
  lineage_as_source: term(),
  master_sections: term(),
  master_source_version: term(),
  master_workspace: term(),
  published_at: term(),
  sections: term(),
  site: term(),
  site_id: term(),
  source_version: term(),
  source_version_id: term(),
  status: term(),
  tenant_sections: term(),
  updated_at: term(),
  version_name: term(),
  version_number: term(),
  workspace: term(),
  workspace_id: 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.

# `clone_allowed?`

```elixir
@spec clone_allowed?(map() | nil) :: boolean()
```

Whether `actor` may clone a version on the dashboard: it holds the workspace area, which writes
versions, and the section area, which writes their pages and notes — what `:clone` and
`:master_clone` ask.

# `default_short_name`

# `delete_confirm`

```elixir
@spec delete_confirm(map()) :: String.t()
```

What the delete button asks before a version is deleted: a warning naming every version cloned
from it (`:clone_numbers`), which goes with it, or the plain question when there is none.

# `detach_confirm`

```elixir
@spec detach_confirm(map()) :: String.t()
```

What "Make independent" asks before it unties a version from the one it was cloned from.

# `form_site_id`

```elixir
@spec form_site_id(map()) :: String.t() | nil
```

The site the version form writes for: a master's chosen site, a site user's own.

# `form_workspace_id`

```elixir
@spec form_workspace_id(map()) :: String.t() | nil
```

The document the version form is for: the one it was opened with, or the edited record's.
`nil` when it names none, so its pickers offer no version.

# `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?`

# `source_label`

```elixir
@spec source_label(map()) :: String.t()
```

How a version is named in a list of versions to pick: its number, and its name when it has one.

---

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