Enum VisibilityTier 

pub enum VisibilityTier {
    Public,
    Internal,
    TeamScoped {
        team_id: String,
    },
    Restricted {
        scope_label: String,
    },
    Private {
        scope_label: String,
    },
}

Content-side visibility tier. Shared by annotations, discussions, and states so the per-commit visibility tiers and annotation/discussion visibility draw from one vocabulary rather than parallel enums.

Variants

Public

Internal

TeamScoped

Fields

team_id: String

Restricted

Fields

scope_label: String

Private

The strictest tier: withheld from every audience — including the otherwise all-seeing Internal audience — except the one holder of the matching Restricted(scope_label). Used for embargoed per-state commit visibility, where even internal callers must not see the content. The who-sees-what arm lives in repo::visibility::visible, placed above the (_, Internal) => true arm so the embargo holds.

Fields

scope_label: String

Implementations

impl VisibilityTier

pub fn as_str(&self) -> &'static str

Stable wire/storage token for the tier discriminant. The labelled variants collapse to their kind name here; the label travels in a separate field. Shared by the discussion RPC vocabulary and the state-visibility signing payload, so it must stay stable.

pub fn restrictiveness_rank(&self) -> u8

Restrictiveness ordering used by the visibility promote monotonicity check (heddle#317). Lower rank = LESS restrictive (the tier reaches a broader audience):

tier	rank	audience reach
Public	0	every audience (least restrictive)
Internal	1	the workspace-internal set (+ every team)
TeamScoped	2	one named team
Restricted	3	one named scope label
Private	4	only the matching scope holder (most restrictive, even Internal is excluded)

This is the defined total order for “less restrictive”, consistent with spike #266 §5.2 (Internal content is one of the least-restrictive values; Private the most — it is the embargo tier that withholds from every audience including Internal). The labelled variants compare by rank only — a lateral move between two teams / two scope labels is the same rank, hence not strictly less restrictive, and must go through set rather than promote.

pub fn is_strictly_less_restrictive_than(&self, other: &Self) -> bool

true iff self is strictly less restrictive than other — i.e. a promote from other to self is a valid opening transition. A narrowing (self more restrictive) or lateral (equal rank, including a different team/scope label at the same rank) change returns false and must be expressed with set. See restrictiveness_rank.

Trait Implementations

impl Clone for VisibilityTier

fn clone(&self) -> VisibilityTier

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VisibilityTier

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for VisibilityTier

fn default() -> VisibilityTier

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for VisibilityTier

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for VisibilityTier

impl PartialEq for VisibilityTier

fn eq(&self, other: &VisibilityTier) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for VisibilityTier

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for VisibilityTier