domain

type AccessBinding ¶

type AccessBinding struct {
	ID              AccessBindingID
	SubjectType     SubjectType
	SubjectID       SubjectID
	RoleID          RoleID
	ResourceType    ResourceType
	ResourceID      string              // opaque id (any prefix, cross-service OK)
	Scope           Scope               // RBAC v2 — anchor tier (CLUSTER/ACCOUNT/PROJECT)
	Status          AccessBindingStatus // PENDING|ACTIVE|REVOKED
	ExpiresAt       *time.Time          // nullable — TTL
	GrantedByUserID UserID              // audit
	RevokedAt       *time.Time          // nullable
	RevokedByUserID *UserID             // nullable
	CreatedAt       time.Time

	// MaterializedAt — OUTPUT-ONLY. When this binding's per-object access last
	// became live: MAX(updated_at) over its ACTIVE rows in
	// access_binding_target_members (the reconciler's ledger). Zero when nothing
	// has materialized yet.
	//
	// It exists because Kachō is eventually-consistent by contract: Operation.done
	// means the binding row is DURABLE, never that the FGA tuples are visible
	// (gating done on downstream visibility is forbidden — ban #9). In that window
	// the grantee's 403 is byte-identical to a real denial, leaving the granting
	// admin with nothing to distinguish "propagating" from "wrong grant" and
	// nothing to poll. This field is the observable — NOT a barrier: it is filled
	// by the read path from an already-written ledger and never blocks a write.
	//
	// Legitimately zero forever for a binding that materializes no per-object
	// membership (CLUSTER scope — served by the flat short-circuit; a legacy
	// permissions-only role with no authored rules[]). Zero therefore means "no
	// ACTIVE per-object member", NOT "the grant is broken".
	//
	// Not persisted on the access_bindings row; filled by the read-side batch
	// projection, like Subjects.
	MaterializedAt time.Time

	// DeletionProtection guards the binding from Delete (RBAC explicit-model 2026
	// P6 — D-10, by the image of vpc.address.deletion_protection). The owner
	// auto-binding created on Account.Create sets it true; Delete on a protected
	// binding → FAILED_PRECONDITION (sync pre-check + atomic CAS backstop). Cleared
	// via Update(update_mask=["deletion_protection"]) (C-03). Default false.
	DeletionProtection bool

	// GrantedRelation — ВТОРАЯ ФОРМА выдачи: имя отношения модели, выдаваемое
	// напрямую на области выдачи, взаимоисключающе с RoleID (ограничение БД
	// `access_bindings_grant_form_ck`). Роль раздаёт ГЛАГОЛЫ через свои правила, а
	// встроенные права платформы выражены именованными отношениями
	// (`system_viewer`, `quota_reader`, `viewer` на кластере) — подобрать роль под
	// каждое означало бы завести роли с пустыми правилами.
	//
	// Непусто ТОЛЬКО у системной выдачи: отношение — внутреннее имя, от которого
	// зависит решение о доступе, и выдавать его вправе только платформа. На вход
	// создания это поле не принимается вовсе — его нет в запросе, поэтому «принято
	// и проигнорировано» здесь невозможно by construction.
	GrantedRelation string

	// System — выдача заведена платформой (встроенный доступ: права служебных
	// учёток, публичное чтение справочников). OUTPUT-ONLY на публичном контракте.
	//
	// Отвечает на вопрос «кто выдал» точнее, чем подставленная учётка: выдал не
	// человек, а платформа, поэтому GrantedByUserID у такой выдачи пуст, и это не
	// пробел аудита, а его содержание.
	System bool

	// Subjects — the full multi-subject set (RBAC rules-model 2026).
	// Persisted in the access_binding_subjects child table; SubjectType/
	// SubjectID above remain the legacy single = Subjects[0] (projection +
	// the active-grant UNIQUE anchor). Empty on a row read without the child
	// load — read-side Get/List fills it. On Create the use-case
	// NormalizeSubjects-resolves it from the request before persisting.
	Subjects []Subject

	// Labels — tenant-facing метки САМОГО ресурса AccessBinding. Делают
	// AccessBinding label-selectable наравне с account/project (ARM_LABELS-грант
	// на iam.accessBinding → v_list по `labels @> matchLabels`; List фильтрует
	// viewer ∪ v_list).
	Labels Labels

	// Target — WHICH objects under the scope-anchor the grant applies to
	// (redesign-2026 F8). AllInScope = whole anchor (incl. future); Resources =
	// closed per-object set. The zero value is treated as AllInScope (legacy /
	// internal rows); the public Create RPC rejects a missing target (least-priv).
	Target AccessTarget
}

AccessBinding — link (subject_type, subject_id) ↔ role_id ↔ (resource_type, resource_id) with lifecycle fields (status, expires_at, granted_by, revoked_at/revoked_by).

State machine: PENDING → ACTIVE → REVOKED (terminal). Transitions are atomic CAS-style UPDATEs (no TOCTOU). REVOKED is irreversible via `WHERE status IN ('PENDING','ACTIVE')`.

DB partial UNIQUE access_bindings_active_grant_uniq (migration 0003; WHERE revoked_at IS NULL) → strict INSERT: a duplicate active grant raises ErrAlreadyExists with verbatim text «these permissions are already granted to <subject_id> on <res_type>:<res_id>». Re-grant after revoke is allowed (revoked rows are out of the partial UNIQUE scope).

func (b AccessBinding) StructuralParent() (StructuralTuple, bool)

project:<resourceID>  →  project  →  iam_access_binding:<id>
account:<resourceID>  →  account  →  iam_access_binding:<id>
cluster:<resourceID>  →  cluster  →  iam_access_binding:<id>

func (b AccessBinding) Validate() error

type AccessBindingID ¶

type AccessBindingID string

type AccessBindingStatus ¶

type AccessBindingStatus string

AccessBindingStatus — enum lifecycle (migration 0011 CHECK).

const (
	AccessBindingStatusPending AccessBindingStatus = "PENDING"
	AccessBindingStatusActive  AccessBindingStatus = "ACTIVE"
	AccessBindingStatusRevoked AccessBindingStatus = "REVOKED"
)

func (s AccessBindingStatus) Validate() error

type AccessTarget ¶

type AccessTarget struct {
	AllInScope bool          // whole-anchor grant (incl. future objects)
	Resources  []ResourceRef // per-object grant (mutually exclusive with AllInScope)
}

AccessTarget is the object-selection of an AccessBinding (F8). Exactly one arm is meaningful; the zero value is the whole-anchor grant (AllInScope semantics).

func (t AccessTarget) Contains(dottedType, id string) bool

func (t AccessTarget) Digest() string

func (t AccessTarget) IsEmpty() bool

func (t AccessTarget) ResourceIDsForTypes(types []string) []string

func (t AccessTarget) Validate() error

type Account ¶

type Account struct {
	ID          AccountID
	Name        AccountName
	Description Description
	Labels      Labels
	OwnerUserID UserID
	CreatedAt   time.Time
}

Account — top-level tenant («организация» как товар продукта IAM). Замещает прежнюю связку tenant+folder из retired kacho-resource-manager. Уникальное имя глобально (DB UNIQUE accounts_name_unique).

FK: owner_user_id → users(id) ON DELETE RESTRICT. Удаление RESTRICT при наличии Project / ServiceAccount / Group / custom Role.

func (a Account) StructuralFacts() []StructuralTuple

cluster:<singleton>  →  cluster  →  account:<id>     (levels 1-2 reach it here)
user:<owner>         →  owner    →  account:<id>

func (a Account) Validate() error

type AccountID ¶

type AccountID string

AccountID / ProjectID / ... — newtypes over string, never bare ids.

type AccountName ¶

type AccountName string

Names — every newtype has its own regex.

func (n AccountName) Validate() error

type Arm ¶

type Arm int

Arm classifies a rule's selector arm.

const (
	ArmAnchor Arm = iota
	ArmNames
	ArmLabels
)

type AssertionClient ¶

type AssertionClient struct {
	// ID — НАШ идентификатор строки реестра. Им и только им клиент себя
	// называет: он же издатель и субъект утверждения.
	ID string
	// Kind — из какой таблицы реестра строка прочитана.
	Kind AssertionClientKind
	// OwnerID — принципал, от чьего имени клиент получает токен.
	OwnerID string
	// PublicKeyPEM — зарегистрированный открытый ключ.
	PublicKeyPEM string
	// Algorithm — ЗАРЕГИСТРИРОВАННЫЙ алгоритм. Пустое значение — законный вход
	// схемы, и означает оно «ключа нет», а НЕ «любой алгоритм».
	Algorithm string
	// ExpiresAt — момент истечения клиента в Unix-секундах; 0 означает
	// «бессрочно», и это законное состояние схемы (колонка допускает NULL).
	ExpiresAt int64
	// Отзыв ключа НЕ является здесь полем, и это не упущение: колонки отзыва в
	// схеме обеих таблиц НЕТ — отзыв выражен СНЯТИЕМ СТРОКИ. Завести поле
	// значило бы описать состояние, которого схема не допускает, и построить
	// на нём пробу, которую нечем поставить (F1 §14 п. 2). Отозванный клиент
	// не резолвится вовсе, и отказ наступает на том же шаге, что для
	// несуществующего, — то есть требование «отозванный токена не получает»
	// выполняется by construction, а не проверкой поля.
	// OwnerActive — владелец в состоянии ACTIVE. Не-ACTIVE — это ДВА значения
	// словаря (PENDING и BLOCKED), и оба обязаны давать один исход.
	OwnerActive bool
	// DeclaredAudiences — сужение адресатов, ОБЪЯВЛЕННОЕ заказчиком ключа при
	// его выдаче (`IssueSAKeyRequest.audience`, задача #1136).
	//
	// ПУСТОЙ ПЕРЕЧЕНЬ ОЗНАЧАЕТ «СУЖЕНИЯ НЕ ОБЪЯВЛЕНО», А НЕ «ЛЮБОЙ АДРЕСАТ», и
	// это НЕ тот класс, что пустой список доверенных отправителей. Там пустое
	// значение снимало единственный контроль; здесь оно оставляет ВНЕШНЮЮ
	// границу — объявленный посадкой перечень адресатов, который страж старта
	// требует непустым и без которого выдача не строится вовсе. Сужение ключа
	// действует ВНУТРИ этой границы и никогда её не расширяет: адресат, которого
	// посадка не объявила, не выдаётся ни одному ключу, как бы он ни объявился.
	//
	// У клиента пользовательского токена перечня нет BY CONSTRUCTION: адресата
	// его токена проставляет сам сервис из своей настройки, и заказчик не вправе
	// назвать его вовсе (решение Р2, `interactive_client.proto`). Поэтому сужать
	// там нечем, и пустое значение на том пути — не умолчание, а отсутствие
	// предмета.
	DeclaredAudiences []string
}

AssertionClient — строка реестра, способная предъявить утверждение.

Зеркального значения (идентификатора клиента во внешнем сервере) здесь НЕТ, и это не упущение: оно не участвует в разрешении клиента ни как второй ключ поиска, ни как запасной (приёмка F2 §2.1). Субъект с двумя именами дал бы две записи журнала об одном действии и два ключа однократности на одно утверждение — то есть отменил бы однократность, сохранив её форму.

func (c AssertionClient) CanPresentAssertion() bool

type AssertionClientKind ¶

type AssertionClientKind string

AssertionClientKind — вид клиента, способного доказать владение ключом.

Словарь ЗАКРЫТ и содержит ровно те виды, у которых в схеме есть ключевой материал. Интерактивного клиента здесь нет НАМЕРЕННО: у него нет способа доказать владение ключом by construction, поэтому он не резолвится ни во что, и отказ наступает на том же шаге, что и для несуществующего клиента (приёмка F2 §2.9). Формулировка «нашли строку, ключ пуст» потребовала бы, чтобы кто-то поддерживал в третьей таблице инвариант «ключа быть не должно»; инвариант, который надо поддерживать, ломается, а выраженный отсутствием таблицы на пути — нет.

const (
	// AssertionClientUser — клиент, через который выдаётся токен пользователя.
	AssertionClientUser AssertionClientKind = "user"
	// AssertionClientServiceAccount — клиент ключа служебной учётки.
	AssertionClientServiceAccount AssertionClientKind = "service_account"
)

func AssertionClientKinds() []AssertionClientKind

type AssignableRole ¶

type AssignableRole struct {
	RoleID      RoleID
	Name        RoleName
	Description Description
	IsSystem    bool
	ScopeGroup  RoleScopeGroup
	CreatedAt   time.Time
}

AssignableRole — the lean projection of a Role for the grant-form picker Carries only publicly-safe fields the UI needs to render + group the picker (id / resolved name / description / is_system / server-computed scope_group / created_at) — NO permissions array and no infra-sensitive fields. ScopeGroup is computed via ScopeGroupOf.

type AuditEventID ¶

type AuditEventID string

