# `MishkaBlog.TeamPermission`
[🔗](https://github.com/mishka-group/mishka_blog/blob/v0.0.1/lib/mishka_blog/resources/team_permission.ex#L5)

Manages the many-to-many relationship between teams and permissions.

This resource serves as the join table that attaches permissions to teams. Each record is one
permission attached to one team. Team members do not inherit it: every gate reads the
permissions a user holds itself.

The resource implements upsert functionality through the assign action, preventing
duplicate permission assignments. The unique constraint on team_id and permission_id pairs
ensures that each team can only have a permission assigned once.

Reading a row needs the blog's post area, `admin:<surface>:blog:post`. Writing or removing one also needs the
permission area on the request's surface, and a site's admin attaches only permissions it holds
itself (`MishkaCmsCore.Accounts.Validations.GrantWithinActorScope`) — whether through
`MishkaBlog.Team` or directly.

# `t`

```elixir
@type t() :: %MishkaBlog.TeamPermission{
  __lateral_join_source__: term(),
  __meta__: term(),
  __metadata__: term(),
  __order__: term(),
  aggregates: term(),
  calculations: term(),
  created_at: term(),
  id: term(),
  permission: term(),
  permission_id: term(),
  team: term(),
  team_id: term(),
  team_in_any_state: term()
}
```

# `default_short_name`

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

# `primary_key_matches?`

---

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