AuditEventID — идентификатор записи журнала: `evt_` плюс 20…30 символов crockford-base32 (ограничение `audit_outbox_id_check`, миграция `0001_initial.sql`).

Тело СЛУЧАЙНО, а не производно от времени: производитель (`pg.newAuditEventID`) берёт 14 байт у источника случайности и печатает из них 22 символа. Порядок по идентификатору поэтому НЕ является порядком по времени; сортировать журнал надо по `created_at`. Прежняя редакция называла его ULID — то есть обещала ровно ту сортируемость, которой нет.

func (id AuditEventID) Validate() error

type AuditOutboxEntry ¶

type AuditOutboxEntry struct {
	ID              AuditEventID
	EventType       EventTypeName
	TenantAccountID *AccountID
	EventPayload    json.RawMessage
	Status          AuditOutboxStatus
	Attempts        int
	CreatedAt       time.Time
	NextAttemptAt   time.Time
}

AuditOutboxEntry — строка журнала аудита `kaname.audit_outbox` (заведён миграцией `0001_initial.sql`), дописываемая только вперёд.

Что происходит на самом деле ¶

Строка ложится в ТУ ЖЕ транзакцию, что и мутация домена, и оттуда вывозится в приёмник журнала — поток структурных записей службы (`services/iam/cmd/kaname/audit_shipper_wiring.go`, механизм — `pkg/audit`). Состояние строки после этого помечено доставленным, а состояние очереди целиком снимает периодический сканер (`services/iam/cmd/kaname/outbox_metrics_wiring.go`).

Здесь было описано ОТСУТСТВИЕ доставки — у него больше нет предмета ¶

Прежняя редакция объясняла, почему дренаж неконструируем: приёмника аудита не существовало ни одного, и из четырёх объявленных состояний достижимо было ровно одно. Оба утверждения были верны на день записи и перестали быть верными вместе с приёмником (#812): состояний теперь ДВА и оба достижимы, потому что словарь сужен до того, что продукт производит.

Здесь стояло описание, неверное ЧЕТЫРЕЖДЫ ¶

Прежняя редакция объявляла: дренаж отправляет строки в топик брокера; журнал заведён миграцией 0013; идентификатор — ULID; ULID сортируется по времени. Верно из этого ноль. Брокера в продукте нет и он запрещён non-negotiable #7; миграция 0013 — про снятие перечня условий обхода; идентификатор собирается из СЛУЧАЙНЫХ байт (`newAuditEventID`, 22 символа crockford-base32), то есть по времени не сортируется ни в каком порядке. Опасен был не сам текст, а его направление: он описывал систему СЛОЖНЕЕ и исправнее, чем она есть, поэтому читатель уходил искать дренаж и топик вместо того, чтобы увидеть, что доставки нет вовсе.

func (e AuditOutboxEntry) Validate() error

type AuditOutboxStatus ¶

type AuditOutboxStatus string

AuditOutboxStatus — состояние ДОСТАВКИ строки журнала.

Значений ровно два, и столько же допускает ограничение таблицы (миграция `20260823001500_audit_journal_gets_its_receiver.sql`). Прежде их объявлялось четыре: «в полёте» и «отказ» не писал никто и никогда — полёта не существует, потому что строка держится блокировкой своей транзакции от клейма до пометки, а терминального отказа не существует, потому что у приёмника нет класса «не приму никогда». Значение, которого продукт произвести не умеет, обещает подсистему, которой нет.

const (
	AuditOutboxStatusPending AuditOutboxStatus = "pending"
	AuditOutboxStatusSent    AuditOutboxStatus = "sent"
)

func (s AuditOutboxStatus) Validate() error

type BasicCredential ¶

type BasicCredential struct {
	// PrincipalType — "user" | "service_account".
	PrincipalType string
	PrincipalID   string
	DisplayName   string
	// CredentialID — идентификатор СТРОКИ; им адресуется отзыв.
	CredentialID string
	ExpiresAt    time.Time
}

BasicCredential — вердикт авторитета о годном предъявленном удостоверении.

type Cluster ¶

type Cluster struct {
	ID          ClusterID
	Name        ClusterName
	Description Description
	CreatedAt   time.Time
}

Cluster — singleton (id = `cluster_root`). Корень иерархии cluster → account → project → resource. Используется как объект модели прав для `cluster:cluster_root#system_admin@user:usr_xxx`.

func (c Cluster) Validate() error

type ClusterAdminEntry ¶

type ClusterAdminEntry struct {
	ClusterAdminGrantID string
	SubjectType         string
	SubjectID           string
	SubjectEmail        string
	SubjectDisplayName  string
	GrantedByUserID     string
	GrantedByEmail      string // "" when granted_by == "bootstrap"
	GrantedAt           time.Time
}

ClusterAdminEntry — read-projection of one active cluster-admin grant with denormalised user fields (subject email/display_name, granter email) resolved by the ListActive read-adapter's users JOIN. Pure domain view used by the InternalClusterService.ListAdmins use-case + handler; the pg adapter maps its rows INTO this type so the use-case/handler never import the pgx adapter package (Clean-Architecture dependency rule — the port speaks in domain types).

Denormalised fields (SubjectEmail / SubjectDisplayName / GrantedByEmail) are output-only mirrors; the authoritative subject/granter ids are SubjectID / GrantedByUserID.

type ClusterAdminGrant ¶

type ClusterAdminGrant struct {
	ID           ClusterAdminGrantID
	ClusterID    ClusterID
	SubjectType  GrantSubjectType
	SubjectID    SubjectID
	GrantedBy    string // 'bootstrap' либо user_id (verbatim text)
	GrantedAt    time.Time
	GrantedUntil *time.Time // NULL = permanent
}

ClusterAdminGrant — permanent root grant. Один источник истины для FGA-tuple `cluster_admin`.

Partial UNIQUE (subject_type, subject_id) WHERE granted_until IS NULL гарантирует на DB-уровне, что **permanent** grant у одного subject — один. Temporary grants не входят в модель — есть только permanent.

func (g ClusterAdminGrant) IsActive() bool

func (g ClusterAdminGrant) Validate() error

type ClusterAdminGrantID ¶

type ClusterAdminGrantID string

ClusterAdminGrantID — self-validating newtype, format `cag_<17-crockford>`.

func (id ClusterAdminGrantID) Validate() error

type ClusterID ¶

type ClusterID string

ClusterID — fixed literal `cluster_root` (singleton constraint в DB).

func (id ClusterID) Validate() error

type ClusterName ¶

type ClusterName string

ClusterName — отображаемое имя singleton-кластера: длина 1..64 и БОЛЬШЕ ничего. Здесь стояло «kebab-case», и это было обещанием алфавита, которого проверка не делает ни в одной ветке.

Форму имени ресурса (`pkg/validate/nameform`) поле НЕ несёт намеренно: оно не задаётся клиентом — значение пишет посевная миграция, а у службы кластера нет глагола, который бы его менял.

func (n ClusterName) Validate() error

type CountableKind ¶

type CountableKind struct {
	Kind    LimitKind
	Carrier LimitCarrier
}

CountableKind — one catalogue record: WHAT is counted and WHERE it is counted.

func CountableEntries() []CountableKind

type CredentialKind ¶

type CredentialKind string

CredentialKind — ЧЕМ УДОСТОВЕРЕНИЕ СЕБЯ ПРЕДЪЯВЛЯЕТ (задача #1142, приёмка BAT-1 §2.5, §4.1).

Значение — то же, что лежит в колонке `credential_kind` обеих таблиц удостоверений: второго написания не заводится. Вид ЗАПИСЫВАЕТСЯ при вставке и читателем НЕ вычисляется — правило вывода по содержимому живёт ровно на одном пути (обратное заполнение существующих строк) и после него не применяется никогда.

const (
	// CredentialKindUnspecified — вид не назван вызывающим. Встречается ТОЛЬКО
	// во входе выдачи и разрешается сохранённым поведением; в строке
	// удостоверения не бывает.
	CredentialKindUnspecified CredentialKind = ""

	// CredentialKindKeypair — ключевая пара ES256: вызывающий сам собирает и
	// подписывает `client_assertion` и обменивает его.
	CredentialKindKeypair CredentialKind = "KEYPAIR"

	// CredentialKindSecret — однострочный непрозрачный секрет, предъявляемый
	// как есть.
	CredentialKindSecret CredentialKind = "SECRET"

	// CredentialKindFederated — удостоверение предъявляет ВНЕШНИЙ издатель по
	// перечню доверенных субъектов; ни материала, ни секрета у нас нет.
	CredentialKindFederated CredentialKind = "FEDERATED"

	// CredentialKindLegacy — строка прежнего потока. НЕ ВЫДАЁТСЯ ни одним
	// глаголом; появляется только обратным заполнением.
	CredentialKindLegacy CredentialKind = "LEGACY"
)

func ResolveIssuedKind(asked CredentialKind, hasTrustedSubjects, federationSupported bool) (CredentialKind, error)

func (k CredentialKind) IsIssuable() bool

func (k CredentialKind) String() string

type Description ¶

type Description string

func (d Description) Validate() error

type DisplayName ¶

type DisplayName string

func (d DisplayName) Validate() error

type EffectiveLimit ¶

type EffectiveLimit struct {
	Kind  LimitKind
	Value int64
	// Carrier — ГДЕ этот вид считается: корень аренды (`project` / `account`)
	// либо двухчастный токен родительского типа.
	//
	// Едет вместе с величиной, потому что вывести его на стороне потребителя
	// НЕЛЬЗЯ: форма токена носителя не определяет (`iam.project` — двухчастный
	// вид, чей носитель не проект), а догадка здесь не отказывает громко — она
	// считает верные строки против неверного владельца, и потребление такой
	// строки не наполняется никогда.
	//
	// Пустым не бывает: вид вне каталога до этой структуры не доходит.
	Carrier       LimitCarrier
	SourceScope   LimitScope
	SourceScopeID string
}

EffectiveLimit — one resolved ceiling plus the scope it was won at.

The source travels with the value because an operator asking "why does this project stop at four" cannot otherwise tell a project override from an account one from the platform default without re-reading all three scopes by hand.

func ResolveEffective(service string, stated []Limit) []EffectiveLimit

type Email ¶

type Email string

func (e Email) Validate() error

type EventTypeName ¶

type EventTypeName string

EventTypeName — `^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$` (CHECK).

func (n EventTypeName) Validate() error

type ExternalSubject ¶

type ExternalSubject string // OIDC sub

func (s ExternalSubject) Validate() error

type FeedSource ¶

type FeedSource int8

FeedSource — where the reconciler reads candidate objects for a selectable type (D7).

const (
	// FeedMirror — candidates read from kaname.resource_mirror (labels @>
	// matchLabels); containment from mirror.parent_* (D7). Mirror-fed types can be
	// PENDING_VERIFICATION (object not yet mirrored). Consumer-owned resources:
	// compute / vpc / loadbalancer.
	FeedMirror FeedSource = iota
	// FeedIAMDirect — candidates read SAME-DB from IAM's own resource table;
	// containment via iam-hierarchy (project ⊑ account ⊑ cluster). Never PENDING
	// (the object is always in its own table the instant it exists). Покрывает ВСЕ
	// iam-native типы (любой `iam.*`): account / project / user / serviceAccount /
	// group / role / accessBinding — все label-selectable под единой моделью.
	FeedIAMDirect
)

func FeedSourceForType(objectType string) FeedSource

type GrantSubjectType ¶

type GrantSubjectType string

GrantSubjectType — enum: user|service_account (NOT group: cluster-admin grant — strictly individual identity for audit). Backed by migration 0011 CHECK.

const (
	GrantSubjectTypeUser           GrantSubjectType = "user"
	GrantSubjectTypeServiceAccount GrantSubjectType = "service_account"
)

func (t GrantSubjectType) Validate() error

type Group ¶

type Group struct {
	ID          GroupID
	AccountID   AccountID
	Name        GroupName
	Description Description
	Labels      Labels
	CreatedAt   time.Time
}

Group — Account-scoped (account_id FK ON DELETE RESTRICT), имеет members (User или ServiceAccount — полиморфно через `group_members.member_type`). Используется в AccessBinding для упрощения раздачи прав.

func (g Group) Validate() error

type GroupID ¶

type GroupID string

type GroupMember ¶

type GroupMember struct {
	GroupID    GroupID
	MemberType SubjectType // user | service_account (group из enum'а исключен)
	MemberID   SubjectID
	AddedAt    time.Time
}

GroupMember — связка group_id ↔ (member_type, member_id). Целостность member_id обеспечивается DB-триггером `group_members_member_exists_trg` (нет полиморфного FK в Postgres).

func (m GroupMember) Validate() error

type GroupName ¶

type GroupName string

func (n GroupName) Validate() error

type InteractiveClient ¶

type InteractiveClient struct {
	ID          InteractiveClientID
	CreatedAt   time.Time
	Name        InteractiveClientName
	Description Description
	Labels      Labels

	// RedirectURIs — where the provider may deliver an authorization code.
	// At least one, every one an absolute https:// URL.
	RedirectURIs []string
	// PostLogoutRedirectURIs — optional; same https:// rule when present.
	PostLogoutRedirectURIs []string

	// ClientID — provider-side client id (output-only).
	ClientID string
	// Audiences — stamped by iam from its own configuration (output-only).
	Audiences []string
	// GrantTypes — always exactly authorization_code + refresh_token (output-only).
	GrantTypes []string
	// TokenEndpointAuthMethod — provider-side auth method (output-only).
	TokenEndpointAuthMethod string

	Status InteractiveClientStatus
}

InteractiveClient — the OAuth2 client through which a HUMAN completes an interactive sign-in ceremony.

Provider-side fields (ClientID, Audiences, GrantTypes, TokenEndpointAuthMethod) are OUTPUT-ONLY: they are decided by iam and the identity provider, never by the caller. Audiences in particular is a decision, not an omission — see Р2 in the acceptance: a field that can be set but cannot be set CORRECTLY is a field without a reader, and one that can be set incorrectly breaks the edge silently.

func (c InteractiveClient) Validate() error

type InteractiveClientID ¶

type InteractiveClientID string

InteractiveClientID — id of an InteractiveClient. Hyphen canon `ic-<17>` (ids.PrefixInteractiveClientHyphen), immutable for the life of the resource and the only externally addressable identity (core rule #15).

type InteractiveClientName ¶

type InteractiveClientName string

InteractiveClientName — cluster-unique cosmetic label. Judged by the single resource-name form of the tree, so the DB CHECK and this validator agree.

func (n InteractiveClientName) Validate() error

type InteractiveClientStatus ¶

type InteractiveClientStatus string

InteractiveClientStatus — lifecycle status.

const (
	InteractiveClientActive   InteractiveClientStatus = "ACTIVE"
	InteractiveClientDeleting InteractiveClientStatus = "DELETING"
)

func (s InteractiveClientStatus) Validate() error

type InviteStatus ¶

type InviteStatus string

InviteStatus — invite-flow state for a User row.

PENDING — created via `UserService.Invite`, external_id="" until first login; the invitee has not yet confirmed identity through Kratos. ACTIVE — either self-signup via `UpsertFromIdentity` without a pending invite, or a PENDING row activated on first-login (matched by email). BLOCKED — административный запрет на членство в Account'е. Ставится и снимается ДЕЙСТВИЯМИ `UserService.Block` / `Unblock` (право `identity_suspender@iam_user` = админ аккаунта плюс каскад облака; `v_update` с этого типа снят, #1128); писатель — `userWriter.SetInviteStatus`.

Состояние принадлежит СТРОКЕ ЧЛЕНСТВА, а не человеку. Одна личность держит по строке на каждый Account, поэтому запрет принадлежит тому аккаунту, который его наложил, и не отключает личность там, где она законно активна: выдача токена перебирает набор членств и обслуживает первое аутентифицирующееся, отказывая лишь когда ни одно не может (token_enrichment_service.go, iamhooks).

Снимать запрет самостоятельным действием нельзя: восстановление пароля доказывает владение почтовым ящиком — ровно то, чего администратор, ставя запрет, под сомнение не ставил (см. internal_on_recovery.go). Поэтому у пути блокировки ОБЯЗАН быть административный путь снятия, иначе заблокированный окажется заперт навсегда. Гейт blocked_state_reachability_test.go требует, чтобы каждый писатель этого состояния был объявлен вместе со ссылкой на снятие, — и делает появление одностороннего пути упавшей сборкой, а не открытием.

const (
	InviteStatusPending InviteStatus = "PENDING"
	InviteStatusActive  InviteStatus = "ACTIVE"
	InviteStatusBlocked InviteStatus = "BLOCKED"
)

func (s InviteStatus) MayAuthenticate() bool

func (s InviteStatus) Validate() error

type KeyID ¶

type KeyID string

KeyID — идентификатор ключа (`kid`).

func (k KeyID) Validate() error

type LabelKey ¶

type LabelKey string

func (k LabelKey) Validate() error

type LabelVal ¶

type LabelVal string

func (v LabelVal) Validate() error

type Labels ¶

type Labels map[LabelKey]LabelVal

Labels — key→val map.

func (l Labels) Validate() error

type Limit ¶

type Limit struct {
	ID        LimitID
	CreatedAt time.Time

	Scope   LimitScope
	ScopeID string
	Kind    LimitKind
	Value   int64

	// WithdrawnAt — the moment the ceiling stopped applying. Zero → in force.
	//
	// A withdrawal is a tombstone rather than a deleted row because owner
	// services keep a PROJECTION of these values and refresh it by delta: a delta
	// that only ever reports writes can never drop a projection row, so a
	// withdrawn project override would keep overriding forever.
	WithdrawnAt time.Time

	// Revision — monotonic, assigned by the database. Advances on a change of
	// value or of withdrawal, and stands still when a write restates what was
	// already there.
	Revision int64
}

Limit — the ceiling on how many resources of one kind a tenant may hold.

The triple (Scope, ScopeID, Kind) IS the limit's identity among those in force; `Value` is the only mutable field. "Moving" a ceiling to another project or another kind is a different ceiling, created and withdrawn explicitly — an Update that could change the triple would silently transfer a tenant's headroom to a tenant who was never granted it.

func (l Limit) Validate() error

func (l Limit) Withdrawn() bool

type LimitCarrier ¶

type LimitCarrier string

LimitCarrier — the type of object a kind is counted IN.

WHY IT IS DECLARED AND NOT DERIVED. The temptation is "two parts ⇒ counted in a project", and that rule is false on the first entry that already exists: `iam.project` has two parts and is counted in an ACCOUNT, because a project does not live inside a project. A guess here does not fail loudly — it counts the right rows against the wrong owner, and the tenant sees a ceiling that never moves. So the carrier travels beside the kind, and the pair is the unit of the catalogue.

const (
	// CarrierProject — counted per project. The common case.
	CarrierProject LimitCarrier = "project"
	// CarrierAccount — counted per account, for kinds that have no project to
	// live in.
	//
	// НИ ОДИН ВИД КАТАЛОГА ЕГО СЕГОДНЯ НЕ НАЗЫВАЕТ, и это состояние, а не
	// упущение: шестеро, кто им пользовался, — проекты и субъекты в области
	// аккаунта — сняты с каталога вместе со своим учётом
	// (`PRO-Robotech/kacho#2117`, сценарий `KAN-Q3-04`), потому что не
	// списывались ни разу.
	//
	// Константа ОСТАЁТСЯ, и снимать её этим изменением нельзя: величину
	// `'account'` по-прежнему принимает ограничение
	// `project_resource_quotas_carrier_ck` ПРИМЕНЁННОЙ миграции, а править
	// применённую нельзя (ban #5). Уходит она вместе с остальным механизмом
	// величин — стадией S4 той же приёмки, где снимаются таблицы и функции.
	CarrierAccount LimitCarrier = "account"
	// CarrierIdentity — counted per HUMAN, across every account they hold.
	//
	// # Why a third root had to exist
	//
	// A carrier must be EXTERNAL to the thing it counts, and for the account
	// neither of the two above is: an account cannot be counted inside an
	// account, and it has no project. That is not an implementation gap but the
	// shape of the tenancy: the account is its root, and the root has no parent
	// below the cluster.
	//
	// Counting per cluster was the obvious alternative and it is worse in the way
	// that matters: the refusal reaches the NEXT honest tenant rather than the one
	// who exhausted the shelf. The identity is the only thing that exists BEFORE
	// an account and outlives it, so it is the only carrier on which the refusal
	// lands on its cause.
	//
	// # What identifies it, and why not the user row
	//
	// The identity is the external login subject (`users.external_id`), NOT the
	// user row. A user row is a MEMBERSHIP: it is scoped to one account, and one
	// human legitimately holds one per account. Counting per user row would tie
	// the ceiling to the very thing that multiplies as soon as the account
	// coupling is removed — that is, it would hand out the bypass together with
	// the change it is meant to survive.
	CarrierIdentity LimitCarrier = "identity"
)

func CarrierOfKind(k LimitKind) (LimitCarrier, bool)

func (c LimitCarrier) Validate() error

type LimitFilter ¶

type LimitFilter struct {
	Scope   LimitScope
	ScopeID string
	Kind    LimitKind
}

LimitFilter — the three-valued narrowing a List accepts. Empty members mean "do not narrow by this"; the vocabulary is closed, so there is no filter grammar here and nothing to parse.

func (f LimitFilter) Validate() error

type LimitID ¶

type LimitID string

LimitID — id of a Limit. Hyphen canon `lim-<17>` (ids.PrefixLimitHyphen), immutable for the life of the resource and the only externally addressable identity (core rule #15).

type LimitKind ¶

type LimitKind string

LimitKind — a dotted token naming what is being counted. Two forms, and only two:

`<domain>.<resource>`            — a resource counted in its carrier
`<domain>.<parent>.<child>`      — how many <child> fit in ONE <parent>

Both forms name REAL types of the authorization model, and the three-part form names two of them. That is a gate rather than a convention: a ceiling stated on a name the platform does not know is a ceiling nobody can check and nobody can show the tenant (§7 п.9 of the acceptance).

func AccountScopedKinds() []LimitKind

func AuthorityStatedKinds() []LimitKind

func CountableKinds() []LimitKind

func CountableKindsOfService(service string) []LimitKind

func PostureStatedKinds() []LimitKind

func (k LimitKind) ChildKind() LimitKind

func (k LimitKind) Nested() bool

func (k LimitKind) ParentKind() LimitKind

func (k LimitKind) Parts() []string

func (k LimitKind) Service() string

func (k LimitKind) Validate() error

type LimitScope ¶

type LimitScope string

LimitScope — where a ceiling is stated. Three arms, ordered by specificity: PROJECT beats ACCOUNT beats DEFAULT.

const (
	// LimitScopeDefault — platform-wide fallback; exactly one row per kind.
	LimitScopeDefault LimitScope = "DEFAULT"
	// LimitScopeAccount — stated for one account.
	LimitScopeAccount LimitScope = "ACCOUNT"
	// LimitScopeProject — stated for one project; the most specific arm.
	LimitScopeProject LimitScope = "PROJECT"
)

func (s LimitScope) Specificity() int

func (s LimitScope) Validate() error

type Membership ¶

type Membership struct {
	ID        MembershipID
	AccountID AccountID
	// AccountName — ЗЕРКАЛО имени аккаунта, источник истины сам аккаунт.
	// Заполняется на чтении соединением в той же БД; пустое значение означает
	// «имя не задано», а НЕ «аккаунта нет».
	AccountName AccountName
	UserID      UserID
	State       MembershipState
	// InvitedBy — кто пригласил. Это и есть след приглашения, ПЕРЕЖИВАЮЩИЙ вход:
	// активация трогает состояние и отметку правки и не трогает это поле.
	// Пусто у членства, заведённого не приглашением.
	InvitedBy UserID
	// CreatedAt — когда членство заведено; для приглашения — когда оно выписано.
	CreatedAt time.Time
	// UpdatedAt — когда состояние менялось в последний раз.
	UpdatedAt time.Time
}

Membership — принадлежность человека аккаунту как ОТДЕЛЬНАЯ связь.

Ресурс ВЫХОДНОЙ: глаголов создания, правки и снятия у него на читающей поверхности нет. Заводит членство приглашение, снимает — исключение из аккаунта, и оба принадлежат потоку человека.

type MembershipID ¶

type MembershipID string

MembershipID — идентификатор членства, дефис-форма `mbr-<17>`.

Он ВЫЧИСЛЯЕТСЯ из пары «человек × аккаунт» неизменяемой SQL-функцией без соли, а не чеканится: писателей строки членства больше одного, и все обязаны прийти к ОДНОЙ строке на одну пару. Отсюда два следствия, которые здесь названы, потому что они меняют решения читающего кода:

• идентификатор ПЕРЕИСПОЛЬЗУЕТСЯ. Уникальность пары полная, снятие есть удаление строки, функция неизменяема — значит повторное приглашение того же человека в тот же аккаунт вернёт ТОТ ЖЕ идентификатор. Признак «строка заведена заново» — `CreatedAt`, а не `ID`;
• идентификатор ВЫЧИСЛИМ ПОСТОРОННИМ. Зная человека и аккаунт, его получает кто угодно, ни разу не обратившись к платформе. Поэтому одиночное чтение обязано быть суженным по аккаунту в САМОМ ЗАПРОСЕ: без этого адрес чужого членства строится арифметикой, а не перебором.

type MembershipState ¶

type MembershipState string

MembershipState — состояние членства. Значений ровно два, и словарь закреплён CHECK'ом на таблице: третьего в колонке не появится.

Согласованность состояния членства со статусом человека конструкцией НЕ закреплена — её держат писатели (зеркалящий триггер строки человека и два стейтмента репозитория). Читающий код поэтому судит то, что в строке лежит, и не выводит одно из другого.

const (
	// MembershipStatePending — человек приглашён и ещё не входил.
	//
	// Наблюдаемо АККАУНТ-СКОУПНЫМ чтением и не наблюдаемо своим списком: у
	// приглашённого нет внешнего субъекта, значит нечем аутентифицироваться,
	// значит своего чтения он вызвать не может. Это не расхождение проекций, а
	// арифметика — разные наблюдатели видят разное.
	MembershipStatePending MembershipState = "PENDING"
	// MembershipStateActive — человек состоит в аккаунте.
	MembershipStateActive MembershipState = "ACTIVE"
)

type MembershipTuple ¶

type MembershipTuple struct {
	User     string // e.g. "user:usr-…", "group:grp-…#member"
	Relation string // tier relation (e.g. "editor")
	Object   string // e.g. "compute_instance:inst-1"
}

MembershipTuple — a per-object FGA relation tuple the reconciler emits/revokes for a materialized membership (subject → tier → object). A flat value so the reconcile use-case stays transport/storage-agnostic; the pg adapter maps it to the fga_outbox payload.

type MirrorObject ¶

type MirrorObject struct {
	ObjectType      string
	ObjectID        string
	ParentProjectID string
	// ParentAccountIDs — АККАУНТЫ, под которыми лежит объект. Множественное
	// число здесь не запас на будущее: у ЛИЧНОСТИ принадлежность аккаунту
	// перестала быть свойством её строки и стала отдельной связью, которых у
	// человека бывает несколько (#470/#471), поэтому скалярное поле называло бы
	// ОДИН аккаунт из многих — и выдача второго аккаунта не находила бы своего
	// человека by construction (#1172).
	//
	// У всех прочих типов набор вырожден: ноль элементов (объект не лежит ни в
	// одном аккаунте) либо один. Пустые строки в набор НЕ КЛАДУТСЯ — «аккаунта
	// нет» выражается отсутствием элемента, а не элементом-пустышкой, иначе
	// область с пустым идентификатором совпала бы с ним.
	ParentAccountIDs []string
	Labels           map[string]string
}

MirrorObject — the same-DB parent-scope projection of an owner object read from resource_mirror (β fed it; γ reads it). Pure value; the reader adapter fills it.

func (m MirrorObject) IsContainedIn(scope ScopeAnchor) bool

project:P ⊑ project:P                         (same project)
project:P ⊑ account:A  if A ∈ mirror.ParentAccountIDs
any       ⊑ cluster:*                          (cluster contains everything)

func (m MirrorObject) MatchesLabels(matchLabels map[string]string) bool

type ModuleSet ¶

type ModuleSet interface {
	// IsKnownModule — состоит ли модуль в наборе.
	IsKnownModule(module string) bool
}

ModuleSet — членство в наборе модулей платформы, каким его знает ВЫЗЫВАЮЩИЙ.

Подстановочный знак `*` членом набора не является ни в одной реализации: он не имя модуля, а маркер политики, и разбирается Rule.Validate отдельно.

func ModuleSetOf(names ...string) ModuleSet

type OAuthClientID ¶

type OAuthClientID string

OAuthClientID — opaque hydra client id (length 1..128, [A-Za-z0-9._:-]).

func (h OAuthClientID) Validate() error

type OAuthClientName ¶

type OAuthClientName string

OAuthClientName — человекочитаемое имя токена (SA-key / user-token). Судится единственной формой имени дерева, как и остальные имена iam.

Пустая строка остаётся законным ВХОДОМ выпуска и означает «назови сам»: до записи её заменяет имя, производное от идентификатора (`validate.NameOrDefault` в use-case). Здесь пустое уже не проходит — эта проверка судит то, что БУДЕТ ЗАПИСАНО, а записи с пустым именем не бывает.

func (n OAuthClientName) Validate() error

type OperationID ¶

type OperationID string

type Permission ¶

type Permission string

func (p Permission) Validate() error

type Permissions ¶

type Permissions []Permission

func CompileRules(rules []Rule) (Permissions, error)

func (p Permissions) Validate() error

func (p Permissions) ValidateCompiled() error

type PrivilegeDerivation ¶

type PrivilegeDerivation string

PrivilegeDerivation — how a subject obtained a privilege.

const (
	// DerivationDirect — the binding's subject IS the requested subject. Also the
	// zero value's meaning (see SubjectPrivilege.Derivation).
	DerivationDirect PrivilegeDerivation = ""
	// DerivationGroup — the binding's subject is a GROUP the requested subject is
	// a member of. Groups do not nest, so this is exactly one hop.
	DerivationGroup PrivilegeDerivation = "GROUP"
)

type Project ¶

type Project struct {
	ID          ProjectID
	AccountID   AccountID
	Name        ProjectName
	Description Description
	Labels      Labels
	CreatedAt   time.Time
}

Project — child Account-а («folder» в YC-стилистике, но без промежуточного Cloud). Уникальное имя per-Account (DB UNIQUE projects_account_name_unique).

FK: account_id → accounts(id) ON DELETE RESTRICT. account_id — hard-immutable после Create (Update его reject'ит).

func (p Project) StructuralFacts() []StructuralTuple

func (p Project) Validate() error

type ProjectID ¶

type ProjectID string

type ProjectName ¶

type ProjectName string

func (n ProjectName) Validate() error

type PrunedSelectorType ¶

type PrunedSelectorType struct {
	// ObjectType — точечный тип объекта, чью строку каталога сняли.
	ObjectType string
	// Outcome — что стало со строкой отбора, из которой тип вырезан.
	Outcome SelectorPruneOutcome
	// Reason — причина снятия строки каталога, записанная применителем
	// манифеста. Причина ПЛАТФОРМЫ, а не действие арендатора: своё правило он не
	// менял. ПУСТАЯ строка означает «строка каталога причины не несла» (снята
	// ранней миграцией), а не «причину потеряли».
	Reason string
	// PrunedAt — момент вырезания. Время ТРАНЗАКЦИИ применения: у всего, что
	// вырезано одним применением, он совпадает дословно.
	PrunedAt time.Time
	// AppliedBy — АВТОР применения, вырезавшего этот тип (#2005). Та же величина
	// и тот же источник, что у соседа: вопрос «кто снял» у обеих ведомостей
	// общий — арендатор не различает, какой из проекций правила он лишился.
	//
	// ПУСТАЯ строка означает «строка вырезана ДО заведения колонки».
	AppliedBy string
}

PrunedSelectorType — точечный тип, ВЫРЕЗАННЫЙ применителем каталога из отбора правила роли при снятии строки ресурса платформы (#1988).

Чем это отличается от соседней [WithdrawnGrant], и почему они не сложены ¶

Переселение адресуется парой «тип объекта + глагол» и означает «право по этой паре действовало и перестало». Вырезание глагола не имеет ВООБЩЕ: отбор правила называет типы, а не пары, — поэтому у него своя ведомость и свой тип здесь. Сложить их значило бы дать вырезанному пустой глагол, а пустой глагол в соседе есть ЯКОРЬ объявления правила, то есть уже занятое значение.

Отпечаток правила сюда НЕ ПЕРЕЕЗЖАЕТ ¶

Ведомость ключуется тройкой «роль + отпечаток правила + тип»: отпечаток нужен ХРАНЕНИЮ, чтобы два правила, потерявшие один тип, не схлопнулись в одну строку. Читающему он не нужен и не отдаётся — это содержательный хеш, которого нет ни в одном контракте платформы; выставь мы его, способ хеширования стал бы частью контракта, а арендатор своё правило знает содержанием, а не дайджестом.

Следствие названо прямо: строки, различавшиеся ТОЛЬКО отпечатком, для читающего есть ОДИН факт и произносятся один раз.

type PublishedKey ¶

type PublishedKey struct {
	KID          KeyID
	Algorithm    SigningAlgorithm
	PublicKeyPEM string
}

PublishedKey — ПУБЛИКУЕМАЯ форма ключа.

Поля приватной половины у этого типа НЕТ и быть не может (F1-05): положить её сюда не выражается, а не «запрещено правилом».

type RecoveryCompletion ¶

type RecoveryCompletion struct {
	RecoveryJTI         string
	ExternalID          ExternalSubject
	UserID              UserID
	RevokedSessionCount int32
}

RecoveryCompletion — one row of the Kratos recovery-completed idempotency ledger (migration 0015). PK recovery_jti dedups at-least-once webhook delivery. The row stores the deterministic primary user_id (first row by created_at ASC) and the revoked session count so a duplicate delivery can replay the same Operation.metadata without re-running any side-effect.

func (r RecoveryCompletion) Validate() error

type ResourceRef ¶

type ResourceRef struct {
	Type string
	ID   string
}

ResourceRef is the closed-table {type,id} per-object pointer (redesign-2026 F8 / B1). Unlike a generic Referrer it carries NO name — the iam target is the strict {type,id} form. `Type` is the dotted `<module>.<resource>` key.

type ResourceType ¶

type ResourceType string

ResourceType — ЯКОРЬ ОБЛАСТИ привязки: один из трёх ярусов иерархии (`cluster`/`account`/`project`). Вокабуляр объявлен ОДИН раз — `scopeAnchorTiers` в access_binding_scope.go, — и `Validate()` судит по нему. Пообъектный тип якорем не бывает: он живёт на оси `target` (F8).

func (r ResourceType) Validate() error

type Role ¶

type Role struct {
	ID          RoleID
	ClusterID   ClusterID // set for system role
	AccountID   AccountID // set for account-scoped custom
	ProjectID   ProjectID // set for project-scoped custom
	Name        RoleName
	Description Description
	// Rules — authored policy (RBAC rules-model 2026). Source of truth + public
	// API surface. Compiled into Permissions (internal, FGA-emit) by CompileRules.
	Rules Rules
	// Permissions — INTERNAL compiled form (anchor/names arms; match_labels NOT
	// compiled). Derived from Rules via CompileRules; NOT a public API field for
	// rules-roles. Legacy permissions-only roles (no Rules) keep their stored set.
	Permissions Permissions
	IsSystem    bool
	// OwnerModule — модуль, которому роль принадлежит. Пусто у ПЛАТФОРМЕННОЙ
	// роли (admin/edit/view/owner, kacho-system.*), непусто у роли, объявленной
	// манифестом этого модуля.
	//
	// Носит ровно ОДИН смысл — владение, — и потому отделяет послабление
	// подстановки от кластерного якоря: `IsSystem` продолжает означать «арендатор
	// эту роль не правит» и больше не означает «этой роли можно подставлять
	// звёздочку». Политика выводится из пары ОДНИМ местом — [PolicyOfRole].
	//
	// Наружу не проецируется: `Role` публичного контракта этой колонки не несёт
	// (задача продукта #1032, тип изменения — ВВОДЯЩЕЕ, без нового поля API).
	OwnerModule string
	CreatedAt   time.Time
	// CreatedByUserID — authoring principal (governance/audit). Optional.
	CreatedByUserID UserID
	// UpdatedAt — last-mutation timestamp. Zero until first Update.
	UpdatedAt time.Time
	// Labels — tenant-facing метки САМОГО ресурса Role (НЕ путать с
	// Rule.MatchLabels, отбирающим объекты под грантом). Делают Role
	// label-selectable наравне с account/project (ARM_LABELS-грант на iam.role →
	// v_list по `labels @> matchLabels`; List фильтрует viewer ∪ v_list).
	Labels Labels
	// Integrity — целость роли: даёт ли она то, что объявляет (#1035).
	//
	// ВЫВОДИТСЯ НА ЧТЕНИИ и НЕ ХРАНИТСЯ: колонки у неё нет, в перечень колонок
	// писателя она не входит и [Role.Validate] её не судит. Нулевое значение
	// означает «этим путём не вычислено» — так её и видят пути, которые роль не
	// читают, а возвращают эхом мутации.
	Integrity RoleIntegrity

	// Lifecycle — ОБЪЯВЛЕНА роль манифестом модуля сегодня либо СНЯТА (#1913).
	//
	// Отдельно от `Integrity` рядом, и различие несущее: `RoleHealthEmpty` даёт
	// и снятая роль, и объявленная, чьи строки каталога сняты, — а следующий шаг
	// у арендатора разный. Довод целиком — [RoleLifecycle].
	//
	// ПРИХОДИТ ЧТЕНИЕМ: колонки пометки у строки есть, но заполняют это поле
	// `Get` и `List`, а ответ операции его не несёт — нулевое состояние там
	// означает «этим ответом не вычислено», ровно как у соседа.
	Lifecycle RoleLifecycle

	// Withdrawn — ЧТО у роли отобрано и почему (#1992): строки ведомости
	// переселения. ОБЪЯСНЯЕТ состояние целости и не определяет его — у роли,
	// пострадавшей третьим путём, переселения не было вовсе, и список пуст при
	// нездоровом состоянии.
	//
	// Пустой срез означает «отобранного нет», а не «не читали»: разводит их
	// [RoleIntegrity.Health] рядом, у которого нулевое состояние есть «этим
	// ответом не вычислено».
	Withdrawn []WithdrawnGrant

	// PrunedSelectorTypes — какие точечные типы ВЫРЕЗАНЫ из отбора правил этой
	// роли и почему (#1988): строки ведомости вырезания.
	//
	// Сосед [Role.Withdrawn] отвечает про ДВЕ проекции правила, у которых есть
	// пара «тип + глагол»; эта — про ТРЕТЬЮ, где глагола нет вовсе. Разные
	// ведомости, разные события, поэтому два поля, а не одно.
	//
	// Пустой срез означает «вырезанного нет», а не «не читали»: разводит их
	// [RoleIntegrity.Health] рядом, у которого нулевое состояние есть «этим
	// ответом не вычислено».
	PrunedSelectorTypes []PrunedSelectorType

	// RuleStates — состояние КАЖДОГО правила роли (#1962): действует, отозвано
	// платформой либо не разрешилось. Записей ровно по числу правил.
	//
	// Отвечает на вопрос, которого нет ни у `Integrity`, ни у `Withdrawn`: КАКОЕ
	// правило пострадало и по КАКОЙ ИЗ ДВУХ причин. Картина счётчиков у причин
	// ОДИНАКОВА, а следующий шаг арендатора — разный.
	//
	// ПРИХОДИТ ЧТЕНИЕМ, НЕ ХРАНИТСЯ — тем же доводом, что `Integrity` рядом.
	// ПУСТОЙ СРЕЗ означает «этим путём не вычислено» и законен: ответ операции
	// состояния не несёт. У роли БЕЗ правил он пуст и на чтении — состояние есть
	// свойство правила, и у роли без правил его нет.
	RuleStates []RuleState

	// TypeVerbs — набор глаголов ТИПА, каким его объявляет ЖИВАЯ строка каталога
	// (#1994). Тем же набором идёт материализация, поэтому превью и эмиссия не
	// могут разойтись.
	//
	// ПРИХОДИТ ПРОВЯЗКОЙ, НЕ ХРАНИТСЯ — как и `Integrity` рядом: колонки у неё
	// нет, писатель её не пишет, [Role.Validate] её не судит. Отличие от
	// `Integrity` в том, чем является НУЛЕВОЕ значение: там оно означает «этим
	// путём не вычислено» и законно, здесь — ОТКАЗ проекции. Показ по словарю,
	// порождённому сборкой, неотличим от честного превью, поэтому «нечем
	// ответить» обязано быть отказом, а не тихим запасным путём.
	TypeVerbs TypeVerbLookup
}

Role — multi-scope. Exactly one scope field is non-NULL:

• is_system=true + ClusterID set: system role (`kacho-system.admin`, ...).
• is_system=false + AccountID set: account-scoped custom role.
• is_system=false + ProjectID set: project-scoped custom role.

Enforced by DB CHECK `roles_definition_tier_xor` + a partial UNIQUE per scope. Domain.Validate duplicates the CHECK to give friendly errors before reaching the DB. (The legacy B2B-tenant role scope was removed; a custom role is scoped to exactly one of {account, project}.)

func (r Role) AuthoredVerbs(lookup TypeVerbLookup) []string

func (r Role) CanonicalRank() int

func (r Role) DefinitionTierID() string

func (r Role) DefinitionTierType() string

func (r Role) DisplayName() string

func (r Role) EffectiveVerbs(lookup TypeVerbLookup) []string

func (r Role) IsClusterAdminRole() bool

func (r Role) IsSystemDerived() bool

func (r Role) Purpose() string

func (r Role) Validate(modules ModuleSet) error

func (r Role) VerbNotes(lookup TypeVerbLookup) map[string]string

func (r Role) WithoutComputedState() Role

type RoleHealth ¶

type RoleHealth uint8

RoleHealth — состояние целости роли.

Нулевой вариант несёт ЕДИНСТВЕННЫЙ смысл: «этим ответом не вычислено». Он не является ни одним из трёх исходов и HealthOf его не возвращает никогда — иначе «посчитано, терять нечего» стало бы неотличимо от «не считали».

const (
	// RoleHealthUnknown — не вычислено ЭТИМ ответом. НИКОГДА не «здорова».
	RoleHealthUnknown RoleHealth = iota
	// RoleHealthHealthy — каждый адресуемый сегмент имеет строку проекции.
	RoleHealthHealthy
	// RoleHealthDegraded — часть сегментов проекции не даёт, часть даёт.
	RoleHealthDegraded
	// RoleHealthEmpty — сегменты объявлены, проекции нет НИ ОДНОЙ.
	RoleHealthEmpty
)

type RoleID ¶

type RoleID string

func SystemRoleID(name RoleName) RoleID

type RoleIntegrity ¶

type RoleIntegrity struct {
	Health RoleHealth
	// Declared — сколько адресуемых сегментов объявляют правила роли.
	Declared int
	// Unresolved — сколько из них не дают ни одной строки проекции.
	Unresolved int
}

RoleIntegrity — состояние целости и пара величин, из которых оно выведено.

Счётчики без состояния были бы двусмысленны: ноль есть И законная величина (роль без адресуемых сегментов), И признак «не считали». Разводит их RoleHealth: у вычисленной целости состояние непустое всегда.

func HealthOf(declared, unresolved int) RoleIntegrity

type RoleLifecycle ¶

type RoleLifecycle struct {
	State RoleLifecycleState
	// RetiredAt — момент снятия. Нулевое время у объявленной роли.
	RetiredAt time.Time
	// RetiredReason — причина снятия. Без неё «отобрали» неотличимо от
	// «сломалось».
	RetiredReason string
	// RetiredBy — кто снял. Сегодня производитель один — путь старта, и он
	// называет процессного актора; глагол применения придёт с `#1034` и назовёт
	// проверенную личность вызывающего. Пустая строка у снятой роли означает
	// «помечено до заведения колонки», а не «автора потеряли».
	RetiredBy string
}

RoleLifecycle — состояние роли и обстоятельства её снятия.

Три сопутствующие величины непусты ТОЛЬКО у снятой роли, и это свойство СХЕМЫ, а не кода: `roles_live_matches_retired` делает состояние «снята и жива» неконструируемым.

func (l RoleLifecycle) Withdrawn() bool

type RoleLifecycleState ¶

type RoleLifecycleState uint8

RoleLifecycleState — объявлена роль манифестом либо снята.

Нулевой вариант несёт ЕДИНСТВЕННЫЙ смысл: «этим ответом не вычислено». Он не является ни одним из двух исходов, и путь чтения его не возвращает никогда — иначе «прочитано, роль объявлена» стало бы неотличимо от «не читали».

const (
	// RoleLifecycleUnknown — не вычислено ЭТИМ ответом. НИКОГДА не «объявлена».
	RoleLifecycleUnknown RoleLifecycleState = iota
	// RoleLifecycleDeclared — строка жива: объявление за ней стоит.
	RoleLifecycleDeclared
	// RoleLifecycleWithdrawn — строка помечена снятой: объявления больше нет.
	RoleLifecycleWithdrawn
)

func (s RoleLifecycleState) String() string

type RoleName ¶

type RoleName string

func (n RoleName) Validate() error

func (n RoleName) ValidateAtTier(isSystem bool) error

type RoleRetirement ¶

type RoleRetirement struct {
	// Marked — строка роли помечена снятой. Ложно означает, что оператор пометки
	// не нашёл своей строки: роль уже снята либо владелец не тот.
	Marked bool
	// ResettledVerbs — строк проекции глаголов переселено в ведомость и снято.
	ResettledVerbs int
	// ResettledRuleRefs — строк проекции сегментов переселено и снято.
	ResettledRuleRefs int
	// RemovedSelectors — строк проекции отбора снято. В ведомость они не
	// переселяются: у строки селектора нет пары «тип + глагол», которой
	// адресуются сироты.
	RemovedSelectors int
	// RemovedTargetMembers — строк материализованного состава цели снято.
	RemovedTargetMembers int
}

RoleRetirement — перепись ОДНОГО отзыва роли: что унесено и что помечено.

Числа возвращаются, а не логируются внутри: вызывающий собирает из них перепись применения, а «снято» без чисел неотличимо от «прошло мимо».

type RoleRuleRef ¶

type RoleRuleRef struct {
	Module   string
	Resource string
	// Verb — пустая строка означает ЯКОРЬ (глаголы не сужены), а не отсутствие
	// значения: см. абзац выше.
	Verb string
}

RoleRuleRef — один ОБЪЯВЛЕННЫЙ сегмент правила роли: «эта роль называет вот этот (модуль, ресурс) и вот этот глагол».

Чем это НЕ является — и различие несущее ¶

Это НЕ `RoleVerb`. Та проекция отвечает на вопрос вердикта «разрешено ли действие» и содержит только то, что РЕЗОЛВИТСЯ: тип, которого не знает словарь модели, пар не даёт (`RoleVerbsFromSelectors`). Здесь наоборот — строка кладётся на КАЖДЫЙ объявленный сегмент, резолвится он или нет, потому что предмет этой таблицы есть ссылочная целостность: молчаливый пропуск и есть тот дефект, ради которого заводится ключ, и воспроизвести его в новом писателе значило бы завести ключ, которому нечего отвергать.

Пустой глагол — это ЯКОРЬ, а не «глагол не задан» ¶

Правило, не сузившее глаголы (`verbs: ["*"]`), даёт строку с пустым `Verb`, которая ложится в хранилище значением NULL. Ключ ресурса на ней проверяется, ключ глагола — пропускается `MATCH SIMPLE`, и это ПРАВИЛЬНО: ресурс уже проверен первым ключом. Ключей поэтому два, а не один: под одним составным ключом `MATCH SIMPLE` снял бы проверку целиком, и правило, называющее несуществующий ресурс, принималось бы успешно.

func RuleRefsOf(rules Rules) []RoleRuleRef

func (r RoleRuleRef) Dotted() string

func (r RoleRuleRef) IsAnchor() bool

type RoleScopeGroup ¶

type RoleScopeGroup int8

RoleScopeGroup — server-computed scope tier of a role, surfaced to the UI in AssignableRole.scope_group so the picker groups without client-side logic Maps 1:1 to the proto ScopeGroup enum.

const (
	RoleScopeGroupUnspecified RoleScopeGroup = 0
	RoleScopeGroupSystem      RoleScopeGroup = 1
	RoleScopeGroupAccount     RoleScopeGroup = 2
	RoleScopeGroupProject     RoleScopeGroup = 3
)

func ScopeGroupOf(r Role) RoleScopeGroup

func (g RoleScopeGroup) String() string

type RoleSegment ¶

type RoleSegment struct {
	RoleID     RoleID
	ObjectType string
	// Verb — пустая строка означает ЯКОРЬ (правило не сузило глаголы): годится
	// любая строка проекции своего типа.
	Verb string
}

RoleSegment — объявленный сегмент роли в форме, которой спрашивают проекцию.

Точечный тип приходит ОДНИМ выражением (RoleRuleRef.Dotted) — тем же, каким его строит переселение и каким его хранит каталог. Второе написание разошлось бы молча: соединение по разным словарям не совпадает никогда.

func SegmentsOf(id RoleID, rules Rules) []RoleSegment

type RoleVerb ¶

type RoleVerb struct {
	ObjectType string
	Verb       string
}

RoleVerb — одна пара проекции «роль даёт этот глагол на этом типе».

Тип — тип объекта модели прав (`vpc_network`), не точечное имя ресурса: вердикт спрашивает именно им. Глагол — в канонической форме и БЕЗ приставки отношения: приставку знает компилятор модели, и дублировать её здесь значило бы завести второе место, где она может смениться.

type Rule ¶

type Rule struct {
	Module        string // exactly one module per rule
	Resources     []string
	Verbs         []string
	ResourceNames []string
	MatchLabels   map[string]string
}

Rule — one authored grant over ONE module. The element lists are validated 1..16 each, the selector is resource_names XOR match_labels.

func (r Rule) Arm() Arm

func (r Rule) Fingerprint() string

func (r Rule) Validate(policy RulePolicy, modules ModuleSet) error

type RuleLabelSelector ¶

type RuleLabelSelector struct {
	RuleFP      string
	ObjectTypes []string
	MatchLabels map[string]string
	Verbs       []string
}

RuleLabelSelector — the reconciler-facing projection of ONE ARM_LABELS rule: the rule_fp it is keyed by, the dotted object types it selects (cartesian modules×resources), the matchLabels equality selector, and the authored verbs (which drive the per-object tier + v_* relations the reconciler emits — the tier is NOT taken from the role's compiled permissions, since ARM_LABELS rules are excluded from CompileRules). It carries no pgx/grpc — pure domain.

type RuleLifecycle ¶

type RuleLifecycle uint8

RuleLifecycle — состояние ОДНОГО правила роли.

Нулевой вариант несёт ЕДИНСТВЕННЫЙ смысл: «этим ответом не вычислено». RuleStatesOf его не возвращает никогда — иначе «посчитано, терять нечего» стало бы неотличимо от «не считали».

const (
	// RuleLifecycleUnknown — не вычислено ЭТИМ ответом. НИКОГДА не «действует».
	RuleLifecycleUnknown RuleLifecycle = iota
	// RuleLifecycleActive — ни один адресуемый сегмент правила не потерян.
	RuleLifecycleActive
	// RuleLifecycleWithdrawn — потерянные сегменты есть, и КАЖДЫЙ объяснён
	// ведомостью переселения: объявление сняла платформа.
	RuleLifecycleWithdrawn
	// RuleLifecycleUnresolved — потерянные сегменты есть, и ХОТЯ БЫ ОДИН не
	// объяснён: правило ссылается на то, чего сейчас нет.
	RuleLifecycleUnresolved
)

type RulePolicy ¶

type RulePolicy struct {
	// contains filtered or unexported fields
}

RulePolicy — политика послабления подстановки в правилах роли.

Почему политик ТРИ, а не две (задача продукта #1032) ¶

До неё политика была одна булева — «системный контекст». Признак `is_system` вычисляется ровно из непустого кластерного якоря и несёт ДВА смысла сразу: «арендатор эту роль не правит» и «этой роли можно подставлять звёздочку». Базовая роль модуля обязана быть системной в первом смысле — иначе её правит арендатор, — и вместе с ним получала второй: прямой путь к `*.*.*`. В диффе это выглядит обычной строкой роли, и ни один обзор её не поймает.

Политики различает ВЛАДЕЛЕЦ, а не ярус:

арендаторская   якоря кластера нет            module: "*" ✗   ресурс "*" ✗
модульная       якорь есть, владелец назван   module: "*" ✗   ресурс "*" ✓ только в своём модуле
платформенная   якорь есть, владельца нет     module: "*" ✓   ресурс "*" ✓

Одно правило, а не три исключения: подстановка в роли с владельцем законна ровно в пределах её модуля. Отсюда обе строки механически — `module: "*"` не находится ни в одном модуле, поэтому отвергается всегда; ресурс `*` находится в модуле своего правила, поэтому законен ровно тогда, когда этот модуль и есть владелец.

Глагол `*` не затрагивается — решение, а не пропуск ¶

Он разрешён и в арендаторской роли, безусловно ([validateVerbs]): он не сегмент пространства имён, а «все действия названного типа». Сузить его здесь значило бы отобрать уже выданное под видом починки.

Носитель — ЗНАЧЕНИЕ, а не второй булев флаг ¶

Два булевых параметра дают четыре сочетания при трёх законных, и четвёртое («не системная, но с владельцем») пришлось бы отвергать четвёртым правилом. Политика передаётся одним значением закрытого перечня, выводимым из строки функцией ОДНОГО места — PolicyOfRole. Второе объявление «системная ли роль для целей подстановки» есть находка, и её ловит гейт дерева.

func PolicyOfRole(isSystem bool, ownerModule string) RulePolicy

func TenantPolicy() RulePolicy

func (p RulePolicy) OwnerModule() string

type RuleSelector ¶

type RuleSelector struct {
	RuleFP        string
	Arm           Arm
	ObjectTypes   []string
	ResourceNames []string          // ARM_NAMES only
	MatchLabels   map[string]string // ARM_LABELS only
	Verbs         []string
}

RuleSelector — the UNIFIED reconciler-facing projection of ONE materializing rule (RBAC explicit-model 2026). It carries the arm so the reconciler picks the match strategy: ARM_ANCHOR(all) → every object of ObjectTypes inside scope; ARM_NAMES → only ResourceNames; ARM_LABELS → labels @> MatchLabels. The per-object FGA tuples (v_* + tier) are derived from Verbs (the tier is NOT taken from the role's compiled permissions — ARM_LABELS/ARM_ANCHOR-materialized rules are not in CompileRules). Pure domain, no pgx/grpc.

type RuleState ¶

type RuleState struct {
	// RuleIndex — индекс правила в `Role.Rules`. КЛЮЧ записи: порядок самих
	// записей не значим, сверять надо по нему.
	//
	// Индекс законен как ключ потому, что `roles.rules` — массив JSONB под одним
	// кодеком, и порядок сохраняется by construction: правило читается тем же
	// индексом, каким записано. Действителен он в пределах ОДНОГО ответа:
	// `Update` перестраивает массив, и мутацию индекс не переживает.
	RuleIndex int
	// State — состояние правила. У вычисленного оно непусто ВСЕГДА.
	State RuleLifecycle
	// Segments — сколько АДРЕСУЕМЫХ сегментов объявляет это правило.
	// Ноль законен (подстановка в модуле или ресурсе сегментов не даёт).
	//
	// ЕДИНИЦА ДРУГАЯ, ЧЕМ У [RoleIntegrity.Declared], и потому имя другое:
	// счётчик роли дедуплицирует сегмент по ВСЕЙ роли, здесь — только внутри
	// правила. Равенство сумм поэтому НЕ ГАРАНТИРОВАНО и нарушается ровно
	// тогда, когда один сегмент назван двумя правилами; на прочих ролях суммы
	// совпадают, и это совпадение, а не инвариант.
	Segments int
	// Lost — сколько из объявленных сегментов этого правила не дают ни одной
	// строки проекции, которую читает вердикт.
	//
	// ПРЕДИКАТ ТОТ ЖЕ, что у [RoleIntegrity.Unresolved]: ведомость здесь не
	// спрашивается — её спрашивает [RuleState.Explained] рядом. Различает
	// величины только единица дедупликации.
	Lost int
	// Explained — сколько из потерянных ОБЪЯСНЕНЫ ведомостью переселения.
	// Необъяснённые выводятся вычитанием: третье поле, равное разности двух
	// соседних, разошлось бы с ними при первой же правке.
	Explained int
}

RuleState — состояние одного правила роли и три величины, из которых оно выведено.

Почему слово И счётчики, а не одно из двух ¶

Правило, у которого часть потерь объяснена, а часть нет, читается RuleLifecycleUnresolved — слово называет состояние, ТРЕБУЮЩЕЕ разбора. Схлопыванием это не является ровно потому, что рядом стоят обе величины: `Withdrawn` и `Unresolved` видны одновременно, и ни одна не потеряна.

Четвёртое значение («частично отозвано») рассмотрено и отвергнуто: у него нет ни своего действия у арендатора, ни своего производителя, при том что счётчики уже несут ровно ту же величину.

func RuleStatesOf(rules Rules, unresolved []RoleSegment, withdrawn []WithdrawnGrant) []RuleState

type Rules ¶

type Rules []Rule

Rules — a role's authored policy. Cardinality 1..64.

func DecodeRules(raw []byte) (Rules, error)

func OwnerRoleRules() Rules

func (rs Rules) CoversType(dottedType string) bool

func (rs Rules) HasAnchorRule() bool

func (rs Rules) LabelSelectors() []RuleLabelSelector

func (rs Rules) MaterializingSelectors() []RuleSelector

func (rs Rules) MaterializingSelectorsInScope(scope Scope) []RuleSelector

func (rs Rules) ScopeSelfVerbs(scopeResource string, typeVerbs []string) []string

func (rs Rules) Validate(policy RulePolicy, modules ModuleSet) error

type SAOAuthClientID ¶

type SAOAuthClientID string

SAOAuthClientID — новый формат `soc<17-crockford>` (corelib `ids.NewID`, без подчёркивания). id существующих строк immutable (id = Hydra client id + JWK kid), поэтому валидатор принимает и legacy `soc_<17-crockford>`.

func (id SAOAuthClientID) Validate() error

type Scope ¶

type Scope int8

Scope — anchor tier for an AccessBinding.

const (
	ScopeUnspecified Scope = 0
	ScopeCluster     Scope = 1
	ScopeAccount     Scope = 2
	ScopeProject     Scope = 3
)

func DeriveFromResourceType(resourceType string) Scope

func (s Scope) String() string

func (s Scope) ValidateAgainst(resourceType, resourceID string) error

type ScopeAnchor ¶

type ScopeAnchor struct {
	Type string
	ID   string
}

ScopeAnchor — the resource the binding is scoped to (its containment anchor). Type is one of "project" | "account" | "cluster"; ID is the resource id.

type SelectorPruneOutcome ¶

type SelectorPruneOutcome uint8

SelectorPruneOutcome — что стало со строкой ОТБОРА, из которой вырезан тип.

Величины разделены намеренно: строка, потерявшая последний живой тип, снята целиком — правило перестало отбирать вовсе; строка, у которой живой тип остался, укорочена — правило сузилось. Для разбирающего последствия это события разного рода, и сложив их, мы потеряли бы ровно это различие.

const (
	// SelectorPruneOutcomeUnknown — исход не прочитан ЭТИМ ответом. Никогда не
	// означает «исход неизвестен»: ведомость несёт его всегда, закрытым набором
	// на уровне схемы (`role_selector_prune_outcome_known`).
	SelectorPruneOutcomeUnknown SelectorPruneOutcome = iota
	// SelectorPruneOutcomeShortened — живой тип у строки остался, она укорочена:
	// правило продолжает отбирать, но уже меньше.
	SelectorPruneOutcomeShortened
	// SelectorPruneOutcomeDropped — живого типа не осталось, строка снята
	// целиком: правило не отбирает ничего.
	SelectorPruneOutcomeDropped
)

type ServiceAccount ¶

type ServiceAccount struct {
	ID          ServiceAccountID
	AccountID   AccountID
	Name        SvcAccountName
	Description Description
	Enabled     bool // default true
	CreatedAt   time.Time
	// Labels — tenant-facing метки. Делают ServiceAccount label-selectable
	// наравне с account/project (ARM_LABELS-грант на iam.serviceAccount → v_list
	// по `labels @> matchLabels`; List фильтрует viewer ∪ v_list).
	Labels Labels
}

ServiceAccount — Account-scoped (account_id FK ON DELETE RESTRICT).

Проектной области у служебной учётки нет: поле `project_id` и его колонка сняты — заполнить их было нечем (ни запроса, ни записи, ни выборки), а claim, который из них выводился, не читал никто. Понадобятся проектные служебные учётки — они заводятся отдельной подсистемой со своей приёмкой.

func (s ServiceAccount) MayAuthenticate() bool

func (s ServiceAccount) Validate() error

type ServiceAccountID ¶

type ServiceAccountID string

type ServiceAccountOAuthClient ¶

type ServiceAccountOAuthClient struct {
	ID              SAOAuthClientID
	SvaID           ServiceAccountID
	OAuthClientID   OAuthClientID
	Description     Description
	CreatedByUserID UserID
	CreatedAt       time.Time
	ExpiresAt       *time.Time
	LastUsedAt      *time.Time

	// PublicKeyPEM — SPKI-encoded ECDSA P-256 public key registered with
	// Hydra as a JWK. Empty for legacy rows that pre-date the private_key_jwt
	// mode (migrated with DEFAULT ”) AND for FEDERATED rows where the
	// key material lives in the external IdP rather than kaname.
	PublicKeyPEM string
	// KeyAlgorithm — JOSE alg of the registered key. One of {"ES256",
	// "RS256", "EdDSA"}. Empty for legacy rows; new private_key_jwt keys
	// always set "ES256"; federated rows leave it empty.
	KeyAlgorithm string

	// TrustedSubjects — федеративный вид ключа. Непустой перечень означает, что
	// удостоверение предъявляет ВНЕШНИЙ издатель по RFC 7521/7523: своего
	// ключевого материала строка не несёт вовсе, а подпись проверяется ключом
	// издателя из НАШЕГО перечня доверенных издателей (задача #1124), который
	// читает проверяющий утверждения на пути запроса.
	//
	// Каждый элемент сужает, какая внешняя пара `(iss, sub)` вправе выступать
	// за этот ключ. Пустой перечень — обычный вид с ключевым материалом.
	TrustedSubjects []TrustedSubject

	// DeclaredAudiences — сужение адресатов, ОБЪЯВЛЕННОЕ заказчиком при выдаче
	// (`IssueSAKeyRequest.audience`, задача #1136). Create-only, как и всё
	// остальное на этом ресурсе: глагола правки у ключа нет.
	//
	// Перечней в тракте выдачи ДВА, и этот — внутренний: он говорит, для чего
	// заведён ЭТОТ ключ, и действует ВНУТРИ перечня, объявленного посадкой.
	// Расширить внешнюю границу он не может ничем.
	//
	// Пустой перечень означает «сужения не объявлено», а не «любой адресат»:
	// внешняя граница остаётся и требуется непустой стражем старта выдачи.
	DeclaredAudiences []string

	// CredentialKind — вид удостоверения. ЗАПИСЫВАЕТСЯ при вставке; читателем
	// не вычисляется и из состава прочих полей не выводится.
	CredentialKind CredentialKind
	// SecretHash — sha256 по идентификатору строки И секретной части вместе,
	// 32 байта. Непуст ТОЛЬКО у вида SECRET. Сам секрет не хранится нигде: он
	// существует только в теле ответа, полученного вызывающим выдачи.
	SecretHash []byte

	// Name — человекочитаемое имя ключа, выставляется на Issue (create-only,
	// immutable — ресурс несёт только Issue/List/Revoke). Пусто для legacy-строк.
	Name OAuthClientName
	// Labels — произвольные метки ключа, выставляются на Issue (create-only,
	// immutable). Пусто для legacy-строк.
	Labels Labels
}

ServiceAccountOAuthClient — Class A workload identity (Hydra static client).

private_key_jwt mode: kaname mints an ECDSA P-256 keypair per SA key, registers the public JWK with Hydra (`token_endpoint_auth_method = private_key_jwt`), and returns the private PEM to the caller exactly once. Hydra stores only the JWK; kaname keeps the SPKI public PEM (for rotation diagnostics) plus the algorithm. The legacy `client_secret_basic` flow is dropped: no secret ever exists.

1:1 SA→client.

func (c ServiceAccountOAuthClient) Validate() error

type SessionRevocation ¶

type SessionRevocation struct {
	TokenJTI     string
	RevokedAt    time.Time
	Reason       string
	UserID       UserID
	TTLExpiresAt time.Time
}

SessionRevocation — fast lookup table keyed by token_jti (PK). A cron cleanup deletes rows past ttl_expires_at (`DeleteExpired`, `pg/audit_session_revocation_repos.go`). Migration `0001_initial.sql`.

Номер миграции здесь был неверен — стояло 0013, а это про снятие перечня условий обхода. Правится вместе с тем же дефектом у соседа (`audit_outbox_entry.go`): радиус берётся по МЕХАНИЗМУ — «номер миграции, названный в шапке сущности», — а не по файлу, где дефект заметили.

func (s SessionRevocation) Validate() error

type SigningAlgorithm ¶

type SigningAlgorithm string

SigningAlgorithm — алгоритм подписи токена. Словарь ЗАКРЫТ: значение вне него отвергается разбором конфигурации и стражем старта (приёмка F1 §3 строка 1, F1-03). Открытый словарь означал бы «принимаем любой» — тот же класс, что пустой перечень.

const (
	SigningAlgRS256 SigningAlgorithm = tokenpolicy.AlgRS256
	SigningAlgES256 SigningAlgorithm = tokenpolicy.AlgES256
	SigningAlgEdDSA SigningAlgorithm = tokenpolicy.AlgEdDSA
)

func ParseSigningAlgorithm(raw string) (SigningAlgorithm, error)

func SigningAlgorithms() []SigningAlgorithm

func (a SigningAlgorithm) MinBits() int

type SigningKeyRecord ¶

type SigningKeyRecord struct {
	KID               KeyID
	Algorithm         SigningAlgorithm
	State             SigningKeyState
	PublicKeyPEM      string
	PrivateKeyWrapped []byte
	CreatedAt         time.Time
	NotAfter          time.Time
	ActivatedAt       *time.Time
	RetiredAt         *time.Time
	RemovedAt         *time.Time
	CompromisedAt     *time.Time
}

SigningKeyRecord — ХРАНИМАЯ форма ключа: несёт обёрнутую приватную половину.

Пара к PublishedKey. Разделение типов держит §6.10 КОМПИЛЯТОРОМ: форма «поле есть, но мы его не заполняем» держалась бы вниманием.

func (r SigningKeyRecord) Published() PublishedKey

type SigningKeyState ¶

type SigningKeyState string

SigningKeyState — состояние ключа в ключнице.

Состояний ПЯТЬ, и «скомпрометирован» существует отдельно от «выведен» (приёмка §2.1): первое снимает ключ из набора немедленно, принимая отказ живых токенов, второе — нет. Глагол, делающий и то и другое, лишил бы второе решение его цены.

const (
	// SigningKeyPublished — ключ в наборе, но ещё не подписывает. Этап
	// существует ровно ради порядка «в наборе → подписывает» (§6.1).
	SigningKeyPublished SigningKeyState = "PUBLISHED"
	// SigningKeyActive — ключ подписывает. Такой РОВНО ОДИН, и это держит
	// частичный уникальный индекс, а не проверка в коде (§6.2).
	SigningKeyActive SigningKeyState = "ACTIVE"
	// SigningKeyRetired — выведен из подписи, остаётся в наборе всю отсрочку:
	// подписанные им токены доживают свой срок (§6.4).
	SigningKeyRetired SigningKeyState = "RETIRED"
	// SigningKeyRemoved — отсрочка истекла, ключа в наборе нет.
	SigningKeyRemoved SigningKeyState = "REMOVED"
	// SigningKeyCompromised — покидает набор НЕМЕДЛЕННО; живые токены
	// отвергаются, и это принятая цена, а не дефект.
	SigningKeyCompromised SigningKeyState = "COMPROMISED"
)

func (s SigningKeyState) CanActivate() bool

func (s SigningKeyState) InKeySet() bool

type StructuralTuple ¶

type StructuralTuple struct {
	// User — the SOURCE of the relation: the parent object ("account:<id>") for a
	// parent-pointer, or the subject ("user:<id>") for the account owner.
	User string
	// Relation — the relation name on Object, named after the parent's type for a
	// pointer ("account"/"project"/"cluster") or "owner".
	Relation string
	// Object — the object the relation is written on ("iam_access_binding:<id>").
	Object string
}

StructuralTuple — one relation triple. Transport-neutral on purpose: the emitter converts it to its repo tuple type, and domain stays free of that type.

func AccountScopedStructuralFact(accountID, objectType, objectID string) (StructuralTuple, bool)

account:<accountID>  →  account  →  <objectType>:<objectID>

type Subject ¶

type Subject struct {
	Type SubjectType
	ID   SubjectID
}

Subject — one grantee of an AccessBinding (RBAC rules-model). A binding may carry 1..32 subjects; each yields an INDEPENDENT FGA tuple-set + emitted-tuple ledger lineage, so per-subject revoke/audit never touches another subject's tuples. A GROUP subject grants the role to every member (userset) — resolved to concrete principals by ExpandAccess and, for admin/editor-tier roles, requiring requireGrantAuthority on the scope (group-amplification guard).

func NormalizeSubjects(subjects []Subject, legacyType SubjectType, legacyID SubjectID) ([]Subject, error)

func (s Subject) IsGroup() bool

func (s Subject) Validate() error

type SubjectID ¶

type SubjectID string

SubjectID — opaque id (user, service_account, or group). The paired SubjectType defines the semantics.

type SubjectPrivilege ¶

type SubjectPrivilege struct {
	BindingID       AccessBindingID
	RoleID          RoleID
	RoleName        RoleName // resolved via JOIN; "" for a dangling/deleted role
	ResourceType    ResourceType
	ResourceID      string // opaque id (any prefix, cross-service OK)
	Scope           Scope  // CLUSTER / ACCOUNT / PROJECT
	Status          AccessBindingStatus
	CreatedAt       time.Time
	GrantedByUserID UserID
	ExpiresAt       *time.Time // nullable — TTL
	// Derivation — DIRECT | GROUP. The zero value is treated as DIRECT by the
	// transport projection (a row produced without an explicit derivation is a
	// direct grant), so the proto enum never leaks UNSPECIFIED.
	Derivation PrivilegeDerivation
	// ViaGroupID — the group carrying the privilege when Derivation==GROUP; empty
	// for a DIRECT grant. Without it a GROUP row is un-actionable: the binding's
	// own subject is the group, so the administrator cannot tell which membership
	// to remove.
	ViaGroupID GroupID
}

SubjectPrivilege — enriched, public-safe projection of an AccessBinding for the subject-privileges view (RPC AccessBindingService.ListSubjectPrivileges).

It is an AccessBinding row JOINed with its Role so the human-readable RoleName is resolved server-side in ONE query (access_bindings ⋈ roles on role_id, same kaname schema, FK access_bindings_role_fk) — no per-row N+1 GetRole fan-out. A dangling role (deleted after a revoke) yields an empty RoleName; the consumer (UI) falls back to the raw RoleID (graceful).

Carries only tenant-facing, publicly-safe fields: id / role / scope / status / created_at / granted_by — никаких инфра-чувствительных данных и никаких condition/builtin_condition-internals (вне scope v1, security.md).

Derivation says HOW the subject holds the privilege: DIRECT (the binding names the subject itself) or GROUP (the binding names a group the subject belongs to, named by ViaGroupID). It is computed by the read query, not stored on the binding — a binding does not know which of its subjects' memberships a given reader is asking about.

type SubjectType ¶

type SubjectType string

SubjectType — enum: user|service_account|group.

const (
	SubjectTypeUser           SubjectType = "user"
	SubjectTypeServiceAccount SubjectType = "service_account"
	SubjectTypeGroup          SubjectType = "group"
)

func (s SubjectType) Validate() error

type SubordinateResource ¶

type SubordinateResource struct {
	// Kind — двухчастный токен, которым подчинённый ресурс называется в видах
	// учёта (`iam.user.credential` → `iam.credential`).
	Kind LimitKind
	// Parents — типы модели прав, от которых производен доступ. Их МОЖЕТ быть
	// несколько: один класс сущности живёт в нескольких таблицах ровно тогда,
	// когда видов родителя несколько.
	Parents []LimitKind
	// Tables — таблицы, чьи строки этот ресурс называет, в форме `схема.имя`.
	// Это АНКЕР записи в дереве, а не справка.
	Tables []string
	// Why — почему своего типа модели прав нет. Запись без причины неотличима
	// от записи без предмета.
	Why string
}

SubordinateResource — ресурс, адресуемый арендатором и НЕ имеющий своего типа модели прав, потому что доступ к нему производен от РОДИТЕЛЯ.

Зачем понадобился второй источник имён ¶

Вид учёта обязан называть реальные типы модели прав — так гейт каталога и устроен, и обоснован он утверждением «модель прав знает КАЖДЫЙ адресуемый арендатором тип». На удостоверениях это утверждение ложно: они адресуются (`/iam/v1/users/{user_id}/tokens/{token_id}`), имеют свой идентификатор и свои глаголы, а типа модели прав у них нет — право на удостоверение вычисляется от человека (`token_issuer: subject`), и заводить объект, на который его можно было бы ВЫДАТЬ, модель намеренно избегает.

Почему это расширение, а не ослабление ¶

Множество допустимых имён остаётся закрытым и сверяемым с деревом. Разница с первой редакцией — в поле `Tables`: без него запись была бы САМОЗАЯВЛЕНИЕМ. У закрытой таблицы типов истинность анкерена гейтом дрейфа против канонической модели; здесь анкер — сами таблицы строк и стоящие на них триггеры списания (утверждения G5/G6 гейта каталога). Опечатка `iam.credentials` внутреннюю согласованность записи проходит и ловится ровно этим анкером.

func SubordinateResourceOf(k LimitKind) (SubordinateResource, bool)

func SubordinateResources() []SubordinateResource

type SvcAccountName ¶

type SvcAccountName string

func (n SvcAccountName) Validate() error

type TargetMember ¶

type TargetMember struct {
	BindingID          AccessBindingID
	RoleID             RoleID
	RuleFP             string
	ObjectType         string
	ObjectID           string
	VerificationStatus VerificationStatus
}

TargetMember — one materialized member of a binding's target with its current verification status. object_type is a closed-table dotted key (e.g. "compute.instance"); object_id is an opaque cross-DB soft-ref.

RuleFP attributes the member to the (role) RULE that produced it: the content-hash of the ARM_LABELS rule (domain.Rule.Fingerprint) for a role.rules-driven member, or the sentinel "legacy-selector" for a legacy binding.selector member. Keying membership by rule_fp (not a positional index) lets a Role.Update that removes one rule eager-revoke ONLY that rule's members and lets the SAME object be a member under two different rules at different tiers (distinct rows).

type TrustedIssuer ¶

type TrustedIssuer struct {
	// ClientID — НАША строка федеративного ключа, которую эта запись
	// уполномочивает. Внешний субъект получает токен от её имени, никогда от
	// своего.
	ClientID string
	// Issuer — идентификатор внешнего издателя, сверяемый с `iss` дословно.
	Issuer string
	// Subject — ТОЧНЫЙ субъект, сверяемый с `sub` дословно.
	//
	// Точный, а не образец: доверие образцу означало бы, что запись покрывает
	// субъектов, которых называющий её не перечислял, — и узнать их состав
	// нельзя ни по записи, ни по журналу.
	Subject string
	// PublicKeyPEM — открытый ключ ИЗДАТЕЛЯ в форме SPKI PEM.
	PublicKeyPEM string
	// Algorithm — зарегистрированный алгоритм издателя. Пустое значение
	// означает «ключа нет», а НЕ «любой алгоритм».
	Algorithm string
	// ExpiresAt — момент истечения ДОВЕРИЯ в Unix-секундах; 0 означает
	// «бессрочно».
	ExpiresAt int64
}

TrustedIssuer — одна запись НАШЕГО перечня доверенных издателей.

Форма повторяет то, что прежде хранил у себя поставщик: издатель, ТОЧНЫЙ субъект, ключевой материал издателя и срок. Повторяет намеренно — перевод перечня к нам не должен был заодно менять то, о чём перечень.

func (ti TrustedIssuer) CanVouch() bool

type TrustedSubject ¶

type TrustedSubject struct {
	Issuer         string
	SubjectPattern string
	// PublicKeyPEM — открытый ключ ИЗДАТЕЛЯ (SPKI PEM). Тот, которым подписано
	// внешнее утверждение; нашего ключевого материала федеративная строка не
	// несёт вовсе.
	PublicKeyPEM string
	// KeyAlgorithm — зарегистрированный алгоритм издателя. Пустое значение
	// означает «ключа нет», а НЕ «любой алгоритм».
	KeyAlgorithm string
}

TrustedSubject — one (issuer, subject) tuple permitted to assert a federated ServiceAccountOAuthClient. `Issuer` MUST match the external OIDC `iss` claim verbatim; `SubjectPattern` is a LITERAL-anchored exact subject (`^<literal>$`, no regex metacharacters).

Точная форма субъекта требуется потому, что доверие выдаётся ПОИМЁННО: запись, покрывающая субъектов образцом, называет тех, кого выдававший не перечислял, и установить их состав нельзя ни по записи, ни по журналу.

Перечень — НАША таблица (задача #1124) ¶

Прежде решение о доверии принимал поставщик: запись жила у него, и там же лежал ключ издателя. Отсюда была выведена и прежняя редакция этого комментария — «служба прав вне пути запроса, поэтому образец было бы нечем применить». Сегодня служба прав НА пути запроса: перечень читает её проверка утверждения (`internal/clientassertion`, федеративная полоса). Точная форма осталась, но держит её теперь названный выше довод, а не чужая реализация.

func (ts TrustedSubject) LiteralSubject() (string, bool)

func (ts TrustedSubject) Validate() error

type TypeVerbLookup ¶

type TypeVerbLookup func(module, resource string) (verbs []string, ok bool)

TypeVerbLookup — набор глаголов, объявленный типом (module, resource); ok=false, когда пара не резолвится ни в один известный тип.

Приходит ПАРАМЕТРОМ, а не импортом таблицы: владельцем таблицы остаётся authzmap, а домен — без внешних зависимостей (см. rule_verbs.go, «pure domain»).

func WithCommonFallback(lookup TypeVerbLookup, common []string) TypeVerbLookup

type User ¶

type User struct {
	ID           UserID
	AccountID    AccountID
	ExternalID   ExternalSubject
	Email        Email
	DisplayName  DisplayName
	InviteStatus InviteStatus
	InvitedBy    UserID // user.id of admin who invoked Invite; "" if self-signup
	CreatedAt    time.Time
	// Labels — tenant-facing метки. Делают User label-selectable наравне с
	// account/project: ARM_LABELS-грант на iam.user материализует v_list по
	// `labels @> matchLabels`, а List фильтрует через viewer ∪ v_list.
	Labels Labels
}

User — зеркало личности из внешнего провайдера. Одна личность — ОДНА строка, сколько бы аккаунтов её ни пригласило.

Принадлежность аккаунту здесь НЕ живёт: её выражает строка `kaname.memberships` (одна на пару «человек × аккаунт»), и членств у одного человека бывает несколько. Ключ идентичности — глобальный: `users_identity_email_uniq` и `users_identity_external_id_uniq` (`20260823050000_users_identity_uniqueness_goes_global.sql`, стадия S4-expand перехода IAM-ID-1). PENDING-строка держит external_id="" до первого входа.

Поле AccountID — ЛЕГАСИ-колонка перехода: она жива и `NOT NULL` до стадии S4, но «его аккаунт» из неё не читается — у человека их несколько.

func (u User) Validate() error

type UserID ¶

type UserID string

type UserOAuthClient ¶

type UserOAuthClient struct {
	ID     UserOAuthClientID
	UserID UserID
	// OAuthClientID — идентификатор клиента у ВНЕШНЕГО поставщика.
	//
	// У строк нового выпуска ПУСТ и обязан быть пуст: выдача больше не заводит
	// клиента у поставщика, а пустое значение здесь означает ровно это —
	// регистрации нет. Непустое значение принадлежит строке прежнего выпуска и
	// держит окно двух издателей: отчеканенные поставщиком токены таких строк
	// действительны до своего истечения.
	//
	// На пути разрешения клиента эта колонка НЕ участвует (см.
	// repo/kaname/pg.AssertionClientRepo).
	OAuthClientID   OAuthClientID
	Description     Description
	CreatedByUserID UserID
	CreatedAt       time.Time
	ExpiresAt       *time.Time
	LastUsedAt      *time.Time

	// PublicKeyPEM — SPKI-encoded ECDSA P-256 публичный ключ удостоверения.
	// По нему проверяется подпись `client_assertion` на пути выдачи токена.
	PublicKeyPEM string
	// KeyAlgorithm — JOSE alg зарегистрированного ключа. Всегда "ES256" для новых
	// токенов.
	KeyAlgorithm string

	// CredentialKind — вид удостоверения. ЗАПИСЫВАЕТСЯ при вставке; читателем
	// не вычисляется и из состава прочих полей не выводится.
	CredentialKind CredentialKind
	// SecretHash — sha256 по идентификатору строки И секретной части вместе,
	// 32 байта. Непуст ТОЛЬКО у вида SECRET. Сам секрет не хранится нигде: он
	// существует только в теле ответа, полученного вызывающим выдачи.
	SecretHash []byte

	// Name — человекочитаемое имя токена, выставляется на Issue (create-only,
	// immutable — ресурс несёт только Issue/List/Revoke). Пусто для legacy-строк.
	Name OAuthClientName
	// Labels — произвольные метки токена, выставляются на Issue (create-only,
	// immutable). Пусто для legacy-строк.
	Labels Labels
}

UserOAuthClient — персональный access-токен пользователя.

private_key_jwt: kaname генерирует пару ключей ECDSA P-256 на каждый токен, держит SPKI public PEM плюс алгоритм и возвращает приватный PEM вызывающему ровно один раз. Секрет не существует at-rest.

Клиентом это удостоверение называется по идентификатору ЭТОЙ строки: им подписывается `client_assertion`, и по нему же разрешает клиента наш реестр утверждений. Второго имени у него нет.

N:1 — у одного User может быть несколько токенов.

func (c UserOAuthClient) Validate() error

type UserOAuthClientID ¶

type UserOAuthClientID string

UserOAuthClientID — новый формат `uoc<17-crockford>` (corelib `ids.NewID`, без подчёркивания). id существующих строк immutable, поэтому валидатор принимает и legacy `uoc_<17-crockford>`.

func (id UserOAuthClientID) Validate() error

type UserTokenRevocation ¶

type UserTokenRevocation struct {
	UserID       UserID
	RevokeBefore time.Time
	Reason       string
	RevokedBy    UserID
}

UserTokenRevocation — per-user "revoke-all-before" cutoff (migration 0012). Backs admin ForceLogout + Revoke(revoke_all_user_tokens): any token whose originating session authenticated at or before RevokeBefore is denied at refresh. One row per user (PK user_id); the cutoff only ever advances (monotonic GREATEST upsert at the repo layer) so a re-auth past the cutoff is allowed again (no permanent lockout).

func (u UserTokenRevocation) Validate() error

type VerificationStatus ¶

type VerificationStatus string

VerificationStatus — the observable per-member containment verdict.

const (
	// VerificationPending — the object is NOT yet in resource_mirror (the grant
	// raced ahead of the owner's RegisterResource). No FGA tuple is emitted; the
	// reconciler verifies it when the mirror row arrives.
	VerificationPending VerificationStatus = "PENDING_VERIFICATION"
	// VerificationActive — the object is in resource_mirror AND under the
	// binding's scope-anchor. The per-object FGA tuple IS emitted.
	VerificationActive VerificationStatus = "ACTIVE"
	// VerificationRejected — the object is in resource_mirror but NOT under scope
	// (mirror.parent_* ⋢ scope). No tuple; an audit event is written (not silent).
	VerificationRejected VerificationStatus = "REJECTED"
)

type WithdrawnGrant ¶

type WithdrawnGrant struct {
	// ObjectType — точечный тип объекта, чью строку каталога сняли.
	ObjectType string
	// Verb — глагол. ПУСТАЯ строка есть ЯКОРЬ объявления правила, а не «любой
	// глагол»: у объявления, не назвавшего глагол поимённо, его нет.
	Verb string
	// Source — из какой проекции переселена строка.
	Source WithdrawnGrantSource
	// Reason — причина снятия строки каталога, записанная применителем
	// манифеста. Причина ПЛАТФОРМЫ, а не действие арендатора.
	Reason string
	// WithdrawnAt — момент переселения. Время ТРАНЗАКЦИИ применения: у всего,
	// что отобрано одним применением, он совпадает дословно.
	WithdrawnAt time.Time
	// AppliedBy — АВТОР применения, снявшего эту строку (#2005): проверенная
	// личность вызывающего на пути глагола либо названный процессный актор на
	// пути старта. НЕ учётка, под которой исполнялась транзакция.
	//
	// Для разбора «почему у меня отобрали право» это второй по важности вопрос
	// после «почему»: причина называет, ЧТО случилось с платформой, а автор — КТО
	// это сделал.
	//
	// ПУСТАЯ строка означает «строка переселена ДО заведения колонки», а не
	// «автора потеряли»: восстановить его у таких строк не из чего.
	AppliedBy string
	// Cause — ПОЧЕМУ строка переселена (#1913). Различие наблюдаемо, потому что
	// от него зависит поведение: оживление роли снимает строки причины
	// [WithdrawnGrantCauseRoleRetired] и не трогает строк причины
	// [WithdrawnGrantCauseCatalogRetired].
	//
	// Отличается от [WithdrawnGrant.Source] предметом: тот называет, ИЗ КАКОЙ
	// проекции строка переселена, этот — ПОЧЕМУ. Величины независимы: каждая
	// причина встречается у обеих популяций.
	Cause WithdrawnGrantCause
}

WithdrawnGrant — одна проекция правила роли, потерявшая референт при снятии строки каталога платформы и ПЕРЕСЕЛЁННАЯ в ведомость, а не отобранная молча.

Зачем этот тип, когда рядом уже стоят счётчики ¶

RoleIntegrity отвечает СКОЛЬКО сегментов перестало проецироваться и не отвечает, ЧТО именно и почему. Со стороны арендатора «право отобрали» без этого неотличимо от «права не было»: свою роль он не менял, а действовать она перестала.

Он ОБЪЯСНЯЕТ состояние и не определяет его ¶

Целость выводится из того, что читает вердикт, а не из ведомости: у роли, пострадавшей вторым путём (тип объявлен, а модель прав его не знает), переселения не было ВОВСЕ, и ведомость о ней пуста при нездоровом состоянии. Судить целость по ведомости значило бы читать такую роль здоровой — форма инцидента 513001.

type WithdrawnGrantCause ¶

type WithdrawnGrantCause uint8

WithdrawnGrantCause — почему проекция переселена в ведомость.

Нулевой вариант означает «этим ответом не вычислено» и НИКОГДА «причина неизвестна»: непонятая строка ведомости отвергается разбором, а не выдаётся за невычисленную.

const (
	// WithdrawnGrantCauseUnknown — не вычислено ЭТИМ ответом.
	WithdrawnGrantCauseUnknown WithdrawnGrantCause = iota
	// WithdrawnGrantCauseCatalogRetired — снята строка КАТАЛОГА платформы, на
	// которую ссылалось правило. Роль при этом объявлена и жива.
	WithdrawnGrantCauseCatalogRetired
	// WithdrawnGrantCauseRoleRetired — снята САМА РОЛЬ. Возврат объявления
	// оживляет её и снимает эти строки.
	WithdrawnGrantCauseRoleRetired
)

type WithdrawnGrantSource ¶

type WithdrawnGrantSource uint8

WithdrawnGrantSource — из какой проекции правила переселена строка ведомости.

Популяции разделены намеренно: «право отобрано» и «правило перестало резолвиться» — разные события для того, кто разбирает последствия, и сложив их, мы потеряли бы именно это различие.

const (
	// WithdrawnGrantSourceUnknown — популяция не прочитана ЭТИМ ответом. Никогда
	// не означает «популяция неизвестна»: ведомость несёт её всегда, закрытым
	// набором на уровне схемы.
	WithdrawnGrantSourceUnknown WithdrawnGrantSource = iota
	// WithdrawnGrantSourceGrant — выдача глагола: право по паре действовало и
	// перестало.
	WithdrawnGrantSourceGrant
	// WithdrawnGrantSourceRuleRef — объявление правила: сегмент перестал
	// резолвиться в каталог.
	WithdrawnGrantSourceRuleRef
)