Module: access - Bijection

Interfaces

References

bothAccessResults

Renames and re-exports __type

servicePrincipal

Renames and re-exports __type

AccessTrace

Re-exports AccessTrace

DisclosureArgs

Re-exports DisclosureArgs

ExecutionDescriptor

Re-exports ExecutionDescriptor

ReadAccessArgs

Re-exports ReadAccessArgs

Type Aliases

RetainedPermission

Ƭ RetainedPermission: Object Readonly evidence of an actual verified decision subject. The opaque value is bound to one model, resource check and application request. It cannot be used as a login, delegation, or permission to perform a mutation.

Type declaration

Name	Type
`evidence`	`string`
`allowed`	`boolean`
`principal`	`string`
`actor`	`string`
`expiresAt`	`number`

AccessReadExecution

Ƭ AccessReadExecution: { kind: "key" } | { kind: "unbound" } | { kind: "native" ; ranges: { index: string ; field: string ; labels?: string }[] } Not exported: an exported type refers to it.

AccessInstallation

Ƭ AccessInstallation: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`reads`	`string`[]
`read`	{ `execution`: `AccessReadExecution` ; `appliesDelegation`: `boolean` }
`read.execution`	`AccessReadExecution`
`read.appliesDelegation`	`boolean`
`write`	{ `kind`: `"native"` ; `basis`: `"original"` \| `"final"` ; `appliesDelegation`: `boolean` } \| `null`
`release`	{ `kind`: `"native"` ; `appliesDelegation`: `boolean` }
`release.kind`	`"native"`
`release.appliesDelegation`	`boolean`

AssignmentListing

Ƭ AssignmentListing: Readonly<{ resourceType: string ; includeGroups: boolean ; index: "by_resource" ; order: "asc" | "desc" ; execution: "indexFilter" }>

AccessResourceDefinition

Ƭ AccessResourceDefinition: Omit<AccessTypeDefinition, "table" | "erasable" | "parent" | "relations" | "read" | "unreadable" | "propertyRestrictions" | "immutable" | "write" | "fieldValidators" | "initialization" | "mutations" | "restrictions" | "integrity" | "conditions" | "resourceSets" | typeof conditionRequiredFields> & { parent?: string ; boundary?: "tenant" ; restrictions?: { root?: { type: string ; category: string } } } Business meaning, independent of the table storing a resource.

AccessDefinitionInput

Ƭ AccessDefinitionInput: Omit<AccessModelDefinition, "types" | "discoveries" | "observationSources" | "inputValidators" | "confer" | "requirements" | "conditions"> & { resources: Record<string, AccessResourceDefinition> ; assignmentRules?: AccessModelDefinition["confer"] ; requirements?: Record<string, AccessDefinitionRequirement> } One resource model; physical fields and indexes belong to schema bindings.

AccessDefinitionRequirement

Ƭ AccessDefinitionRequirement: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`on`	readonly [`string`, …string[]]
`onOrigins?`	readonly `AuthorityOrigin`[]
`decision?`	`NonNullable`<`AccessModelDefinition`[`"requirements"`]>[`string`][`"decision"`]
`when?`	`RequirementCondition`

AccessResourceBinding

Ƭ AccessResourceBinding<Field, Permission, Document, Definition, Target, SourceOwned>: Omit<BoundAccessResourceBinding<Field, Permission, Document, Definition, Target>, "read" | "write" | "unreadable" | "immutable" | "propertyRestrictions" | "fieldValidators" | "initialization" | "mutations" | SourceOwned extends true ? "transitions" | "integrity" : never> & { document: { read: AccessReadRequirement<Permission, Field, keyof Definition["resources"] & string> } & SourceOwned extends true ? { create?: never ; delete?: never } : { create: Extract<"create", Permission> | false ; delete: Extract<"delete", Permission> | false } ; fields: AccessFieldProtections<Field, Permission, keyof Definition["resources"] & string, Document, SourceOwned> ; metadata?: { _creationTime?: AccessReadRequirement<Permission, Field, keyof Definition["resources"] & string> | false } } & SourceOwned extends true ? { transitions?: never ; integrity?: never } : unknown Every field declares read protection. Locally owned tables also declare creation and update permissions; a source inherently owns those writes.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Permission`	extends `string` = `string`
`Document`	`Record`<`Field`, `string` \| `bigint` \| `boolean` \| readonly `string`[] \| readonly `bigint`[]>
`Definition`	extends `AccessDefinitionInput` = `AccessDefinitionInput`
`Target`	extends `string` = `string`
`SourceOwned`	extends `boolean` = `false`

AccessDocumentBinding

Ƭ AccessDocumentBinding<Field, Permission, Document, Definition, Target, SourceOwned>: Omit<AccessResourceBinding<Field, Permission, Document, Definition, Target, SourceOwned>, "document" | "fields"> & { document?: never ; fields?: AccessFieldExceptions<Field, Permission, keyof Definition["resources"] & string, Document, SourceOwned> } The short binding: the resource’s read, create, edit and delete permissions apply to the document, unlisted fields follow it, and fields names only the exceptions. Everything else a binding declares (its parent, relations, labels, transitions, integrity, requirements) keeps its meaning. Declaring document selects the exhaustive AccessResourceBinding.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Permission`	extends `string` = `string`
`Document`	`Record`<`Field`, `string` \| `bigint` \| `boolean` \| readonly `string`[] \| readonly `bigint`[]>
`Definition`	extends `AccessDefinitionInput` = `AccessDefinitionInput`
`Target`	extends `string` = `string`
`SourceOwned`	extends `boolean` = `false`

SourceReadAccessBinding

Ƭ SourceReadAccessBinding<Field, Permission, ParentField>: Object One read permission over an explicit list of source-owned fields. Every unlisted field, including one a connector adds later, stays unreadable. Compiles to the ordinary document and field grants.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Permission`	extends `string` = `string`
`ParentField`	extends `string` = `Field`

Type declaration

Name	Type
`read`	{ `permission`: `Permission` ; `fields`: readonly `Field`[] }
`read.permission`	`Permission`
`read.fields`	readonly `Field`[]
`parent?`	{ `field`: `ParentField` ; `index?`: `string` }
`parent.field`	`ParentField`
`parent.index?`	`string`

PrincipalSourceTable

Ƭ PrincipalSourceTable<Field>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`Field`	extends `string`

Type declaration

Name	Type
`[principalSource]`	`Field`

Binding

Ƭ Binding: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`table`	`Table`
`options`	`BoundAccessResourceBinding`

ClassifiedRead

Ƭ ClassifiedRead<R, Name, Field>: R extends false ? false : { permission: R extends string ? R : R extends { permission: infer P } ? P : never ; restrictions: readonly (R extends { restrictions: readonly infer T[] } ? T : never | { type: Name ; field: Field ; allowed: readonly string[] })[] } Not exported: an exported type refers to it.

Type parameters

Name	Type
`R`	`R`
`Name`	extends `string`
`Field`	extends `string`

ProfileCondition

Ƭ ProfileCondition: <Resource, Principal, Context>(scope: Parameters<AccessTransitionCondition<Resource, Principal, Context>>[0]) => AccessExpression

Type declaration

▸ <Resource, Principal, Context>(scope): AccessExpression Not exported: an exported type refers to it.

Type parameters

Name
`Resource`
`Principal`
`Context`

Parameters

Name	Type
`scope`	`Parameters`<`AccessTransitionCondition`<`Resource`, `Principal`, `Context`>>[`0`]

Returns

AccessExpression

ReadPermission

Ƭ ReadPermission<R>: R extends string ? R : R extends { permission: infer P } ? P : never Not exported: an exported type refers to it.

Type parameters

Name
`R`

ProfileReadCondition

Ƭ ProfileReadCondition: <Resource, Principal, Context>(scope: Parameters<AccessCondition<Resource, Principal, Context>>[0]) => AccessExpression

Type declaration

▸ <Resource, Principal, Context>(scope): AccessExpression Not exported: an exported type refers to it.

Type parameters

Name
`Resource`
`Principal`
`Context`

Parameters

Name	Type
`scope`	`Parameters`<`AccessCondition`<`Resource`, `Principal`, `Context`>>[`0`]

Returns

AccessExpression

ClassifiedBinding

Ƭ ClassifiedBinding<B, Name, Field>: Omit<B, "document" | "fields" | "metadata" | "labels" | "transitions" | "requirements"> & { document: Omit<B["document"], "read"> & { read: ClassifiedRead<B["document"]["read"], Name, Field> } ; fields: { [K in keyof B[“fields”]]: Omit<B[“fields”][K], “read”> & Object } ; labels: { field: Field ; type: Name } ; metadata?: B["metadata"] extends { _creationTime: infer R } ? { _creationTime: ClassifiedRead<R, Name, Field> } : never ; requirements: B extends { requirements: infer R } ? R : {} & Record<`classification_

\{Name}\`, \{ `on`: readonly [[`ReadPermission`](/api/modules/access#readpermission)\<`B`[``"document"``][``"read"``]\>] ; `when`: [`ProfileReadCondition`](/api/modules/access#profilereadcondition) \}\> ; `transitions`: `B` extends \{ `transitions`: infer T \} ? `T` : \{\} & `Record`\<\`classification\_

{Name}`, { on: readonly ("create" | "update" | "move")[] ; when: ProfileCondition }> } Not exported: an exported type refers to it.

Type parameters

Name	Type
`B`	extends `Binding`
`Name`	extends `string`
`Field`	extends `string`

ClassificationCategory

Ƭ ClassificationCategory: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`keys`	readonly `string`[]
`combine?`	`"all"` \| `"any"`
`dominates?`	`Readonly`<`Record`<`string`, readonly `string`[]>>

ClassificationKey

Ƭ ClassificationKey<C>: { [K in keyof C & string]: `

\{K}:

{C[K][“keys”][number]}` }[keyof C & string] Not exported: an exported type refers to it.

Type parameters

Name	Type
`C`	extends `Record`<`string`, `ClassificationCategory`>

LabelRegistrySnapshot

Ƭ LabelRegistrySnapshot: Object The organization’s central label registry as bijection organization label get --format json prints it. A profile bound to it compiles exactly these categories; other fields are ignored.

Type declaration

Name	Type
`organization_id`	`string`
`revision`	`number`
`categories`	readonly { `name`: `string` ; `combine`: `"all"` \| `"any"` ; `keys`: readonly `string`[] ; `dominates?`: `Readonly`<`Record`<`string`, readonly `string`[]>> }[]

RegistryCategories

Ƭ RegistryCategories<R>: { [K in R[“categories”][number] as K[“name”]]: Object } Not exported: an exported type refers to it.

Type parameters

Name	Type
`R`	extends `LabelRegistrySnapshot`

RegistryBinding

Ƭ RegistryBinding: Readonly<{ organization: string ; revision: number }> Not exported: an exported type refers to it.

ClassificationProfile

Ƭ ClassificationProfile<Name, Required, C>: ReturnType<typeof classificationProfile> A compiled classification profile.

Type parameters

Name	Type
`Name`	extends `string`
`Required`	extends readonly `string`[]
`C`	extends `Record`<`string`, `ClassificationCategory`>

Selection

Ƭ Selection: { readonly [K in keyof C & string]?: readonly C[K][“keys”][number][] } Not exported: an exported type refers to it.

Destination

Ƭ Destination: DisclosureArgs["destination"] Not exported: an exported type refers to it.

ComponentInstallationAccessRequest

Ƭ ComponentInstallationAccessRequest: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`component`	`string` \| `DeclarationReference`<`string`>
`worker?`	`never`
`custody`	`boolean`
`effects`	`Readonly`<`Record`<`string`, `never`>>

ComponentWorkerAccessRequest

Ƭ ComponentWorkerAccessRequest<Effects>: Object

Type parameters

Name	Type
`Effects`	extends `string` = `string`

Type declaration

Name	Type	Description
`component`	`string`	-
`worker`	`string`	-
`relative`	`boolean`	-
`custody`	`true`	-
`effects`	readonly `Effects`[] \| `null`	null exists only in initial symbolic references. Native admission always resolves the worker and validates the named effects against its analysis.

ComponentAccessRequest

Ƭ ComponentAccessRequest: ComponentInstallationAccessRequest | ComponentWorkerAccessRequest

ComponentWorkConsentOptions

Ƭ ComponentWorkConsentOptions<Effects>: Object

Type parameters

Name	Type
`Effects`	extends `string` = `string`

Type declaration

Name	Type
`retain?`	`boolean`
`effects?`	readonly `Effects`[]

ComponentDataConsent

Ƭ ComponentDataConsent: Object The host’s consent to one request, for rows of the from resources.

Type declaration

Name	Type	Description
`request`	`ComponentAccessRequest`	-
`from`	readonly `string`[]	-
`custody?`	`boolean`	Consent to the component’s scheduled work holding these rows.
`effects?`	readonly `string`[]	The request’s effects consented to, by name.

CompiledComponentBinding

Ƭ CompiledComponentBinding: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`component`	`string`
`worker`	`string` \| `null`
`relative`	`boolean`
`from`	`Set`<`string`>
`custody`	`boolean`
`effects`	{ `name`: `string` }[]

ComponentWorkBinding

Ƭ ComponentWorkBinding: Omit<ComponentDataConsent, "from"> The host’s consent to one request in a hand-written destination rule, which decides its own table’s rows.

AccessClaimType

Ƭ AccessClaimType: "String" | "Long" | "Bool" | "Set<String>" | "Set<Long>" Not exported: an exported type refers to it.

CompiledConferEnvelope

Ƭ CompiledConferEnvelope: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`permission`	`string`
`roles`	{ `kind`: `"exact"` ; `role`: `RoleRef` } \| { `kind`: `"permissions"` ; `type`: `string` ; `permissions`: { `kind`: `"all"` } \| { `kind`: `"only"` ; `permissions`: `string`[] } } \| { `kind`: `"tenant"` ; `type`: `string` }
`recipients`	`ConferRecipientKind`[]
`operations`	`ConferOperation`[]
`maxDuration?`	`number`
`selfOnly?`	`boolean`
`when?`	`Expr`

AssignmentHolder

Ƭ AssignmentHolder: { holderKind: "person" | "service" ; holderKey: string ; holderType?: never ; holderPermission?: never ; holderProgram?: never } | { holderKind: "group" ; holderKey: string ; holderType: string ; holderPermission: string ; holderProgram?: never } | { holderKind: "program" ; holderKey: string ; holderProgram: ProgramGrantRef ; holderType?: never ; holderPermission?: never } Not exported: an exported type refers to it.

AssignmentDocument

Ƭ AssignmentDocument: AssignmentHolder & { _id: GenericId<string> ; type: string ; key: string ; role: RoleRef ; expiresAt?: number ; _creationTime?: number ; reason?: string }

AccessCtx

Ƭ AccessCtx: Object The context a rule or helper needs. Every query context satisfies it.

Type declaration

Name	Type	Description
`auth`	`Auth`	-
`db`	`SelectableDatabaseReader`<`any`>	-
`sources?`	`Pick`<`Sources`, `"evidence"`>	The coverage of the sources that publish directory rows. Without it, no directory row confers a role. A rule decides from coverage alone; the acquisition schedule is not readable inside one.
`audit?`	(`body`: `AuditLogBody`) => `Promise`<`void`>	Where audit records go; `log.audit` unless given.

AccessMutationCtx

Ƭ AccessMutationCtx: Object The context of the grant mutation helpers.

Type declaration

Name	Type
`auth`	`Auth`
`db`	`Omit`<`GenericDatabaseWriter`<`any`>, `"query"`> & `SelectableDatabaseReader`<`any`>
`scheduler`	`Scheduler`
`audit?`	(`body`: `AuditLogBody`) => `Promise`<`void`>

AccessRefusalReason

AccessDecision

Ƭ AccessDecision: { kind: "allowed" ; validUntil: number | null } | { kind: "denied" ; code: "not_authorized" } | { kind: "unavailable" ; code: "evaluation_failed" } A disclosed permission result. Private provenance is never included.

PermissionResult

Ƭ PermissionResult: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`outcome`	`AuthorizationOutcome`
`validUntil`	`number` \| `null`

AccessCheck

Ƭ AccessCheck: Object One permission check of a batch: permission on the object key of type, as require takes them.

Type declaration

Name	Type
`permission`	`string`
`type`	`string`
`key`	`string`

AccessContractContext

ContractRequirement

Ƭ ContractRequirement: Term<AuthorityObligation>

ContractCase

Ƭ ContractCase: Readonly<{ on: "create" | "update" | "delete" ; changes: readonly string[] ; require: ContractRequirement }>

ContractStorage

Ƭ ContractStorage: Readonly<{ table: string ; schema: ValidatorJSON ; indexes: Readonly<Record<string, readonly string[]>> ; inputs: readonly string[] ; read: ReadProgram ; guard: ContractRequirement ; signatures: Readonly<Record<string, Readonly<{ publicKey: string ; usages: readonly string[] }>>> }>

RecordContractDeclaration

Ƭ RecordContractDeclaration: Readonly<{ storage: ContractStorage ; kind: "record" ; cases: Readonly<Record<string, ContractCase>> }>

ReviewedContractDeclaration

Ƭ ReviewedContractDeclaration: Readonly<{ storage: ContractStorage ; kind: "reviewed" ; state: Readonly<{ field: string ; proposed: string ; approved: string ; rejected: string ; withdrawn: string }> ; reviewer: string ; proposer: string ; expiry: string ; maxDuration: number ; propose: ContractRequirement ; approve: ContractRequirement ; reject: ContractRequirement ; withdraw: ContractRequirement }>

AccessContractDeclaration

Ƭ AccessContractDeclaration: RecordContractDeclaration | ReviewedContractDeclaration

DecisionInstallation

Ƭ DecisionInstallation: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`reads`	() => `string`[]
`resources`	() => `Record`<`string`, `string` \| `null`>
`program`	() => `AccessProgram`
`evaluate`	(`ctx`: `AccessCtx`, `checks`: readonly `AccessCheck`[]) => `Promise`<`PermissionResult`[]>

Term

Ƭ Term<A>: Readonly<{ kind: "atom" ; atom: A }> | Readonly<{ kind: "all" | "any" ; nodes: readonly Term<A>[] }> | Readonly<{ kind: "not" ; node: Term<A> }> | Readonly<{ kind: "choose" ; test: Term<A> ; yes: Term<A> ; no: Term<A> }> Not exported: an exported type refers to it.

Type parameters

Name
`A`

AuthorityInput

Ƭ AuthorityInput: { kind: "key" } | { kind: "literal" ; value: Value } | { kind: "before" | "after" ; field: string } | { kind: "row" ; slot: string ; field: string } | { kind: "absent" } | { kind: "execution" ; field: "principal" | "decisionActor" | "active" | "origin" | "direct" | "transactionTime" | "authenticatedAt" | "verifiedEmail" | "issuer" } | { kind: "present" | "trimmed" | "utf16Length" | "principalKind" ; input: AuthorityInput } | { kind: "fixedHex" ; input: AuthorityInput ; bytes: number } | { kind: "retained" ; input: AuthorityInput ; directory: AccessDirectory | null } | { kind: "deadline" ; duration: number } | { kind: "path" ; input: AuthorityInput ; field: string } | { kind: "default" ; input: AuthorityInput ; value: Value } | { kind: "principal" | "deadlineValue" ; input: AuthorityInput } | { kind: "recorded" ; table: string ; key: AuthorityInput ; image: "before" | "after" } | { kind: "changeCount" ; table: string ; added: boolean } Not exported: an exported type refers to it.

AuthorityObligation

Ƭ AuthorityObligation: { kind: "witness" ; verifier: string ; usage: string } | { kind: "onlyChanges" ; fields: readonly string[] } | { kind: "beforeExpiry" ; input: AuthorityInput } | { kind: "confer" ; assignment: AuthorityInput ; permissions: AuthorityInput ; operation: "grant" | "revoke" ; source: "original" | "placement" } | { kind: "programCustody" ; assignment: AuthorityInput } | { kind: "clearance" ; assignment: AuthorityInput } | { kind: "scopeChanged" ; assignment: AuthorityInput } | { kind: "construction" ; assignment: AuthorityInput ; resource: string ; permission: string } | { kind: "ceiling" ; key: AuthorityInput ; resource: string ; permission: string } | { kind: "reachability" ; key: AuthorityInput ; resource: string ; ancestor: AuthorityInput ; ancestorResource: string } | { kind: "environment" ; name: string ; bind: string ; body: Term<AuthorityObligation> } | { kind: "equal" ; left: AuthorityInput ; right: AuthorityInput } | { kind: "predicate" ; fields: Record<string, AccessClaimType> ; inputs: Record<string, AuthorityInput> ; expr: Expr } | { kind: "permission" ; basis: "original" ; judgment: PermissionJudgment ; permission: string ; on: ResourceRef ; lifetime: AuthorityLifetime } | { kind: "each" ; input: AuthorityInput ; bind: string ; body: Term<AuthorityObligation> } | { kind: "atMost" ; view: "original" | "final" ; table: string ; index: string ; pins: readonly readonly [string, AuthorityInput][] ; maximum: number } | { kind: "range" ; view: "original" | "final" ; table: string ; index: string ; pins: readonly readonly [string, AuthorityInput][] ; bind: string ; quantifier: "any" | "all" | "empty" ; body: Term<AuthorityObligation> } Not exported: an exported type refers to it.

AccessDiscoveryRoute

Ƭ AccessDiscoveryRoute: Readonly<{ kind: "get" }> | Readonly<{ kind: "shares" ; table: string ; index: string }> | Readonly<{ kind: "index" ; index: string }> | Readonly<{ kind: "scope" ; table: string ; index: string }> Not exported: an exported type refers to it.

AccessEmulationConfiguration

Ƭ AccessEmulationConfiguration: Object An immutable centrally declared scope, authorized through native grants. Eligibility does not grant any of the scope’s permissions.

Type declaration

Name	Type
`requiredPreset`	`boolean`
`applications?`	`Record`<`string`, { `organization`: { `type`: `string` ; `key`: `string` } ; `eligibilityPermission`: `string` ; `dependencies`: readonly { `name`: `string` ; `resource`: { `type`: `string` ; `key`: `string` } ; `permissions`: readonly `string`[] }[] }>
`presets`	`Record`<`string`, { `organization`: { `type`: `string` ; `key`: `string` } ; `eligibilityPermission`: `string` ; `scope`: { `resources`: readonly { `type`: `string` ; `key`: `string` }[] ; `roles?`: readonly `string`[] ; `permissions?`: readonly `string`[] ; `grantSources?`: { `direct`: `boolean` ; `groups`: readonly { `type`: `string` ; `key`: `string` }[] } ; `clearances?`: readonly { `type`: `string` ; `key`: `string` }[] } ; `targets`: readonly (`"live"` \| `"sandbox"`)[] ; `maxDurationMs`: `number` }>

ContactKind

Ƭ ContactKind: "phone" | "email" Typed evidence declarations. These describe propositions, never grants.

ContactField

Ƭ ContactField: Readonly<{ kind: ContactKind ; field: string }>

ContactIdentity

Ƭ ContactIdentity: Readonly<{ kind: ContactKind ; value: string }>

EvidenceType

Ƭ EvidenceType: { kind: "resource" ; resource: string } | { kind: "contact" ; contact: ContactKind } | { kind: "principal" } | { kind: "string" } | { kind: "bool" } | { kind: "long" }

EvidenceDeclaration

Ƭ EvidenceDeclaration: Readonly<{ scope: "participant" | "principal" ; fields: Readonly<Record<string, EvidenceType>> }> Scope selects the evidence custody/audience namespace. The declared fields define its statement: consuming requirements bind every field, including any proposal, input version, program identity and permitted use the statement needs. A verifier establishes facts; neither its output nor these bindings grants a role.

EvidenceValue

Ƭ EvidenceValue: { kind: "resource" ; resource: string ; key: string } | { kind: "contact" ; contact: ContactIdentity } | { kind: "principal" ; principal: string } | { kind: "string" ; value: string } | { kind: "bool" ; value: boolean } | { kind: "long" ; value: string }

ConditionScalar

Ƭ ConditionScalar: string | bigint | boolean Not exported: an exported type refers to it.

ConditionValue

Ƭ ConditionValue: ConditionScalar | readonly string[] | readonly bigint[] Not exported: an exported type refers to it.

Operand

Ƭ Operand<T>: T | AccessExpression<T> Not exported: an exported type refers to it.

Type parameters

Name
`T`

AccessOptionalExpression

Ƭ AccessOptionalExpression<T>: Pick<AccessExpression<T>, "match" | "isPresent"> Not exported: an exported type refers to it.

Type parameters

Name
`T`

References

Ƭ References<T>: { readonly [K in keyof T as NonNullable<T[K]> extends ConditionValue ? K : never]-?: 0 extends 1 & T[K] ? AccessExpression<any> : NonNullable<T[K]> extends readonly unknown[] ? undefined extends T[K] ? Pick<AccessArrayExpression<NonNullable<T[K]>>, “isPresent” | “match”> : null extends T[K] ? Pick<AccessArrayExpression<NonNullable<T[K]>>, “isPresent” | “match”> : AccessArrayExpression<NonNullable<T[K]>> : undefined extends T[K] ? AccessOptionalExpression<NonNullable<T[K]>> : null extends T[K] ? AccessOptionalExpression<NonNullable<T[K]>> : AccessExpression<T[K]> } Not exported: an exported type refers to it.

Type parameters

Name
`T`

AccessConditionScope

Ƭ AccessConditionScope<Resource, Principal, Context>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`Resource`	`any`
`Principal`	`any`
`Context`	`any`

Type declaration

Name	Type
`resource`	`References`<`Resource`>
`principal`	`References`<`Principal`>
`claims`	`References`<`Context`>
`set`	<T>(`value`: `AccessArrayExpression`<`T`> \| `AccessExpression`<`T`> \| `T`) => `AccessExpression`<`T`>
`all`	(…`conditions`: `AccessExpression`<`boolean`>[]) => `AccessExpression`<`boolean`>
`any`	(…`conditions`: `AccessExpression`<`boolean`>[]) => `AccessExpression`<`boolean`>
`not`	(`condition`: `AccessExpression`<`boolean`>) => `AccessExpression`<`boolean`>
`literal`	<T>(`value`: `T`) => `AccessExpression`<`T`>

AccessCondition

Ƭ AccessCondition<Resource, Principal, Context>: (scope: AccessConditionScope<Resource, Principal, Context>) => AccessExpression<boolean>

Type parameters

Name	Type
`Resource`	`any`
`Principal`	`any`
`Context`	`any`

Type declaration

▸ (scope): AccessExpression<boolean> Not exported: an exported type refers to it.

Parameters

Name	Type
`scope`	`AccessConditionScope`<`Resource`, `Principal`, `Context`>

Returns

AccessExpression<boolean>

CompiledConditionBuilder

Ƭ CompiledConditionBuilder: (scope: any) => AccessExpression<boolean>

Type declaration

▸ (scope): AccessExpression<boolean> Not exported: an exported type refers to it.

Parameters

Name	Type
`scope`	`any`

Returns

AccessExpression<boolean>

StateValue

Ƭ StateValue: string | boolean | bigint Not exported: an exported type refers to it.

FieldState

Ƭ FieldState<T>: undefined extends T ? { initial?: never ; transitions?: never } : [T] extends [StateValue] ? { initial?: T ; transitions?: readonly readonly [T, T][] } : { initial?: never ; transitions?: never } Not exported: an exported type refers to it.

Type parameters

Name
`T`

AccessReadRequirement

Ƭ AccessReadRequirement<Permission, Field, Resource>: true | Permission | { permission: Permission ; restrictions: readonly (AccessReadRestriction<Resource> | AccessReadLabelField<Field, Resource>)[] } Additional mandatory protections on a readable row or value.

Type parameters

Name	Type
`Permission`	extends `string` = `string`
`Field`	extends `string` = `string`
`Resource`	extends `string` = `string`

AccessFieldProtection

Ƭ AccessFieldProtection<Permission, Field, Resource>: Object One explicit classification for a stored application field.

Type parameters

Name	Type
`Permission`	extends `string` = `string`
`Field`	extends `string` = `string`
`Resource`	extends `string` = `string`

Type declaration

Name	Type	Description
`read`	`AccessReadRequirement`<`Permission`, `Field`, `Resource`> \| `false`	-
`create`	`Extract`<`"create"`, `Permission`> \| `false`	Initialization is permitted only under the row’s creation permission.
`update`	`Permission` \| `false`	-
`whole?`	`GenericValidator`	Explicit whole-value classification for opaque payloads. Its validator must equal this field’s schema, including nested fields.
`fields?`	`Record`<`string`, `AccessFieldProtection`<`Permission`, `Field`, `Resource`>>	-
`items?`	`AccessFieldProtection`<`Permission`, `Field`, `Resource`>	-
`initial?`	`StateValue`	-
`transitions?`	readonly readonly [`StateValue`, `StateValue`][]	-

FieldPolicy

Ƭ FieldPolicy<P, F, R, SourceOwned>: Pick<AccessFieldProtection<P, F, R>, "read"> & SourceOwned extends true ? { create?: never ; update?: never } : Pick<AccessFieldProtection<P, F, R>, "create" | "update"> Not exported: an exported type refers to it.

Type parameters

Name	Type
`P`	extends `string`
`F`	extends `string`
`R`	extends `string`
`SourceOwned`	extends `boolean` = `false`

AccessFieldProtections

Ƭ AccessFieldProtections<Field, Permission, Resource, Document, SourceOwned>: { [K in Field as K extends `_${string}` ? never : K]-?: FieldPolicy<Permission, Field, Resource, SourceOwned> & (K extends keyof Document ? FieldShape<Document[K], Permission, Field, Resource, SourceOwned> & (SourceOwned extends true ? Object : FieldState<Document[K]>) : unknown) } Every application field is classified, including optional fields.

Type parameters

Name	Type
`Field`	extends `string`
`Permission`	extends `string`
`Resource`	extends `string`
`Document`	`Record`<`Field`, `unknown`>
`SourceOwned`	extends `boolean` = `false`

AccessFieldExceptions

Ƭ AccessFieldExceptions<Field, Permission, Resource, Document, SourceOwned>: { [K in Field as K extends `_${string}` ? never : K]?: Partial<FieldPolicy<Permission, Field, Resource, SourceOwned>> & (K extends keyof Document ? ExceptionShape<Document[K], Permission, Field, Resource, SourceOwned> & (SourceOwned extends true ? Object : FieldState<Document[K]>) : unknown) } Not exported: an exported type refers to it.

Type parameters

Name	Type
`Field`	extends `string`
`Permission`	extends `string`
`Resource`	extends `string`
`Document`	`Record`<`Field`, `unknown`>
`SourceOwned`	extends `boolean` = `false`

FieldException

Ƭ FieldException<T, P, F, R, SourceOwned>: Partial<FieldPolicy<P, F, R, SourceOwned>> & ExceptionShape<T, P, F, R, SourceOwned> Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`P`	extends `string`
`F`	extends `string`
`R`	extends `string`
`SourceOwned`	extends `boolean`

ExceptionShape

Ƭ ExceptionShape<T, P, F, R, SourceOwned>: 0 extends 1 & T ? { whole?: GenericValidator ; fields?: never ; items?: never } : [NonNullable<T>] extends [Geometry<GeometrySpace> | Position | ObjectRef] ? { whole?: never ; fields?: never ; items?: never } : [NonNullable<T>] extends [readonly infer Item[]] ? true extends Structured<Item> ? { items?: FieldException<Item, P, F, R, SourceOwned> ; fields?: never ; whole?: never } : { fields?: never ; items?: never ; whole?: never } : true extends Structured<T> ? string extends Keys<NonNullable<T>> ? { whole?: GenericValidator ; fields?: never ; items?: never } : { fields?: { [K in Keys<NonNullable<T>> & string]?: FieldException<At<NonNullable<T>, K>, P, F, R, SourceOwned> } ; items?: never ; whole?: never } : { fields?: never ; items?: never ; whole?: never } Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`P`	extends `string`
`F`	extends `string`
`R`	extends `string`
`SourceOwned`	extends `boolean`

Keys

Type parameters

Name
`T`

At

Ƭ At<T, K>: T extends unknown ? K extends keyof T ? T[K] : never : never Not exported: an exported type refers to it.

Type parameters

Name
`T`
`K`

FieldShape

Ƭ FieldShape<T, P, F, R, SourceOwned>: 0 extends 1 & T ? { whole?: GenericValidator ; fields?: never ; items?: never } : [NonNullable<T>] extends [Geometry<GeometrySpace> | Position | ObjectRef] ? { whole?: never ; fields?: never ; items?: never } : [NonNullable<T>] extends [readonly infer Item[]] ? true extends Structured<Item> ? { items: FieldPolicy<P, F, R, SourceOwned> & FieldShape<Item, P, F, R, SourceOwned> ; fields?: never ; whole?: never } : { fields?: never ; items?: never ; whole?: never } : true extends Structured<T> ? string extends Keys<NonNullable<T>> ? { whole: GenericValidator ; fields?: never ; items?: never } : { fields: { [K in Keys<NonNullable<T>> & string]-?: FieldPolicy<P, F, R, SourceOwned> & FieldShape<At<NonNullable<T>, K>, P, F, R, SourceOwned> } ; items?: never ; whole?: never } : { fields?: never ; items?: never ; whole?: never } Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`P`	extends `string`
`F`	extends `string`
`R`	extends `string`
`SourceOwned`	extends `boolean`

Structured

Ƭ Structured<T>: 0 extends 1 & T ? true : T extends readonly infer Item[] ? Structured<Item> : T extends string | number | bigint | boolean | ArrayBuffer | CommitTsPlaceholder | ObjectRef ? false : T extends object ? true : false Not exported: an exported type refers to it.

Type parameters

Name
`T`

AccessIdentity

Ƭ AccessIdentity: Object Verified request evidence and its application-owned association key. Resolving a key never rewrites the issuer, subject or session claims.

Type declaration

Name	Type
`verified`	`UserIdentity`
`identityKey`	`string`

AccessInformationProtection

Ƭ AccessInformationProtection<Field, Resource>: Object One reusable protection.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Resource`	extends `string` = `string`

Type declaration

Name	Type	Description
`restrictions?`	readonly (`AccessReadRestriction`<`Resource`> \| `AccessReadLabelField`<`Field`, `Resource`>)[]	Restrictions a reader must clear, carried with derived information.
`immutable?`	`true`	The value may be set at creation and never changes afterwards.

VisibleRead

Ƭ VisibleRead: { id: string ; kind: "object" ; object: Record<string, unknown> } | { id: string ; kind: "absent" } | { id: string ; kind: "restricted" } One identifier of a visible read: the object, with each selected property outside its visibility permission wrapped as a VisibleValue; or absent; or restricted when the reader may not see the object at all.

PermissionExplanation

Ƭ PermissionExplanation: { authenticationRequired?: PermissionAuthentication ; permission: string ; emulation?: "allowed" | "ordinaryAuthority" | "permissionCeiling" | "resourceBounds" | "grantSources" | "clearances" | "unavailable" ; steps: AccessStep[] ; trace?: AccessTrace ; actions?: { kind: "request" ; role: string }[] } & { outcome: "allowed" ; validUntil: number | null ; via: string | null } | { outcome: "denied" ; reason: AccessRefusalReason ; refusedBy: string } | { outcome: "unavailable" ; missingFacts: string[] } How one permission on one object is decided for a principal.

AccessOutcome

Ƭ AccessOutcome: "allowed" | "denied" | "unavailable" An inspected permission’s outcome. Invalid security metadata or an evaluation failure is an error, never an outcome.

PolicyCompilationIdentity

Ƭ PolicyCompilationIdentity: Readonly<{ compilationDigest: string ; declarationDigest: string ; entryDigest: string ; schemaBindingDigest: string | null ; compilerRevision: string ; cedarVersion: string ; clauseCount: number }> Identity of the admitted compiler plan. This carries no captured rows, private predicate values, or authority to reuse an inspection as a permit.

ExecutionObservation

Ƭ ExecutionObservation: Object

Type declaration

Name	Type
`basis`	`AccessInspectionBasis`
`execution`	`ExecutionDescriptor` \| `null`

AccessIntegrity

Ƭ AccessIntegrity<Field>: Object Closed structural invariants over engine-recorded row images. These constrain writes; they never grant a permission. They do not track what influenced a value: information-flow protection belongs in defineInformationProtection.

Type parameters

Name	Type
`Field`	extends `string` = `string`

Type declaration

Name	Type
`insertOnly?`	`true`
`noDelete?`	`true`
`unchanged?`	readonly `Field`[]
`writeOnce?`	readonly `Field`[]
`issuedOnly?`	readonly `Field`[]

AccessResolution

Ƭ AccessResolution: { kind: "ready" } | { kind: "interactionRequired" ; offers: AccessRecoveryOffer[] } | { kind: "refused" ; code: "not_authorized" } | { kind: "unavailable" ; code: "evaluation_failed" } A current inspection’s disclosed next step. Offers remain advisory and owner-bound; completing one never retries the business operation.

AccessFields

Ƭ AccessFields: readonly string[] | "rest" The fields a permission covers: a list, or every field no other permission of the same map lists.

AccessReadRestriction

Ƭ AccessReadRestriction<Type>: Object A mandatory classification on values released by one permission.

Type parameters

Name	Type
`Type`	extends `string` = `string`

Type declaration

Name	Type
`type`	`Type`
`key`	`string`
`field?`	`never`
`allowed?`	`never`

AccessReadLabelField

Ƭ AccessReadLabelField<Field, Type>: Object Labels each row carries for one read group: field holds the keys of the row’s labels, each one of allowed. A reader passes them as a row’s own labels are passed: every label of an all category, one of each any category’s. A key outside allowed is invalid security metadata, an error rather than an empty set. allowed bounds the work a projection spends resolving passes; it grants nothing.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Type`	extends `string` = `string`

Type declaration

Name	Type
`type`	`Type`
`field`	`Field`
`allowed`	readonly `string`[]
`key?`	`never`

AccessReadGroup

Ƭ AccessReadGroup<Field, Type>: readonly Field[] | "rest" | { fields: readonly Field[] | "rest" ; restrictions: readonly (AccessReadRestriction<Type> | AccessReadLabelField<Field, Type>)[] } Fields covered by a read permission and the labels every reader must pass: fixed labels, each required independently, and labels each row carries in a field. Roles cannot override them.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Type`	extends `string` = `string`

AccessCreation

Ƭ AccessCreation: Object What creating an object also establishes in the same transaction: an assignment of a fixed role of its type to its creator.

Type declaration

Name	Type	Description
`assign`	{ `role`: `string` ; `holder`: `"creator"` }	-
`assign.role`	`string`	-
`assign.holder`	`"creator"`	-
`children?`	readonly `string`[]	Child types whose constructors may compose with this fresh parent.

AccessTypeDefinition

Ƭ AccessTypeDefinition: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`table?`	`string`
`parent?`	{ `field`: `string` ; `type`: `string` ; `index`: `string` }
`parent.field`	`string`
`parent.type`	`string`
`parent.index`	`string`
`relations?`	`Record`<`string`, { `type`: `string` ; `index`: `string` }>
`permissions?`	readonly `string`[]
`audience?`	`Record`<`string`, `"public"`>
`erasable?`	`boolean`
`read?`	`Record`<`string`, `AccessReadGroup`>
`propertyRestrictions?`	`Record`<`string`, readonly (`AccessReadRestriction` \| `AccessReadLabelField`)[]>
`unreadable?`	readonly `string`[]
`immutable?`	readonly `string`[]
`initialization?`	`Record`<`string`, `boolean`>
`fieldValidators?`	`Record`<`string`, `unknown`>
`mutations?`	{ `create`: `boolean` ; `delete`: `boolean` }
`mutations.create`	`boolean`
`mutations.delete`	`boolean`
`conditions?`	`Record`<`string`, { `on`: readonly `string`[] ; `when`: `CompiledConditionBuilder` }>
`resourceSets?`	`Record`<`string`, `ResourceSetDefinition`>
`transitions?`	`Record`<`string`, `TransitionConditionDeclaration`>
`fields?`	`Record`<`string`, `AccessClaimType`>
`[conditionRequiredFields]?`	readonly `string`[]
`write?`	`Record`<`string`, `AccessFields`>
`restrictions?`	{ `root?`: { `type`: `string` ; `category`: `string` } ; `field?`: { `name`: `string` ; `type`: `string` } }
`restrictions.root?`	{ `type`: `string` ; `category`: `string` }
`restrictions.root.type`	`string`
`restrictions.root.category`	`string`
`restrictions.field?`	{ `name`: `string` ; `type`: `string` }
`restrictions.field.name`	`string`
`restrictions.field.type`	`string`
`category?`	`string` \| { `from`: `"key"` }
`dominates?`	`Readonly`<`Record`<`string`, readonly `string`[]>>
`clearance?`	`"registry"`
`create?`	`AccessCreation`
`recovery?`	{ `role`: `string` }
`recovery.role`	`string`
`holders?`	`string`
`integrity?`	`AccessIntegrity`

AccessRoleDefinition

Ƭ AccessRoleDefinition: readonly string[] | { permissions: readonly string[] ; assignment?: { maxDuration?: number ; reasonRequired?: boolean ; selfGrant?: string ; requestable?: boolean ; guests?: boolean ; purpose?: string } ; issuance?: Record<string, never> } A role: the permissions it bundles, as type:name, type:* or type:grant.*, on its own type and descendant types. A role may bound the duration of its grants, require a written reason on each, and let holders of a permission of its type grant it to themselves: just-in-time access, which must then be bounded and justified, and which ends no later than the holder’s own grant of that permission.

AccessDirectory

Ƭ AccessDirectory: Object A source-owned table of identity-provider memberships assigning role on (member, object) pairs. index covers [member, object]. A row is the same assignment a grant record of that role and holder would be: one evaluator decides both. A row confers its role only while the source that published it (its source_id) has not lost continuity and either the exact record or a completed population acquisition was observed less than maxAge milliseconds ago, read through ctx.sources.evidence. A removal the provider exposes at time t therefore takes effect by t + maxAge at the latest, whether or not the sync runs, and a decision relying on a membership is valid until its source’s observation is maxAge old. An observation stamped later than the decision’s clock counts as made then, so no decision outlasts maxAge from now. A row without a source, or a context without sources, confers nothing.

Type declaration

Name	Type	Description
`table`	`string`	-
`memberIndex`	`string`	-
`objectIndex`	`string`	-
`type`	`string`	-
`role`	`string`	-
`object`	`string`	-
`member`	`string`	-
`maxAge`	`number`	How old, in milliseconds, the source’s oldest qualifying observation may be for its rows to confer the role: 1 s to 365 days.

AccessDirectoryDeclaration

Ƭ AccessDirectoryDeclaration: Omit<AccessDirectory, "role"> & { role: Extract<RoleRef, { kind: "declared" }> } A directory as a model declares it. role is a stable reference to a declared role of type ({ kind: "declared", key }); a tenant role is tenant data no model can name. A bounded role’s maxDuration runs from when the source first asserted the membership: refreshing the same assertion keeps its row, and so its start. A role requiring a reason or granting itself cannot be a directory’s.

AccessDirectoryCoverage

Ƭ AccessDirectoryCoverage: Pick<SourceEvidence, "populationCovered" | "populationObservedFrom" | "recordObservedFrom" | "continuityLost" | "erased"> What a directory’s freshness rule reads of a source’s coverage.

AccessRoleDefinitions

Ƭ AccessRoleDefinitions: Object Immutable tenant role bundles, scoped to one tenant root. Definition authority is separate from data use and bounded by an explicit permission envelope. Assignments separately require grant.custom on their target.

Type declaration

Name	Type	Description
`table`	`string`	-
`scope`	`string`	-
`permissions`	`string`[]	Administrative envelope, independent of the administrator’s data access. `*` explicitly admits every permission below this scope.

RoleDefinitionDocument

Ƭ RoleDefinitionDocument: Object One tenant-defined role: the permissions, as type:name, of a role of type usable on objects under the scope object scope. maxDuration bounds its grants as a declared role’s does: each must expire within it, and renewing one extends it for at most that long.

Type declaration

Name	Type
`_id`	`GenericId`<`string`>
`scope`	`string`
`type`	`string`
`name`	`string`
`permissions`	`string`[]
`maxDuration?`	`number`
`reasonRequired?`	`boolean`
`guests?`	`boolean`

AccessServiceDefinition

Ƭ AccessServiceDefinition: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`description`	`string`
`ceiling`	readonly `string`[]
`maxDuration?`	`number`

AccessClientRestrictions

Ƭ AccessClientRestrictions: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`required`	`boolean`
`providers`	`Record`<`string`, `string`>
`credentials`	`Record`<`string`, `string`>
`applications`	`Record`<`string`, { `nativeSession?`: `true` ; `scopePermissions?`: `Readonly`<`Record`<`string`, readonly `string`[]>> ; `permissions`: readonly `string`[] ; `resources?`: readonly { `type`: `string` ; `key`: `string` }[] ; `functions?`: readonly `string`[] ; `maxDuration?`: `number` }>

AccessInitialOwner

Ƭ AccessInitialOwner: string | { environment: string } A bootstrap identity key, or the deployment variable holding it.

AccessModelDefinition

Ƭ AccessModelDefinition: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`contracts?`	`Readonly`<`Record`<`string`, `AccessContractDeclaration`>>
`assignmentListings?`	`Record`<`string`, `AssignmentListing`>
`observationSources?`	`Record`<`string`, { `table`: `string` ; `inputs`: readonly `string`[] }>
`discoveries?`	`Readonly`<`Record`<`string`, `AccessDiscoveryDefinition`>>
`initialOwner?`	`AccessInitialOwner`
`assignments?`	`string`
`requests?`	`string`
`categories?`	`Record`<`string`, `"all"` \| `"any"`>
`types`	`Record`<`string`, `AccessTypeDefinition`>
`roles`	`Record`<`string`, `AccessRoleDefinition`>
`confer?`	`Record`<`string`, `Omit`<`AccessConferEnvelope`, `"when"`> & { `when?`: (`scope`: `any`) => `AccessExpression` }>
`evidence?`	`Record`<`string`, `EvidenceDeclaration`>
`requirements?`	`Record`<`string`, `PermissionRequirement`>
`services?`	`Record`<`string`, `AccessServiceDefinition`>
`clients?`	`AccessClientRestrictions`
`emulation?`	`AccessEmulationConfiguration`
`guests?`	{ `maxDuration?`: `number` }
`guests.maxDuration?`	`number`
`groups?`	{ `types?`: readonly `string`[] }
`groups.types?`	readonly `string`[]
`directories?`	readonly `AccessDirectoryDeclaration`[]
`roleDefinitions?`	`AccessRoleDefinitions`
`claims?`	`Record`<`string`, `AccessClaimType`>
`inputValidators?`	`AccessInputValidators`
`conditions?`	`Record`<`string`, { `when`: `CompiledConditionBuilder` ; `on?`: readonly `string`[] }>
`requestScope?`	{ `objects?`: `string` ; `permissions?`: `string` }
`requestScope.objects?`	`string`
`requestScope.permissions?`	`string`
`destinations?`	`Record`<`string`, `AccessDestinationTarget`>
`releases?`	`Record`<`string`, `AccessRelease`>
`components?`	readonly `ComponentDataConsent`[]
`audit?`	`boolean`
`users?`	{ `table`: `string` ; `index`: `string` ; `user`: `string` ; `principalIndex`: `string` ; `attributes?`: `Record`<`string`, `AccessClaimType`> }
`users.table`	`string`
`users.index`	`string`
`users.user`	`string`
`users.principalIndex`	`string`
`users.attributes?`	`Record`<`string`, `AccessClaimType`>

Fields

Ƭ Fields: Map<string, string> & { rest?: string } Not exported: an exported type refers to it.

CompiledType

Ƭ CompiledType: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`erasable`	`boolean`
`table?`	`string`
`parent`	{ `type`: `string` ; `field?`: `string` ; `index`: `string` }
`parent.type`	`string`
`parent.field?`	`string`
`parent.index`	`string`
`relations`	`Map`<`string`, { `type`: `string` ; `index`: `string` }>
`permissions`	`Set`<`string`>
`readFields`	`Fields`
`readGroups`	`Map`<`string`, `AccessFields`>
`readRestrictions`	`Map`<`string`, `AccessReadRestriction`[]>
`propertyRestrictions`	`Map`<`string`, `AccessReadRestriction`[]>
`propertyLabelFields`	`Map`<`string`, { `type`: `string` ; `field`: `string` ; `allowed`: `string`[] }[]>
`readLabelFields`	`Map`<`string`, { `type`: `string` ; `field`: `string` ; `allowed`: `string`[] }[]>
`visibility`	`string`
`unreadable`	`Set`<`string`>
`writeFields`	`Fields`
`root?`	{ `type`: `string` ; `category`: `string` }
`root.type`	`string`
`root.category`	`string`
`inheritedRoots`	{ `type`: `string` ; `category`: `string` }[]
`restrictionField?`	{ `name`: `string` ; `type`: `string` }
`restrictionField.name`	`string`
`restrictionField.type`	`string`
`category?`	`string` \| { `from`: `"key"` }
`dominates?`	`Readonly`<`Record`<`string`, readonly `string`[]>>
`create?`	`AccessCreation`
`recovery?`	{ `role`: `string` }
`recovery.role`	`string`
`holders?`	`string`
`integrity?`	`AccessIntegrity`
`resourceConditions`	{ `name`: `string` ; `on`: `string`[] ; `expr`: `Expr` ; `fields`: `Set`<`string`> }[]
`resourceSets`	`Record`<`string`, `InstalledResourceSet`>
`transitionConditions`	`CompiledTransitionCondition`[]
`conditionFields`	`Record`<`string`, `AccessClaimType`>
`requiredConditionFields`	`Set`<`string`>

CompiledService

Ƭ CompiledService: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`description`	`string`
`ceiling`	`Set`<`string`>
`maxDuration?`	`number`

CompiledRole

Ƭ CompiledRole: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`type`	`string`
`permissions`	`Set`<`string`>
`maxDuration?`	`number`
`reasonRequired`	`boolean`
`selfGrant?`	`string`
`requestable`	`boolean`
`guests`	`boolean`
`purpose?`	`string`
`sessions`	`boolean`

Compiled

Ƭ Compiled: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`assignmentListings`	`Record`<`string`, `AssignmentListing`>
`partitionLimits`	`Record`<`string`, `Record`<`string`, `PartitionLimit`>>
`observationSources`	`Record`<`string`, { `table`: `string` ; `inputs`: readonly `string`[] }>
`declaration?`	`CanonicalAccessDeclaration`
`contracts`	`Readonly`<`Record`<`string`, `AccessContractDeclaration`>>
`discoveries`	`Readonly`<`Record`<`string`, `AccessDiscoveryDefinition`>>
`session?`	{ `people`: `string` ; `services`: `string` }
`session.people`	`string`
`session.services`	`string`
`initialOwner?`	`AccessInitialOwner`
`assignments`	`string`
`requests?`	`string`
`categories`	`Record`<`string`, `"all"` \| `"any"`>
`rootCategories`	`Set`<`string`>
`types`	`Map`<`string`, `CompiledType`>
`byTable`	`Map`<`string`, `CompiledType`>
`permissionCandidates`	`ReadonlyMap`<`string`, readonly `string`[]>
`permissionTargets`	`ReadonlyMap`<`string`, `string`>
`roles`	`Map`<`string`, `CompiledRole`>
`confer`	`Map`<`string`, `CompiledConferEnvelope`>
`evidence`	`Map`<`string`, `EvidenceDeclaration`>
`requirements`	`Readonly`<`Record`<`string`, `CompiledPermissionRequirement`>>
`services`	`Map`<`string`, `CompiledService`>
`clients?`	`CompiledClientRestrictions`
`guests`	{ `maxDuration`: `number` }
`guests.maxDuration`	`number`
`principalTypes`	`string`[]
`directories`	`AccessDirectory`[]
`users?`	`AccessModelDefinition`[`"users"`]
`roleDefinitions?`	`AccessRoleDefinitions`
`claims`	`Record`<`string`, `AccessClaimType`>
`conditions`	{ `name`: `string` ; `expr`: `Expr` ; `claims`: `Set`<`string`> ; `on`: `Set`<`string`> \| `null` }[]
`requestScope`	{ `objects?`: `string` ; `permissions?`: `string` }
`requestScope.objects?`	`string`
`requestScope.permissions?`	`string`
`audit`	`boolean`
`scoped`	`Set`<`string`>
`inputs`	`string`[]
`releases`	`CompiledRelease`[]
`components`	`CompiledComponentBinding`[]

PrincipalSource

Ƭ PrincipalSource: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`kind`	`"workspaceIdentity"`
`table`	`string`
`index`	`string`
`person`	`string`

WorkspaceStandingRequirement

Ƭ WorkspaceStandingRequirement: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`kind`	`"workspaceStanding"`
`people`	`string`
`services`	`string`

StorageBinding

Ƭ StorageBinding: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`table`	`string`

Table

Ƭ Table: GenericSchema[string] Not exported: an exported type refers to it.

Model

Ƭ Model<T>: DataModelFromSchemaDefinition<SchemaDefinition<{ observation: T }, true>> Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	extends `Table`

Info

Ƭ Info<T>: Model<T>[keyof Model<T>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	extends `Table`

Ƭ Next: [1, 2, 3, 4] Not exported: an exported type refers to it.

BoundValue

Ƭ BoundValue<T>: T extends string | boolean | bigint ? T | AccessExpression<T> : never | T extends GenericId<string> ? AccessExpression<string> : never | T extends string ? Extract<RequirementValue, { kind: "principal" | "program" }> : never | T extends string | boolean | bigint ? Extract<RequirementValue, { kind: "claim" }> : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

Policy

Ƭ Policy: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`table`	`string`
`policy`	`SchemaAccessPolicy`

Address

Ƭ Address: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`module`	`string`
`export`	`string`

InstalledRule

Ƭ InstalledRule: ReturnType<typeof decisionQuery> | ReturnType<typeof expiryMutation> Not exported: an exported type refers to it.

AssignmentLifecycle

Ƭ AssignmentLifecycle: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`table`	() => `string`
`expire`	(`ctx`: `AccessMutationCtx`, `args`: { `assignmentId`: `GenericId`<`string`> }) => `Promise`<`null`>

AccessResourceRef

Ƭ AccessResourceRef: { type: "root" ; id?: never ; key?: never } | { type: string ; id: string ; key?: never } | { type: string ; key: string ; id?: never }

RoleRef

Ƭ RoleRef<Key>: Key | Extract<NativeRoleRef, { kind: "tenant" }>

Type parameters

Name	Type
`Key`	extends `string` = `string`

AccessPrincipal

Ƭ AccessPrincipal<UserId, Service>: { kind: "user" ; userId: UserId } | { kind: "service" ; name: Service } | { kind: "session" ; service: Service ; id: string }

Type parameters

Name	Type
`UserId`	extends `string` = `string`
`Service`	extends `string` = `string`

Holder

Ƭ Holder<UserId>: Exclude<AccessPrincipal<UserId>, { kind: "session" }> | { kind: "group" ; resource: AccessResourceRef ; memberPermission: string } | { kind: "program" ; program: ProgramGrantRef }

Type parameters

Name	Type
`UserId`	extends `string` = `string`

HolderInput

Ƭ HolderInput: Holder | { kind: "self" } | { kind: "identity" ; tokenIdentifier: string }

Assignment

Ƭ Assignment<AssignmentId>: Object

Type parameters

Name	Type
`AssignmentId`	extends `GenericId`<`string`> = `GenericId`<`string`>

Type declaration

Name	Type
`id`	`AssignmentId`
`resource`	`AccessResourceRef`
`role`	`RoleRef`
`holder`	`Holder`
`expiresAt?`	`number`
`reason?`	`string`

AssignmentInput

Ƭ AssignmentInput: Omit<Assignment, "id" | "holder"> & { holder: HolderInput }

AccessExplanation

Ƭ AccessExplanation: Omit<AccessExplanation, "resource" | "principal" | "execution"> & { resource: AccessResourceRef ; principal: AccessPrincipal | null ; execution: ExecutionDescriptor | null }

InspectionRequest

Ƭ InspectionRequest: Object

Type declaration

Name	Type
`resource`	`AccessResourceRef`
`principal?`	`AccessPrincipal`
`permissions?`	readonly `string`[]
`detail?`	`"evidence"`
`excludedAssignments?`	readonly `string`[]

AccessInspector

Ƭ AccessInspector: Object

Type declaration

Name	Type
`explain`	(`request`: `InspectionRequest`) => `Promise`<`AccessExplanation`>
`simulate`	(`request`: `InspectionRequest` & { `changes`: `Record`<`string`, `Value`> }) => `Promise`<`AccessExplanation`>

AccessHolders

Ƭ AccessHolders<Resource, AssignmentId>: Object

Type parameters

Name	Type
`Resource`	extends `AccessResourceRef` = `AccessResourceRef`
`AssignmentId`	extends `GenericId`<`string`> = `GenericId`<`string`>

Type declaration

Name	Type
`resource`	`Resource`
`assignments`	`Assignment`<`AssignmentId`>[]
`directories`	{ `table`: `string` ; `role`: `RoleRef` }[]

AccessRequest

Ƭ AccessRequest: Object

Type declaration

Name	Type
`permission`	`string`
`resource`	`AccessResourceRef`

RetainedPermissionBinding

Ƭ RetainedPermissionBinding: AccessRequest & { binding: string }

UnprovenReason

Ƭ UnprovenReason: Object

Type declaration

Name	Type
`field`	`string`
`code`	`"FIELD_MAY_BE_MISSING"` \| `"BOUNDS_NOT_PROVEN"` \| `"FIELD_UNBOUNDED"` \| `"FIELD_UNPINNED"`
`mayBeMissing`	`boolean`
`message`	`string`

NativeReceiver

Ƭ NativeReceiver: { kind: "http" ; prefix: string ; methods: string[] | null } | { kind: "integration" ; integration: string ; command: string } | { kind: "dataset" ; dataset: string } | { kind: "executor" ; onward: "unrestricted" ; executor: ExecutorReceiver } Not exported: an exported type refers to it.

AccessReleaseCondition

Ƭ AccessReleaseCondition<Args>: Object Closed predicates over exact command arguments. These compile at schema analysis; no application callback makes a runtime authorization decision.

Type parameters

Name	Type
`Args`	`any`

Type declaration

Name	Type
`fields`	`Record`<`string`, `AccessClaimType`>
`condition`	`AccessCondition`<`Args`, {}, {}>

Releases

Ƭ Releases<D>: D extends { releases: infer R } ? R : {} Not exported: an exported type refers to it.

Type parameters

Name
`D`

Destinations

Ƭ Destinations<D>: D extends { destinations: infer R } ? R : {} Not exported: an exported type refers to it.

Type parameters

Name
`D`

DestinationCommand

Ƭ DestinationCommand<D, Name>: Releases<D>[Name] extends { destination: infer Target } ? Target extends keyof Destinations<D> ? Destinations<D>[Target] extends { receiver: infer C } ? C : never : never : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	`D`
`Name`	extends keyof `Releases`<`D`>

ReceiverNames

Ƭ ReceiverNames<D>: { [Name in keyof Releases<D> & string]: [DestinationCommand<D, Name>] extends [never] ? never : Name }[keyof Releases<D> & string] Not exported: an exported type refers to it.

Type parameters

Name
`D`

ReceiverInput

Ƭ ReceiverInput<D, Name>: { args: CommandArgs<DestinationCommand<D, Name>> } & DestinationCommand<D, Name> extends CommandHandle<any, "resource"> ? { target?: { bindingId: string } } : DestinationCommand<D, Name> extends CommandHandle<any, "collection"> ? { target?: CommandTarget } : { target: CommandTarget } Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	`D`
`Name`	extends `ReceiverNames`<`D`>

ReceiverRequest

Ƭ ReceiverRequest<D, Name>: { integration: IntegrationAddress ; command: string ; release: Name } & ReceiverInput<D, Name> Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	`D`
`Name`	extends `ReceiverNames`<`D`>

ExecutorReceiver

Ƭ ExecutorReceiver: { kind: "python" ; component: string | null ; function: string ; connection: string ; program: { revision: string } } | { kind: "workload" ; component: string | null ; integration: string ; sourceId: string ; definitionRevision: string ; command: string } Exact executor identity selected by native admission. A receiver admits this recipient; it never asserts technical confinement.

AccessReceiver

Ƭ AccessReceiver: CommandHandle<any> | { http: string ; methods?: readonly string[] } | { dataset: string } | { executor: ExecutorReceiver ; onward: "unrestricted" } Something leaving the deployment that a destination may send to: a binding and the operations on it.

AccessDestinationTarget

Ƭ AccessDestinationTarget: { reader: true } | { table: string } | { receiver: AccessReceiver } Where a declared destination sends protected rows.

AccessRelease

Ƭ AccessRelease: Object One transfer contract. A named destination identifies a boundary and grants no authority; each release independently declares its sources and conditions.

Type declaration

Name	Type	Description
`from`	readonly `string`[]	The resource types whose rows the destination may carry.
`destination`	`string`	-
`requires?`	`string`	The permission each source type declares and the caller (for a command, its retained requester) must hold on every source object, or on the parent or root a range is decided at. Prefer a distinct permission, such as `geocode`: reusing `read` makes every reader eligible. Omit it only for a command decided without a requester, with `when`.
`publisher?`	`string`	For dataset publication: the declared service whose live grants, ceiling and sponsorship authorize each batch. Requires a source permission and never declassifies information.
`when?`	`AccessReleaseCondition`	For an integration command receiver: decide its typed arguments (recipients, amounts) at every phase. Required when `requires` is omitted.
`accepts?`	{ `labels`: readonly `string`[] }	The only labels data sent here may carry, as label keys. A source restricted by any other label is refused, whoever could declassify it: this narrows the destination, it grants nothing. Tenant roots are not labels and are unaffected.
`accepts.labels`	readonly `string`[]	-
`declassify?`	readonly `string`[]	Restriction types this contract may remove. Omitted preserves every obligation. The caller also needs declassify on each affected object; this declaration alone grants no authority.
`transform?`	`AccessTransform`	Consent to one transformation’s output, instead of its raw sources. Requires a table or integration command destination.
`reasonRequired?`	`true`	A checkpoint, in the `reasonRequired` vocabulary of role assignments: the command declares a `reason: v.string()` argument, and every phase of the crossing is refused natively unless it states a non-empty reason. The decision’s audit line records it (`access.justified`). Integration command receivers only.

AccessTransform

Ƭ AccessTransform: Object One transformation a source owner consents to release. Native release compares the destination’s payload with the return of the retained call it cites. That call’s exact retained program, never the caller or recipient, must currently hold requires and the source’s read permission on every source, through a program grant. declassify is then decided as that program too, so the caller gains no authority over the protected input. The release’s own requires still decides who may receive the output. Every source of the crossing must have been read by that program during the cited call. A source the caller read separately refuses the route. Pinning a program establishes which code ran, not what its output reveals: the grant is the owner’s judgment of that code.

Type declaration

Name	Type	Description
`requires`	`string`	Source permission the exact retained program must currently hold.
`call`	`string`	Dotted payload path citing the native business call record.
`payload`	`string`	Dotted payload path holding the transformed output.
`result?`	`string`	Top-level return field the output equals; omit for the whole return.

ReleaseFor

Ƭ ReleaseFor<Destinations>: { [Name in keyof Destinations & string]: Omit<AccessRelease, “destination” | “when”> & Object }[keyof Destinations & string] Not exported: an exported type refers to it.

Type parameters

Name	Type
`Destinations`	extends `Record`<`string`, `AccessDestinationTarget`>

CompiledDestination

Ƭ CompiledDestination: { kind: "executor" ; executor: ExecutorReceiver ; onward: "unrestricted" } | { kind: "table" ; table: string } | { kind: "http" ; prefix: URL ; methods: Set<string> | null } | { kind: "integration" ; handle: CommandHandle<any> } | { kind: "reader" } | { kind: "dataset" ; dataset: string } Not exported: an exported type refers to it.

CompiledRelease

Ƭ CompiledRelease: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`from`	`Set`<`string`>
`to`	`CompiledDestination`
`requires?`	`string`
`publisher?`	`string`
`when?`	`CompiledReleaseCondition`
`accepts?`	`Set`<`string`>
`declassify?`	`Set`<`string`>
`reasonRequired?`	`true`
`transform?`	`AccessTransform`

Declaration

Ƭ Declaration<S>: S extends { [selectedAccess]?: infer A } ? A : never Not exported: an exported type refers to it.

Type parameters

Name
`S`

RequestClient

Ƭ RequestClient<S>: RequestAccessModel<Declaration<S>, S extends GenericSchema ? S : GenericSchema> Not exported: an exported type refers to it.

Type parameters

Name
`S`

ReaderMethod

Ƭ ReaderMethod: typeof readerMethods[number] Not exported: an exported type refers to it.

WriterMethod

Ƭ WriterMethod: typeof writerMethods[number] Not exported: an exported type refers to it.

AccessReader

Ƭ AccessReader<S>: 0 extends 1 & S ? any : Pick<RequestClient<S>, ReaderMethod> Request-bound permission decisions and authorized discovery.

Type parameters

Name	Type
`S`	`GenericSchema`

AccessWriter

Ƭ AccessWriter<S>: 0 extends 1 & S ? any : Pick<RequestClient<S>, Extract<ReaderMethod | WriterMethod | "roles", keyof RequestClient<S>>> Request-bound assignment and release lifecycle.

Type parameters

Name	Type
`S`	`GenericSchema`

AuthorityOrigin

Ƭ AuthorityOrigin: "person" | "service" | "issued" | "delegated" | "worker"

RequirementApplicability

Ƭ RequirementApplicability: Readonly<{ kind: "all" }> | Readonly<{ kind: "origins" ; origins: readonly AuthorityOrigin[] }> Not exported: an exported type refers to it.

ProgramRequirementField

Ƭ ProgramRequirementField: "implementation" | "function" | "installation" | "record"

RequirementValue

Ƭ RequirementValue: { kind: "target" } | { kind: "principal" } | { kind: "claim" ; name: string } | { kind: "program" ; field: ProgramRequirementField } | { kind: "field" ; field: string } | { kind: "contact" ; field: string ; contact: ContactKind } | { kind: "literal" ; value: EvidenceValue }

RequirementCondition

Ƭ RequirementCondition: AccessExpression<boolean> | (scope: AccessConditionScope) => AccessExpression<boolean> A permission requirement’s condition: an expression of the one condition language, built from requirement and, in a builder, the claims, principal attributes and typed fields of the requirement’s target.

PermissionAuthentication

Ƭ PermissionAuthentication: Readonly<{ maxAgeMs: number ; acrValues: readonly string[] ; requiredMethods: readonly string[] }> Exact verified OIDC evidence required from a direct actor.

PermissionRequirement

Ƭ PermissionRequirement: Readonly<{ permission: string ; on: string ; applies_to?: RequirementApplicability ; decision?: { actors: readonly ("person" | "service")[] ; direct?: boolean ; authentication?: PermissionAuthentication ; unless?: RequirementCondition } ; when?: RequirementCondition }> Not exported: an exported type refers to it.

CompiledPermissionRequirement

Ƭ CompiledPermissionRequirement: Readonly<{ permission: string ; on: string ; applies_to: RequirementApplicability ; decision?: { actors: readonly ("person" | "service")[] ; direct: boolean ; authentication?: PermissionAuthentication ; unless?: Expr } ; when: Expr }> Not exported: an exported type refers to it.

InstalledResourceSet

Ƭ InstalledResourceSet: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`arguments`	`Record`<`string`, `AccessClaimType`>
`fields`	`Record`<`string`, `AccessClaimType`>
`requiredFields`	`string`[]
`predicate`	`Expr`

TransitionOperation

Ƭ TransitionOperation: "create" | "update" | "move" | "delete"

AccessTransitionCondition

Ƭ AccessTransitionCondition<Resource, Principal, Context>: (scope: Omit<AccessConditionScope<Resource, Principal, Context>, "resource"> & { before: References<Resource> ; after: References<Resource> }) => AccessExpression<boolean>

Type parameters

Name	Type
`Resource`	`any`
`Principal`	`any`
`Context`	`any`

Type declaration

▸ (scope): AccessExpression<boolean>

Parameters

Name	Type
`scope`	`Omit`<`AccessConditionScope`<`Resource`, `Principal`, `Context`>, `"resource"`> & { `before`: `References`<`Resource`> ; `after`: `References`<`Resource`> }

Returns

AccessExpression<boolean>

TransitionConditionDeclaration

Ƭ TransitionConditionDeclaration<Resource, Principal, Context>: Object

Type parameters

Name	Type
`Resource`	`any`
`Principal`	`any`
`Context`	`any`

Type declaration

Name	Type
`on`	readonly `TransitionOperation`[]
`when`	`AccessTransitionCondition`<`Resource`, `Principal`, `Context`>

CompiledTransitionCondition

Ƭ CompiledTransitionCondition: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`on`	`TransitionOperation`[]
`expr`	`Expr`

ProgramGrantRef

Ƭ ProgramGrantRef: Readonly<{ installation: string ; callback: string ; record: string ; implementation: string }> Exact retained execution. Public locators confer no authority without a resource assignment and live native record/code custody.

AssignmentMutation

Ƭ AssignmentMutation: FunctionReference<"mutation", "internal", { assignmentId: GenericId<string> }> A product internal mutation taking an assignment’s id.

AssignmentReminder

Ƭ AssignmentReminder: Object A review reminder for a bounded assignment: notify, the product’s internal mutation, runs before milliseconds ahead of the assignment’s expiry (at once when that moment has passed) with the assignment’s id. It calls reviewDue and commits the notice.

Type declaration

Name	Type
`before`	`number`
`notify`	`AssignmentMutation`

AssignmentOptions

Ƭ AssignmentOptions: Object An optional application-owned review reminder; expiry uses the installed handler.

Type declaration

Name	Type
`remind?`	`AssignmentReminder`

TypeNames

Ƭ TypeNames<D>: "root" | Extract<keyof D["types"], string> Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`

DeclaredPermissions

Ƭ DeclaredPermissions<T>: T extends { permissions: readonly infer P[] } ? P : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

ResourceKey

Ƭ ResourceKey<D, T>: T extends "root" ? "*" : T extends keyof D["types"] ? D["types"][T] extends { table: infer Table } ? string extends Table ? string : GenericId<Table> : string : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`
`T`	extends `string`

HandlerResource

Ƭ HandlerResource<D, T>: T extends "root" ? { type: "root" } : D["types"][T] extends { table: infer Table } ? string extends Table ? { type: T ; id: string ; key?: never } | { type: T ; key: string ; id?: never } : { type: T ; id: GenericId<Table> ; key?: never } : { type: T ; key: ResourceKey<D, T> ; id?: never } Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`
`T`	extends `TypeNames`<`D`>

HandlerTarget

Ƭ HandlerTarget<D>: { [T in TypeNames<D>]: HandlerResource<D, T> }[TypeNames<D>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`

PermissionArguments

Ƭ PermissionArguments<D>: string extends AccessPermission<D> ? [permission: string, key?: string] : { [P in AccessPermission<D>]: PermissionTarget<D, P> extends “root” ? [permission: P] : [permission: P, key: ResourceKey<D, PermissionTarget<D, P>>] }[AccessPermission<D>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`

ResourceBinding

Ƭ ResourceBinding<D, S, Name>: { [Table in Extract<keyof S, string>]-?: S[Table] extends AccessTableBinding<infer R, infer B> ? R extends AccessResource<any, any, Name & string, D> ? Object & (B extends Object ? Object : Object) & (B extends Object ? Object : Object) : never : never }[Extract<keyof S, string>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessDefinitionInput`
`S`	extends `GenericSchema`
`Name`	`Name`

LoweredResources

Ƭ LoweredResources<D, S>: { roles: D["roles"] ; types: { [K in keyof D[“resources”]]: ([ResourceBinding<D, S, K>] extends [never] ? [S] extends [never] ? Object : string extends keyof S ? Object : Object : ResourceBinding<D, S, K>) & Object & (D[“resources”][K] extends Object ? Object : Object) & (D[“resources”][K] extends Object ? Object : Object) } } & D extends { groups: infer G } ? { groups: G } : {} & D extends { audit: infer A } ? { audit: A } : {} & D extends { services: infer Services } ? { services: Services } : {} & D extends { releases: infer Releases } ? { releases: Releases } : {} & D extends { destinations: infer Destinations } ? { destinations: Destinations } : {} & D extends { assignmentListings: infer Listings } ? { assignmentListings: Listings } : {} & D extends { users: infer U } ? { users: U } : {} & D extends { roleDefinitions: infer R } ? { roleDefinitions: R } : {} Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessDefinitionInput`
`S`	extends `GenericSchema` = `never`

AccessPermission

Ƭ AccessPermission<D, S>: AccessPermission<LoweredResources<D, S>> Permission names inferred from semantic resources and scoped roles.

Type parameters

Name	Type
`D`	extends `AccessDefinitionInput`
`S`	extends `GenericSchema` = `never`

AssignmentSource

Ƭ AssignmentSource<Definition>: Object Not exported: an exported type refers to it.

Type parameters

Name
`Definition`

Type declaration

Name	Type
`[assignmentSource]`	`Definition`

AccessDefinition

Ƭ AccessDefinition<D>: Omit<GenericAccessDefinition, "resource" | "role" | "person" | "service" | "delegate" | "policy" | "assignments"> & { release: <Name>(name: Name, input: ReceiverInput<D, Name>) => ReceiverRequest<D, Name> ; assignments: (…args: Parameters<GenericAccessDefinition["assignments"]>) => ReturnType<GenericAccessDefinition["assignments"]> & AssignmentSource<D> ; policy: (type: TypeNames<LoweredResources<D>>, options?: { alsoTo?: readonly string[] }) => SchemaAccessPolicy ; delegate: (client: DelegationClient, input: Omit<DelegationInput, "recipient" | "restriction"> & { recipient: { kind: "service" ; name: Extract<keyof NonNullable<D["services"]>, string> } | { kind: "user" ; userId: string } ; restriction: AccessRestriction<HandlerTarget<LoweredResources<D>>, AccessPermission<LoweredResources<D>>> }) => Promise<DelegationGrant> ; [accessDefinition]: D ; resources: { root: AccessResource<undefined, "administer", "root", D> } & { readonly [K in keyof D[“resources”]]: AccessResource<D[“resources”][K] extends Object ? P : undefined, D[“resources”][K] extends Object ? P : never, K & string, D> } } An immutable declaration with typed table-binding handles.

Type parameters

Name	Type
`D`	extends `AccessDefinitionInput` = `AccessDefinitionInput`

RequestInspection

Ƭ RequestInspection<D, S>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`
`S`	extends `GenericSchema`

Type declaration

Name	Type
`resource`	`HandlerTarget`<`D`>
`permissions?`	readonly `AccessPermission`<`D`>[]
`principal?`	`AccessPrincipal`<`PrincipalKey`<`D`, `EndpointContext`<`S`>>>

RequestAccess

Ƭ RequestAccess<D, Definition, S>: RequestOperations<D, Definition, S> & string extends keyof D["types"] ? { roles: RequestRoleWriter } : D extends { roleDefinitions: object } ? { roles: RequestRoleWriter } : {} Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `AccessModelDefinition`
`Definition`	`Definition`
`S`	extends `GenericSchema`

RequestRoleWriter

Ƭ RequestRoleWriter: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`create`	(`input`: `Omit`<`Parameters`<`AccessModel`[`"roles"`][`"create"`]>[`1`], `"scope"`> & { `scope`: `AccessResourceRef` }) => `ReturnType`<`AccessModel`[`"roles"`][`"create"`]>
`rename`	(`role`: `Parameters`<`AccessModel`[`"roles"`][`"rename"`]>[`1`], `name`: `Parameters`<`AccessModel`[`"roles"`][`"rename"`]>[`2`]) => `Promise`<`void`>
`remove`	(`role`: `Parameters`<`AccessModel`[`"roles"`][`"remove"`]>[`1`]) => `Promise`<`void`>

RequestAccessModel

Ƭ RequestAccessModel<M, S>: [EndpointDefinition<M>] extends [never] ? RequestAccess<AccessModelDefinition, AccessModelDefinition, GenericSchema> : RequestAccess<LoweredResources<EndpointDefinition<M>, S>, EndpointDefinition<M>, S> Not exported: an exported type refers to it.

Type parameters

Name	Type
`M`	`M`
`S`	extends `GenericSchema`

AccessValidators

Ƭ AccessValidators: Record<string, GenericValidator>

AccessInputValidatorJSON

Ƭ AccessInputValidatorJSON: { type: "string" | "boolean" | "bigint" } | { type: "literal" ; value: string | boolean | { $integer: string } } | { type: "array" ; value: AccessInputValidatorJSON } | { type: "union" ; value: AccessInputValidatorJSON[] } Not exported: an exported type refers to it.

AccessInputValidators

Ƭ AccessInputValidators: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`claims`	`Record`<`string`, { `validator`: `AccessInputValidatorJSON` ; `optional`: `boolean` }>
`attributes`	`Record`<`string`, { `validator`: `AccessInputValidatorJSON` ; `optional`: `boolean` }>

AccessSignatureQuestion

Ƭ AccessSignatureQuestion: Readonly<{ table: string ; record: string ; verifier: string ; usage: string }>

AccessSignatureWitness

Ƭ AccessSignatureWitness: Readonly<{ question: AccessSignatureQuestion ; signature: string }>

AdmissionGateKind

Ƭ AdmissionGateKind: "entitlement" | "capacity" | "provider" | "assurance" Independent owners contribute mandatory conditions; none grants the operation’s business permission.

AdmissionGate

Ƭ AdmissionGate<Row, Principal, Claims>: Object A gate compiles to an ordinary mandatory permission requirement. Reading an entitlement from a source therefore retains that source’s native reads, freshness and withdrawal controls.

Type parameters

Name	Type
`Row`	`any`
`Principal`	`any`
`Claims`	`any`

Type declaration

Name	Type
`kind`	`AdmissionGateKind`
`on`	readonly [`string`, …string[]]
`when`	`AccessCondition`<`Row`, `Principal`, `Claims`>
`onOrigins?`	readonly `AuthorityOrigin`[]
`decision?`	{ `actors`: readonly (`"person"` \| `"service"`)[] ; `direct?`: `boolean` ; `authentication?`: `PermissionAuthentication` }
`decision.actors`	readonly (`"person"` \| `"service"`)[]
`decision.direct?`	`boolean`
`decision.authentication?`	`PermissionAuthentication`

AllowanceReference

Ƭ AllowanceReference: Readonly<{ address: Readonly<{ module: string ; export: string }> ; unit: string }>

AllowanceDefinition

Ƭ AllowanceDefinition: Readonly<{ isAllowance: true ; [reference]: () => AllowanceReference ; exportAllowance: () => string }> A quantity with one installed address and immutable unit.

AllowanceCharge

Ƭ AllowanceCharge<Argument>: Readonly<{ allowance: AllowanceDefinition ; amount: Argument }> A charge is derived from final validated effect arguments.

Type parameters

Name	Type
`Argument`	extends `string` = `string`

AllowanceAllocation

Ƭ AllowanceAllocation: Readonly<{ allowance: AllowanceDefinition | AllowanceReference ; limit: bigint | "unbounded" }> Allocation at this level; inherited allocations continue to apply.

AllowanceObservation

Ƭ AllowanceObservation: Object

Type declaration

Name	Type
`available`	`string` \| `null`
`pools`	{ `owner`: `string` ; `limit`: `string` ; `reserved`: `string` ; `spent`: `string` ; `available`: `string` }[]

ApplicationAuthServerOptions

Ƭ ApplicationAuthServerOptions: Object Server callbacks with HttpOnly cookie custody over native session records.

Type declaration

Name	Type	Description
`deploymentUrl`	`string`	-
`clientId?`	`string`	Exact installed OAuth client ID; required when several clients exist.
`applicationOrigin`	`string`	-
`flowSecret`	`Uint8Array`	At least 32 random bytes, retained privately across server restarts.
`basePath?`	`string`	-
`fetch?`	typeof `fetch`	-

CliSignInOptions

Ƭ CliSignInOptions: Object CLI sign-in uses the provider’s public OIDC client with PKCE. Register loopback redirects with the provider. No client secret is retained.

Type declaration

Name	Type
`scopes?`	`string`[]

BrowserSignInOptions

Ƭ BrowserSignInOptions: Object Browser sign-in uses exact registered HTTPS callback URLs.

Type declaration

Name	Type
`redirectUris`	`string`[]
`scopes?`	`string`[]

ApplicationAuthConfig

Ƭ ApplicationAuthConfig: Object Ordinary provider admission with optional application-owned sign-in. Select cli, browser, or both on one OIDC provider. Other admitted providers may use the same issuer with another audience. An explicit workosAuthkit declaration adds the public AuthKit PKCE protocol to its custom JWT verifier. Other custom JWT admission retains its inherited contract.

Type declaration

Name	Type
`providers`	`AuthProvider` & { `sourceId?`: `string` ; `grantProtocol?`: `"oidc"` \| `"workosAuthkit"` ; `clientSecretCredential?`: `string` ; `nativeClientId?`: `string` ; `nativeSessions?`: { `authenticationAssurance?`: { `acrValues`: `string`[] ; `requiredMethods`: `string`[] } \| `null` ; `providerEvidence?`: { `requiredFacts`: (`"sessionActive"` \| `"accountEnabled"`)[] ; `maximumAgeMs`: `number` } \| `null` ; `accessTokenLifetimeMs`: `number` ; `absoluteLifetimeMs`: `number` ; `idleLifetimeMs`: `number` } ; `cli?`: `CliSignInOptions` ; `browser?`: `BrowserSignInOptions` ; `sessionRevocation?`: { `type`: `"workos"` ; `apiKeyCredential`: `string` } ; `providerSecurity?`: `boolean` ; `securityEvents?`: { `type`: `"workos"` ; `signingSecretCredential`: `string` } ; `caepEvents?`: { `issuer`: `string` ; `audience`: `string` ; `jwksUrl`: `string` ; `sessionIdentifier`: `"providerSid"` } ; `backChannelLogout?`: `boolean` }[]

AuthenticationIsolationCase

Ƭ AuthenticationIsolationCase: Object

Type declaration

Name	Type
`name`	`string`
`issuer`	`string`
`audiences`	readonly `string`[]

ApplicationSessionControl

Ƭ ApplicationSessionControl: Object A native authority control. The principal is the exact issuer|subject; provider-session effects intersect it with the issuer, client and sid.

Type declaration

Name	Type
`requestId`	`string`
`principal`	`string`
`reason`	`string`
`action`	{ `kind`: `"endAll"` \| `"requireReauthentication"` \| `"disable"` \| `"enable"` } \| { `kind`: `"endSession"` ; `session`: `string` } \| { `kind`: `"revokeProviderSession"` ; `issuer`: `string` ; `client`: `string` ; `session`: `string` }

ApplicationSessionControlReceipt

Ƭ ApplicationSessionControlReceipt: Object

Type declaration

Name	Type
`requestId`	`string`
`principal`	`string`
`action`	`ApplicationSessionControl`[`"action"`]
`authorityRevision`	`string`
`acceptedAt`	`number`

AuditEventDeclaration

Ƭ AuditEventDeclaration: Object

Type declaration

Name	Type
`resources`	readonly `string`[]
`metadata`	`GenericValidator`

AuditEventDefinitions

Ƭ AuditEventDefinitions: Record<string, { resources: string[] ; metadata: GenericValidator["json"] }>

AuditLogBody

Ƭ AuditLogBody: Object

Index signature

▪ [key: string]: AuditLogValue

AuditLogValue

Ƭ AuditLogValue: null | undefined | boolean | number | string | LogVar | AuditLogValue[] | { [key: string]: AuditLogValue; }

AutomationCredential

Ƭ AutomationCredential: Object

Type declaration

Name	Type
`credential`	`string`
`service`	`string`
`label`	`string`
`owner`	{ `personal`: { `issuer`: `string` ; `subject`: `string` ; `session`: `string` ; `participation`: `string` } \| `null` ; `resource`: { `type`: `string` ; `key`: `string` } ; `createdBy`: `string` ; `model`: `string` ; `modelDigest`: `string` ; `requestId`: `string` ; `restriction`: `AccessRestriction` ; `predecessor`: `string` \| `null` ; `successor`: { `credential`: `string` ; `overlapUntil`: `number` } \| `null` }
`owner.personal`	{ `issuer`: `string` ; `subject`: `string` ; `session`: `string` ; `participation`: `string` } \| `null`
`owner.resource`	{ `type`: `string` ; `key`: `string` }
`owner.resource.type`	`string`
`owner.resource.key`	`string`
`owner.createdBy`	`string`
`owner.model`	`string`
`owner.modelDigest`	`string`
`owner.requestId`	`string`
`owner.restriction`	`AccessRestriction`
`owner.predecessor`	`string` \| `null`
`owner.successor`	{ `credential`: `string` ; `overlapUntil`: `number` } \| `null`
`installedAt`	`number`
`expiresAt`	`number` \| `null`
`revokedAt`	`number` \| `null`

PolicyContract

Ƭ PolicyContract<Args, Result>: Object A package’s validator contract. It contains no application authority.

Type parameters

Name	Type
`Args`	extends `PropertyValidators` = `PropertyValidators`
`Result`	extends `GenericValidator` = `GenericValidator`

Type declaration

Name	Type
`args`	`Args`
`returns`	`Result`

ComponentAccessPolicy

Ƭ ComponentAccessPolicy<Kind>: Object Standard resource decisions derived by component schema declarations, optionally narrowed by the package to the resource kinds it installs.

Type parameters

Name	Type
`Kind`	extends `string` = `string`

Type declaration

Name	Type
`args`	typeof `componentAccessArgs`
`returns`	typeof `readAccessResults`
`componentAccess`	`true`
`resourceKinds?`	readonly `Kind`[]

AuthenticationCeremony

Ƭ AuthenticationCeremony: Object

Type declaration

Name	Type
`principal`	`string`
`session`	`string`
`issuer`	`string`
`clientId`	`string`
`configurationDigest`	`string`
`configurationRevision`	`string`
`providerOrganization`	`string` \| `null`
`providerMethod`	`string` \| `null`
`methods`	`string`[]
`authenticatedAtMs`	`number` \| `null`
`observedAtMs`	`number`

Configuration

Ƭ Configuration: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`issuer`	`string`
`clientId`	`string`
`providerOrganization`	`string`

Observation

Ƭ Observation: Infer<typeof enterpriseProviderObservation> Not exported: an exported type refers to it.

Proof

Ƭ Proof: Infer<typeof enterpriseSetupProof> Not exported: an exported type refers to it.

ReadContext

Ƭ ReadContext: BijectionQueryCtx<any, any> Not exported: an exported type refers to it.

SetupTable

Ƭ SetupTable<Table, Resource>: Table & AccessTableBinding<Resource, any> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Table`	`Table`
`Resource`	extends `AccessResource`<`any`, `any`, `any`>

Population

Ƭ Population: Infer<typeof identityCorrelationPopulation> Not exported: an exported type refers to it.

IdentityCorrelation

Ƭ IdentityCorrelation: { kind: "matched" ; person: string ; organization: string ; provider: string ; subject: string ; evidence: InspectionEvidence[] ; validUntil: number } | { kind: "conflict" ; people: string[] ; evidence: InspectionEvidence[] } | { kind: "unmatched" ; evidence: InspectionEvidence[] } | { kind: "unavailable" ; evidence: InspectionEvidence[] }

IdentityFieldAuthority

Ƭ IdentityFieldAuthority<Row, Principal, Claims>: (scope: Omit<AccessConditionScope<Row, Principal, Claims>, "resource"> & { before: References<Row> }) => AccessExpression<boolean>

Type parameters

Name	Type
`Row`	`any`
`Principal`	`any`
`Claims`	`any`

Type declaration

▸ (scope): AccessExpression<boolean> Field management is a transition obligation, independent of disclosure and ordinary edit permission. The authority builder receives only the recorded original identity; proposed identity fields cannot establish their owner.

Parameters

Name	Type
`scope`	`Omit`<`AccessConditionScope`<`Row`, `Principal`, `Claims`>, `"resource"`> & { `before`: `References`<`Row`> }

Returns

AccessExpression<boolean>

PolicySlot

Ƭ PolicySlot<Args, Result>: FunctionReference<"query", "internal", Args, Result> A component’s typed policy dependency. Each installation’s application binds it to one policy query in the component’s binding (policies). Calling it outside native policy evaluation is refused.

Type parameters

Name	Type
`Args`	extends `DefaultFunctionArgs` = `DefaultFunctionArgs`
`Result`	`any`

QueryPolicy

Ƭ QueryPolicy: Object Explicit inputs and shared query calls for a query used by a policy.

Type declaration

Name	Type
`reads`	readonly `string`[] \| () => readonly `string`[]
`calls?`	readonly `FunctionReference`<`"query"`, `"public"` \| `"internal"`>[]

PolicyExecution

Ƭ PolicyExecution: { kind: "caller" } | { kind: "program" ; program: DerivationProgramExecution } | { kind: "custody" ; component: string | null ; owner: string | null } & { scheduled: { function: string ; job: GenericId<"_scheduled_functions"> } | null } Native execution of the decision being evaluated. It confers no person or resource permission. Available only inside a rule with private inputs. A custody holder is set by native scheduling/worker admission; an ordinary caller, including an anonymous or administrator caller, cannot select it. A decision for a delegated human remains a caller decision.

LogVar

Ƭ LogVar: typeof REQUEST_ID | typeof IP | typeof USER_AGENT | typeof NOW | typeof BIJECTION_ACTOR Not exported: an exported type refers to it.

Workflow

Ƭ Workflow: { role: string ; maxDurationMs: number | null } & { kind: "participation" } | { kind: "task" ; args: GenericValidator ; perform: FunctionReference<"mutation", "internal", any, any> ; completion: FunctionReference<"query", "internal", { invitationId: string ; result: Value }, typeof type> } Not exported: an exported type refers to it.

Decision

Ƭ Decision<Result>: void | Result | Promise<void | Result> Not exported: an exported type refers to it.

Type parameters

Name
`Result`

CommandDecision

Ƭ CommandDecision: null | { validUntil: number } | { recheckAt: number } One command decision: permit (optionally until validUntil), or defer with recheckAt, which refuses now and is never permission.

CommandContract

Ƭ CommandContract<Args, Target>: Object A connector’s protocol contract for one command: its argument validators and, when the connector fixes it, its target. It carries no installed source and no application authority.

Type parameters

Name	Type
`Args`	extends `PropertyValidators` = `PropertyValidators`
`Target`	extends `Validator`<`any`, `"required"`, `any`> \| `undefined` = `Validator`<`any`, `"required"`, `any`> \| `undefined`

Type declaration

Name	Type
`args`	`Args`
`target?`	`Target`

CommandPolicyDefinition

Ƭ CommandPolicyDefinition<Contract, Target, DataModel>: { reads?: readonly Extract<keyof DataModel, string>[] ; calls?: readonly FunctionReference<"query", "public" | "internal", any, any>[] ; handler: (ctx: BijectionQueryCtx<DataModel>, input: Omit<CommandGoverningInput, "target" | "args"> & { target: Target["type"] ; args: ObjectType<Contract["args"]> }) => Decision<CommandDecision> } & Contract["target"] extends Validator<any, "required", any> ? { target?: never } : { target: Target } Application admission for one command contract. Completing normally permits, throwing refuses, and an explicit decision adds an expiry or a deferral. Omitted reads means no table reads.

Type parameters

Name	Type
`Contract`	extends `CommandContract`
`Target`	extends `Validator`<`any`, `"required"`, `any`>
`DataModel`	extends `GenericDataModel`

ReadAccessRequest

Ƭ ReadAccessRequest: Infer<typeof requests>[number] One native object or searched-domain authorization obligation.

Crossing

Ƭ Crossing: Infer<typeof crossing> One crossing out of the backend.

ResourceAuditPage

Ƭ ResourceAuditPage: Object A scoped statement retains the journal’s native outcome and attribution. Body fields are authored claims. Source bodies can be withheld independently.

Type declaration

Name	Type
`items`	{ `id`: `string` ; `revision`: `string` ; `recordedAtMs`: `number` ; `source`: `string` ; `outcome`: `"committed"` \| `"execution_failed"` \| `"authorized"` \| `"refused"` \| `"observed"` ; `observed_at_ms`: `number` ; `request_id`: `string` \| `null` ; `function`: `string` \| `null` ; `actor`: `Record`<`string`, `Value`> \| `null` ; `body`: `Value` }[]
`cursor`	`string` \| `null`
`hasMore`	`boolean`
`retentionDays`	`number`
`earliestRecordingTimeMs`	`number`
`snapshotRevision`	`string`

ResourceAuthority

Ƭ ResourceAuthority<Mode>: Object A programmable policy owner for a table inside an installed component, installed through .access. Applications declare their tables’ protection with defineAccess and .access(access.resources.<type>, ...) instead: activation refuses a programmable policy on an application (root) table. The queries decide the actual caller or finite programme under current policy; this declaration grants no component or programme authority itself.

Type parameters

Name	Type
`Mode`	extends `"read"` \| `"readWrite"` = `"read"` \| `"readWrite"`

Type declaration

Name	Type
`[authority]`	`true`
`mode`	`Mode`

Query

Ƭ Query<A>: FunctionReference<"query", "public" | "internal", A, ReadAccessResults> Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Record`<`string`, `any`>

ResourceAuthorityOptions

Ƭ ResourceAuthorityOptions: Object Private policy inputs are ordinary tables in this schema. The fixed query declarations name their callable policy dependencies separately.

Type declaration

Name	Type	Description
`read`	`Query`<`ReadAccessArgs`>	-
`destination`	`Query`<`DisclosureArgs`>	-
`export?`	`Query`<`DisclosureArgs`>	Separately authorize loss of runtime control at an external executor.
`writeReads?`	readonly `string`[] \| () => readonly `string`[]	Write policy inputs may additionally include invariant tables.
`write?`	`Query`<{ `changes`: `any`[] }>	-
`writeBasis?`	`"original"` \| `"final"`	-
`rowsFollowRange?`	`ReadAccess`[`"rowsFollowRange"`]	-
`audit?`	`boolean`	-
`appliesDelegation?`	`boolean`	-

RiskBinding

Ƭ RiskBinding: Infer<typeof riskBinding>

RiskObservation

Ƭ RiskObservation: Infer<typeof riskObservation>

RiskAssessment

Ƭ RiskAssessment: Infer<typeof assessment>

SecuritySection

Ƭ SecuritySection: Readonly<{ owner: InspectionOwner ; population: FunctionReference<"query", "internal", { principal: string ; limit: number ; cursor: string | null }, typeof type> }>

InspectionReader

Ƭ InspectionReader: Pick<BijectionQueryCtx<any, any>, "runQuery" | "auth">

InspectionWriter

Ƭ InspectionWriter: Pick<BijectionMutationCtx<any, any>, "runQuery" | "runMutation" | "auth">

InspectionOwner

Ƭ InspectionOwner<Facts>: Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<Facts>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }>

Type parameters

Name	Type
`Facts`	`any`

ApplicationSubjectInspection

Ƭ ApplicationSubjectInspection: readonly InspectionOwner[]

Variables

accessResource

• Const accessResource: typeof accessResource Not exported: an exported type refers to it.

accessBindingOwner

• Const accessBindingOwner: typeof accessBindingOwner Not exported: an exported type refers to it.

accessModelExtension

• Const accessModelExtension: Readonly<{ transactionTime: () => Promise<number> ; signatureChallenge: (question: AccessSignatureQuestion) => Promise<string> ; presentSignatureWitness: (witness: AccessSignatureWitness) => Promise<void> ; accessMetadata: (value: object) => Pick<AccessProtection, "isAccessModel" | "accessAddress" | "accessRules" | "assignmentTableName" | "initializationRole" | "requestsConfigured" | "requestActions" | "assignmentTable" | typeof attachAccess> ; defineAccessContribution: (definition: AccessContributionDefinition) => AccessContribution ; accessContribution: typeof accessContribution ; servicePrincipal: (identity: { issuer: string ; subject?: string }) => { service: string ; session: string | null } | null ; accessScope: <C>(ctx: C) => C ; accessMemo: <T>(ctx: AccessCtx, key: object, resolve: () => Promise<T>) => Promise<T> ; resolveAccessIdentity: (ctx: AccessCtx) => Promise<AccessIdentity | null> ; readIdentityAssociation: (ctx: AccessCtx, source: { table: string ; index: string }, identityKey: string) => Promise<Record<string, any> | null> ; accessProtection: (definitions: Record<string, Policy> | () => Record<string, Policy>, owner?: AccessBindingOwner, decisions?: DecisionInstallation, lifecycle?: AssignmentLifecycle) => AccessProtection ; installAccessMetadata: <T>(target: T, installation: AccessProtection) => T ; accessBindingOwner: typeof accessBindingOwner ; accessResource: typeof accessResource ; markPrincipalSource: <T, Field>(table: T, field: Field) => T & PrincipalSourceTable<Field> ; DELEGATION_CLAIMS: { recipient: "delegatedRecipient" = “delegatedRecipient”; clientLabel: "delegatedClientLabel" = “delegatedClientLabel”; support: "delegatedSupport" = “delegatedSupport”; personal: "delegatedPersonal" = “delegatedPersonal”; credentialScope: "bijectionCredentialScope" = “bijectionCredentialScope”; ancestry: "delegatedAncestry" = “delegatedAncestry”; scope: "delegatedScope" = “delegatedScope”; restriction: "delegatedRestriction" = “delegatedRestriction”; permissions: "delegatedPermissions" = “delegatedPermissions” } ; both: (…results: ReadAccessResult[]) => GoverningResult }>

conditionRequiredFields

• Const conditionRequiredFields: typeof conditionRequiredFields Not exported: an exported type refers to it.

ROOT_TYPE

• Const ROOT_TYPE: "root" The one object every tree hangs from. A type without a parent is a child of the root, so an administrator of everything is an ordinary role on an ordinary object, and a whole-table read is a scope pinned at the root.

ROOT_KEY

• Const ROOT_KEY: "*" The key of the single root object.

accessContribution

• Const accessContribution: typeof accessContribution Not exported: an exported type refers to it.

requirement

• Const requirement: Readonly<{ query: <T>(table: T) => Readonly<{ withIndex: <Name>(name: Name, range: (q: RequirementIndexRange<DocumentByInfo<Info<T>>, NamedIndex<Info<T>, Name>>) => unknown) => Readonly<{ exists: () => AccessExpression<boolean> ; filter: (predicate: AccessCondition<DocumentByInfo<Info<T>>>) => Readonly<{ exists: () => AccessExpression<boolean>; filter: (predicate: AccessCondition<DocumentByInfo<Info<T>>>) => Readonly<…>; }> }> }> = accessPropositionQuery; target: () => RequirementValue ; principal: () => Extract<RequirementValue, { kind: "principal" }> ; claim: (name: string) => Extract<RequirementValue, { kind: "claim" }> ; program: (field: ProgramRequirementField) => Extract<RequirementValue, { kind: "program" }> ; field: (field: string) => RequirementValue ; contact: (contact: ContactKind, field: string) => RequirementValue ; literal: (value: EvidenceValue) => RequirementValue ; evidence: (predicate: string, bindings: Record<string, RequirementValue>, audience: "established" | "any") => AccessExpression<boolean> ; all: (…of: AccessExpression<boolean>[]) => AccessExpression<boolean> ; any: (…of: AccessExpression<boolean>[]) => AccessExpression<boolean> ; not: (condition: AccessExpression<boolean>) => AccessExpression<boolean> }>

attachAccess

• Const attachAccess: typeof attachAccess Not exported: an exported type refers to it.

readerMethods

• Const readerMethods: ["check", "require", "requirePrincipalPermission", "capturePermission", "recheckPermission", "permissionsOn", "assignments", "holders", "reviewDue", "explain", "simulate", "requestable", "principal", "isInitialOwner"] Not exported: an exported type refers to it.

writerMethods

• Const writerMethods: ["grant", "renew", "revoke", "revokeAll"] Not exported: an exported type refers to it.

billablePopulation

• Const billablePopulation: VUnion<{ kind: "unavailable" } | { kind: "counted" ; owner: string ; revision: string ; count: number ; observedAtMs: number ; validUntilMs: number }, [VObject<{ kind: "unavailable" }, { kind: VLiteral<"unavailable", "required"> }, "required", "kind">, VObject<{ kind: "counted" ; owner: string ; revision: string ; count: number ; observedAtMs: number ; validUntilMs: number }, { kind: VLiteral<"counted", "required"> ; owner: VString<string, "required"> ; count: VFloat64<number, "required"> ; revision: VString<string, "required"> ; observedAtMs: VFloat64<number, "required"> ; validUntilMs: VFloat64<number, "required"> }, "required", "kind" | "owner" | "revision" | "count" | "observedAtMs" | "validUntilMs">], "required", "kind" | "owner" | "revision" | "count" | "observedAtMs" | "validUntilMs"> A complete native count from the application’s declared participation population. Source-backed populations must establish their native coverage and freshness in this query; unavailable input is never zero seats.

componentAccessPolicy

• Const componentAccessPolicy: ComponentAccessPolicy

discoveryAdmissionArgs

• Const discoveryAdmissionArgs: Object A metadata decision uses the caller’s ordinary query context and tracked reads. false withholds this definition; a dependency failure throws. It grants no row, property, transition, or execution permission.

Type declaration

Name	Type
`resources`	`VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>

enterpriseProviderObservation

• Const enterpriseProviderObservation: VUnion<{ kind: "connection" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; active: null | boolean ; observedAt: number ; validUntil: number ; configuration: { issuer: string; clientId: string; providerOrganization: string; } } | { kind: "certificate" ; expiresAt: null | number ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; observedAt: number ; validUntil: number ; configuration: { issuer: string; clientId: string; providerOrganization: string; } } | { kind: "directory" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; observedAt: number ; validUntil: number ; complete: boolean ; checkpoint: null | string ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; publicationRevision: null | string } | { kind: "policy" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; observedAt: number ; validUntil: number ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; ssoEnforced: null | boolean }, [VObject<{ kind: "connection" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; active: null | boolean ; observedAt: number ; validUntil: number ; configuration: { issuer: string; clientId: string; providerOrganization: string; } }, { configuration: VObject<{ issuer: string ; clientId: string ; providerOrganization: string }, { issuer: VString<string, "required"> ; clientId: VString<string, "required"> ; providerOrganization: VString<string, "required"> }, "required", "issuer" | "clientId" | "providerOrganization"> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; revision: VString<string, "required"> ; observedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> ; state: VUnion<"unavailable" | "blocked" | "ready", [VLiteral<"ready", "required">, VLiteral<"blocked", "required">, VLiteral<"unavailable", "required">], "required", never> ; kind: VLiteral<"connection", "required"> ; active: VUnion<null | boolean, [VBoolean<boolean, "required">, VNull<null, "required">], "required", never> }, "required", "kind" | "source" | "revision" | "state" | "active" | "observedAt" | "validUntil" | "configuration" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "configuration.issuer" | "configuration.clientId" | "configuration.providerOrganization">, VObject<{ kind: "certificate" ; expiresAt: null | number ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; observedAt: number ; validUntil: number ; configuration: { issuer: string; clientId: string; providerOrganization: string; } }, { configuration: VObject<{ issuer: string ; clientId: string ; providerOrganization: string }, { issuer: VString<string, "required"> ; clientId: VString<string, "required"> ; providerOrganization: VString<string, "required"> }, "required", "issuer" | "clientId" | "providerOrganization"> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; revision: VString<string, "required"> ; observedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> ; state: VUnion<"unavailable" | "blocked" | "ready", [VLiteral<"ready", "required">, VLiteral<"blocked", "required">, VLiteral<"unavailable", "required">], "required", never> ; kind: VLiteral<"certificate", "required"> ; expiresAt: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> }, "required", "kind" | "expiresAt" | "source" | "revision" | "state" | "observedAt" | "validUntil" | "configuration" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "configuration.issuer" | "configuration.clientId" | "configuration.providerOrganization">, VObject<{ kind: "directory" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; observedAt: number ; validUntil: number ; complete: boolean ; checkpoint: null | string ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; publicationRevision: null | string }, { configuration: VObject<{ issuer: string ; clientId: string ; providerOrganization: string }, { issuer: VString<string, "required"> ; clientId: VString<string, "required"> ; providerOrganization: VString<string, "required"> }, "required", "issuer" | "clientId" | "providerOrganization"> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; revision: VString<string, "required"> ; observedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> ; state: VUnion<"unavailable" | "blocked" | "ready", [VLiteral<"ready", "required">, VLiteral<"blocked", "required">, VLiteral<"unavailable", "required">], "required", never> ; kind: VLiteral<"directory", "required"> ; checkpoint: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; publicationRevision: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; complete: VBoolean<boolean, "required"> }, "required", "kind" | "source" | "revision" | "state" | "observedAt" | "validUntil" | "complete" | "checkpoint" | "configuration" | "publicationRevision" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "configuration.issuer" | "configuration.clientId" | "configuration.providerOrganization">, VObject<{ kind: "policy" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; state: "unavailable" | "blocked" | "ready" ; observedAt: number ; validUntil: number ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; ssoEnforced: null | boolean }, { configuration: VObject<{ issuer: string ; clientId: string ; providerOrganization: string }, { issuer: VString<string, "required"> ; clientId: VString<string, "required"> ; providerOrganization: VString<string, "required"> }, "required", "issuer" | "clientId" | "providerOrganization"> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; revision: VString<string, "required"> ; observedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> ; state: VUnion<"unavailable" | "blocked" | "ready", [VLiteral<"ready", "required">, VLiteral<"blocked", "required">, VLiteral<"unavailable", "required">], "required", never> ; kind: VLiteral<"policy", "required"> ; ssoEnforced: VUnion<null | boolean, [VBoolean<boolean, "required">, VNull<null, "required">], "required", never> }, "required", "kind" | "source" | "revision" | "state" | "observedAt" | "validUntil" | "configuration" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "configuration.issuer" | "configuration.clientId" | "configuration.providerOrganization" | "ssoEnforced">], "required", "kind" | "expiresAt" | "source" | "revision" | "state" | "active" | "observedAt" | "validUntil" | "complete" | "checkpoint" | "configuration" | "publicationRevision" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "configuration.issuer" | "configuration.clientId" | "configuration.providerOrganization" | "ssoEnforced"> A fixed provider owner supplies observed facts. Unknown certificate or directory state stays unavailable; configuration alone proves neither.

enterpriseSetupProof

• Const enterpriseSetupProof: VObject<{ source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }, { outcome: VUnion<"unavailable" | "blocked" | "ready", [VLiteral<"ready", "required">, VLiteral<"blocked", "required">, VLiteral<"unavailable", "required">], "required", never> ; configurationDigest: VString<string, "required"> ; definitionDigest: VString<string, "required"> ; revision: VString<string, "required"> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; validUntil: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; reason: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> }, "required", "source" | "revision" | "reason" | "validUntil" | "outcome" | "configurationDigest" | "definitionDigest" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation"> A proof owner returns current facts about this exact configuration.

identityCorrelationPopulation

• Const identityCorrelationPopulation: VObject<{ coverage: "partial" | "complete" ; records: { subject: string; organization: string; person: string; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; }; revision: string; provider: string; validUntil: number; }[] }, { coverage: VUnion<"partial" | "complete", [VLiteral<"complete", "required">, VLiteral<"partial", "required">], "required", never> ; records: VArray<{ subject: string ; organization: string ; person: string ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; provider: string ; validUntil: number }[], VObject<{ subject: string ; organization: string ; person: string ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; provider: string ; validUntil: number }, { organization: VString<string, "required"> ; provider: VString<string, "required"> ; subject: VString<string, "required"> ; person: VString<string, "required"> ; source: VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> = subjectRefValidator; revision: VString<string, "required"> ; validUntil: VFloat64<number, "required"> }, "required", "subject" | "organization" | "person" | "source" | "revision" | "provider" | "validUntil" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation">, "required"> }, "required", "coverage" | "records">

identityProjectionObservation

• Const identityProjectionObservation: VUnion<{ kind: "blocked" ; reason: "unavailable" | "unmatched" | "conflict" } | { key: string ; kind: "observed" ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; groups: Record<string, { kind: “selected”; values: Record<string, any>; } | { kind: “skipped”; reason: “unavailable” | “conflict” | “sourceNotAuthoritative”; }> ; validUntilMs: number ; identityId: string }, [VObject<{ kind: "blocked" ; reason: "unavailable" | "unmatched" | "conflict" }, { kind: VLiteral<"blocked", "required"> ; reason: VUnion<"unavailable" | "unmatched" | "conflict", [VLiteral<"unmatched", "required">, VLiteral<"conflict", "required">, VLiteral<"unavailable", "required">], "required", never> }, "required", "kind" | "reason">, VObject<{ key: string ; kind: "observed" ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; groups: Record<string, { kind: “selected”; values: Record<string, any>; } | { kind: “skipped”; reason: “unavailable” | “conflict” | “sourceNotAuthoritative”; }> ; validUntilMs: number ; identityId: string }, { kind: VLiteral<"observed", "required"> ; key: VString<string, "required"> ; identityId: VString<string, "required"> ; source: VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> = subjectRefValidator; revision: VString<string, "required"> ; validUntilMs: VFloat64<number, "required"> ; groups: VRecord<Record<string, { kind: "selected" ; values: Record<string, any> } | { kind: "skipped" ; reason: "unavailable" | "conflict" | "sourceNotAuthoritative" }>, VString<string, "required">, VUnion<{ kind: "selected" ; values: Record<string, any> } | { kind: "skipped" ; reason: "unavailable" | "conflict" | "sourceNotAuthoritative" }, [VObject<{ kind: "selected" ; values: Record<string, any> }, { kind: VLiteral<"selected", "required"> ; values: VRecord<Record<string, any>, VString<string, "required">, VAny<any, "required", string>, "required", string> }, "required", "kind" | "values" | `values.

\{string}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"skipped"`` ; `reason`: ``"unavailable"`` \| ``"conflict"`` \| ``"sourceNotAuthoritative"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"skipped"``, ``"required"``\> ; `reason`: [`VUnion`](/api/classes/values.VUnion)\<``"unavailable"`` \| ``"conflict"`` \| ``"sourceNotAuthoritative"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"sourceNotAuthoritative"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"conflict"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"unavailable"``, ``"required"``\>], ``"required"``, `never`\> = skippedReason \}, ``"required"``, ``"kind"`` \| ``"reason"``\>], ``"required"``, ``"kind"`` \| ``"values"`` \| ``"reason"`` \| \`values.

{string}`>, "required", string> }, "required", "key" | "kind" | "source" | "revision" | "groups" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "validUntilMs" | "identityId" | `groups.

\{string}\`\>], ``"required"``, ``"key"`` \| ``"kind"`` \| ``"source"`` \| ``"revision"`` \| ``"reason"`` \| ``"groups"`` \| ``"source.id"`` \| ``"source.installation"`` \| ``"source.location"`` \| ``"source.protocol"`` \| ``"source.location.incarnation"`` \| ``"source.location.branch"`` \| ``"source.location.deployment_id"`` \| ``"source.location.branch.key"`` \| ``"source.location.branch.generation"`` \| ``"validUntilMs"`` \| ``"identityId"`` \| \`groups.

{string}`> Returned by an installed internal query over current source evidence and a reviewed immutable-identity association. No public endpoint accepts it. Native field transitions and ordinary target permissions remain required.

identityProjectionResult

• Const identityProjectionResult: VUnion<{ kind: "blocked" ; reason: "unavailable" | "unmatched" | "conflict" } | { kind: "projected" ; requestId: string ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; sourceRevision: string ; groups: { name: string; reason: “unavailable” | “accepted” | “conflict” | “sourceNotAuthoritative” | “sameValue”; outcome: “unchanged” | “skipped” | “applied”; }[] ; recordedAtMs: number ; identityId: string ; projectionDigest: string ; beforeDigest: string ; afterDigest: string }, [VObject<{ kind: "blocked" ; reason: "unavailable" | "unmatched" | "conflict" }, { kind: VLiteral<"blocked", "required"> ; reason: VUnion<"unavailable" | "unmatched" | "conflict", [VLiteral<"unmatched", "required">, VLiteral<"conflict", "required">, VLiteral<"unavailable", "required">], "required", never> }, "required", "kind" | "reason">, VObject<{ kind: "projected" ; requestId: string ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; sourceRevision: string ; groups: { name: string; reason: “unavailable” | “accepted” | “conflict” | “sourceNotAuthoritative” | “sameValue”; outcome: “unchanged” | “skipped” | “applied”; }[] ; recordedAtMs: number ; identityId: string ; projectionDigest: string ; beforeDigest: string ; afterDigest: string }, { kind: VLiteral<"projected", "required"> ; requestId: VString<string, "required"> ; projectionDigest: VString<string, "required"> ; source: VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> = subjectRefValidator; sourceRevision: VString<string, "required"> ; identityId: VString<string, "required"> ; beforeDigest: VString<string, "required"> ; afterDigest: VString<string, "required"> ; groups: VArray<{ name: string ; reason: "unavailable" | "accepted" | "conflict" | "sourceNotAuthoritative" | "sameValue" ; outcome: "unchanged" | "skipped" | "applied" }[], VObject<{ name: string ; reason: "unavailable" | "accepted" | "conflict" | "sourceNotAuthoritative" | "sameValue" ; outcome: "unchanged" | "skipped" | "applied" }, { name: VString<string, "required"> ; outcome: VUnion<"unchanged" | "skipped" | "applied", [VLiteral<"applied", "required">, VLiteral<"unchanged", "required">, VLiteral<"skipped", "required">], "required", never> ; reason: VUnion<"unavailable" | "accepted" | "conflict" | "sourceNotAuthoritative" | "sameValue", [VLiteral<"accepted", "required">, VLiteral<"sameValue", "required">, VUnion<"unavailable" | "conflict" | "sourceNotAuthoritative", [VLiteral<"sourceNotAuthoritative", "required">, VLiteral<"conflict", "required">, VLiteral<"unavailable", "required">], "required", never>], "required", never> }, "required", "name" | "reason" | "outcome">, "required"> ; recordedAtMs: VFloat64<number, "required"> }, "required", "kind" | "requestId" | "source" | "sourceRevision" | "groups" | "recordedAtMs" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "identityId" | "projectionDigest" | "beforeDigest" | "afterDigest">], "required", "kind" | "requestId" | "source" | "reason" | "sourceRevision" | "groups" | "recordedAtMs" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "identityId" | "projectionDigest" | "beforeDigest" | "afterDigest">

onboardingReceipt

• Const onboardingReceipt: VObject<{ revision: bigint ; state: "revoked" | "completed" | "accepted" | "claimed" | "invited" ; participation: null | string ; invitationId: string }, { invitationId: VString<string, "required"> ; revision: VInt64<bigint, "required"> ; state: VUnion<"revoked" | "completed" | "accepted" | "claimed" | "invited", [VLiteral<"invited", "required">, VLiteral<"claimed", "required">, VLiteral<"accepted", "required">, VLiteral<"completed", "required">, VLiteral<"revoked", "required">], "required", never> ; participation: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> }, "required", "revision" | "state" | "participation" | "invitationId">

onboardingCompletion

• Const onboardingCompletion: VUnion<{ kind: "pending" } | { kind: "complete" ; receipt: string }, [VObject<{ kind: "pending" }, { kind: VLiteral<"pending", "required"> }, "required", "kind">, VObject<{ kind: "complete" ; receipt: string }, { kind: VLiteral<"complete", "required"> ; receipt: VString<string, "required"> }, "required", "kind" | "receipt">], "required", "kind" | "receipt">

PERSON_DECISION_REQUIRED

• Const PERSON_DECISION_REQUIRED: "Only a person signed in directly can make this decision" The refusal every surface gives a non-person at a person’s decision.

readAccessArgs

• Const readAccessArgs: Object Arguments for an ordinary query used by .access({ read, reads }). The native reader constructs the complete batch. Calling the query directly does not grant private policy-input access or authorize another database read. properties: null requires the whole document. Otherwise properties include selected fields and fields contributing to membership, filtering and order, including _id and _creationTime. Nested paths require their whole top-level property. Query equalities are guaranteed index bounds, not guessed filters. An omitted equality value denotes absence; null remains an explicit value. A query target with covers: true stands for rows the engine does not present as requests of their own: a maintained total, a count, a table change token, a whole relation’s status, a range folded past the read evidence bound (rowsFollowRange) or a retained obligation kept in place of per-row requests. Its result decides every row it covers. Without the key, any row the read returned arrives as a request of its own.

Type declaration

Name	Type
`requests`	`VArray`<{ `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; interval?: { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; }; kind: “query”; equalities: { …; }[]; } ; `table`: `string` }[], `VObject`<{ `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; interval?: { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; }; kind: “query”; equalities: { …; }[]; } ; `table`: `string` }, { `table`: `VString`<`string`, `"required"`> ; `properties`: `VUnion`<`null` \| `string`[], [`VNull`<`null`, `"required"`>, `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>], `"required"`, `never`> ; `target`: `VUnion`<{ `kind`: `"object"` ; `id`: `string` } \| { `covers`: `undefined` \| `true` ; `interval`: `undefined` \| { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; } ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, [`VObject`<{ `kind`: `"object"` ; `id`: `string` }, { `kind`: `VLiteral`<`"object"`, `"required"`> ; `id`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"id"`>, `VObject`<{ `covers`: `undefined` \| `true` ; `interval`: `undefined` \| { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; } ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, { `kind`: `VLiteral`<`"query"`, `"required"`> ; `equalities`: `VArray`<{ `value`: `undefined` \| `Value` ; `field`: `string` }[], `VObject`<{ `value`: `undefined` \| `Value` ; `field`: `string` }, { `field`: `VString`<`string`, `"required"`> ; `value`: `VAny`<`undefined` \| `Value`, `"optional"`, `string`> }, `"required"`, `"value"` \| `"field"` \| `value. $\{string}\`\>, ``"required"``\> ; `covers`: [`VLiteral`](/api/classes/values.VLiteral)\<`undefined` \\| ``true``, ``"optional"``\> ; `interval`: [`VObject`](/api/classes/values.VObject)\<`undefined` \\| \{ `field`: ``null`` \\| `string` ; `index`: `string` ; `lower`: ``null`` \\| \{ value?: Value; inclusive: boolean; \} ; `upper`: ``null`` \\| \{ value?: Value; inclusive: boolean; \} \}, \{ `index`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `field`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \\| `string`, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>], ``"required"``, `never`\> ; `lower`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \\| \{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, \{ `value`: [`VAny`](/api/classes/values.VAny)\<`undefined` \\| [`Value`](/api/modules/values#value), ``"optional"``, `string`\> ; `inclusive`: [`VBoolean`](/api/classes/values.VBoolean)\<`boolean`, ``"required"``\> \}, ``"required"``, ``"value"`` \\| \`value.$ {string}` \| `"inclusive"`>], `"required"`, `"value"` \| `value. $\{string}\` \\| ``"inclusive"``\> ; `upper`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \\| \{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, \{ `value`: [`VAny`](/api/classes/values.VAny)\<`undefined` \\| [`Value`](/api/modules/values#value), ``"optional"``, `string`\> ; `inclusive`: [`VBoolean`](/api/classes/values.VBoolean)\<`boolean`, ``"required"``\> \}, ``"required"``, ``"value"`` \\| \`value.$ {string}` \| `"inclusive"`>], `"required"`, `"value"` \| `value. $\{string}\` \\| ``"inclusive"``\> \}, ``"optional"``, ``"field"`` \\| ``"index"`` \\| ``"lower"`` \\| ``"upper"`` \\| ``"lower.value"`` \\| \`lower.value.$ {string}` \| `"lower.inclusive"` \| `"upper.value"` \| `upper.value. $\{string}\` \\| ``"upper.inclusive"``\> \}, ``"required"``, ``"kind"`` \\| ``"covers"`` \\| ``"interval"`` \\| ``"equalities"`` \\| ``"interval.field"`` \\| ``"interval.index"`` \\| ``"interval.lower"`` \\| ``"interval.upper"`` \\| ``"interval.lower.value"`` \\| \`interval.lower.value.$ {string}` \| `"interval.lower.inclusive"` \| `"interval.upper.value"` \| `interval.upper.value. $\{string}\` \\| ``"interval.upper.inclusive"``\>], ``"required"``, ``"kind"`` \\| ``"id"`` \\| ``"covers"`` \\| ``"interval"`` \\| ``"equalities"`` \\| ``"interval.field"`` \\| ``"interval.index"`` \\| ``"interval.lower"`` \\| ``"interval.upper"`` \\| ``"interval.lower.value"`` \\| \`interval.lower.value.$ {string}` \| `"interval.lower.inclusive"` \| `"interval.upper.value"` \| `interval.upper.value. $\{string}\` \\| ``"interval.upper.inclusive"``\> \}, ``"required"``, ``"properties"`` \\| ``"target"`` \\| ``"table"`` \\| ``"target.kind"`` \\| ``"target.id"`` \\| ``"target.covers"`` \\| ``"target.interval"`` \\| ``"target.equalities"`` \\| ``"target.interval.field"`` \\| ``"target.interval.index"`` \\| ``"target.interval.lower"`` \\| ``"target.interval.upper"`` \\| ``"target.interval.lower.value"`` \\| \`target.interval.lower.value.$ {string}` \| `"target.interval.lower.inclusive"` \| `"target.interval.upper.value"` \| `target.interval.upper.value.${string}` \| `"target.interval.upper.inclusive"`>, `"required"`>

readAccessResults

• Const readAccessResults: VArray<(null | { reason: undefined | string ; validUntil: number } | { reason: string })[], VUnion<null | { reason: undefined | string ; validUntil: number } | { reason: string }, [VNull<null, "required">, VObject<{ reason: undefined | string ; validUntil: number }, { validUntil: VFloat64<number, "required"> ; reason: VString<undefined | string, "optional"> }, "required", "reason" | "validUntil">, VObject<{ reason: string }, { reason: VString<string, "required"> }, "required", "reason">], "required", "reason" | "validUntil">, "required"> The return validator of every rule: read, destination, a table’s write rule (.govern) and an integration command’s rule. A command rule gives no reason; one that defers with recheckAt declares that member beside null and { validUntil }.

crossing

• Const crossing: VUnion<{ kind: "rows" ; fields: string[] ; from: string ; to: { site: “compute”; } | { target: string; source: string; site: “source”; } | { dataset: string; site: “catalog”; catalog: string; } } | { kind: "state" ; fields: string[] ; from: string ; to: { site: “compute”; } } | { kind: "keys" ; fields: string[] ; from: string ; to: { target: string; source: string; site: “source”; } } | { kind: "range" ; fields: string[] ; from: string ; to: { target: string; source: string; site: “source”; } } | { kind: "values" ; fields: string[] ; from: null | string ; to: { target: string; source: string; site: “source”; } }, [VObject<{ kind: "rows" ; fields: string[] ; from: string ; to: { site: “compute”; } | { target: string; source: string; site: “source”; } | { dataset: string; site: “catalog”; catalog: string; } }, { kind: VLiteral<"rows", "required"> ; from: VString<string, "required"> ; to: VUnion<{ site: "compute" } | { target: string ; source: string ; site: "source" } | { dataset: string ; site: "catalog" ; catalog: string }, [VObject<{ site: "compute" }, { site: VLiteral<"compute", "required"> }, "required", "site">, VObject<{ target: string ; source: string ; site: "source" }, { site: VLiteral<"source", "required"> ; source: VString<string, "required"> ; target: VString<string, "required"> }, "required", "target" | "source" | "site">, VObject<{ dataset: string ; site: "catalog" ; catalog: string }, { site: VLiteral<"catalog", "required"> ; catalog: VString<string, "required"> ; dataset: VString<string, "required"> }, "required", "dataset" | "site" | "catalog">], "required", "target" | "dataset" | "source" | "site" | "catalog"> ; fields: VArray<string[], VString<string, "required">, "required"> }, "required", "kind" | "fields" | "from" | "to" | "to.target" | "to.dataset" | "to.source" | "to.site" | "to.catalog">, VObject<{ kind: "state" ; fields: string[] ; from: string ; to: { site: “compute”; } }, { kind: VLiteral<"state", "required"> ; from: VString<string, "required"> ; to: VObject<{ site: "compute" }, { site: VLiteral<"compute", "required"> }, "required", "site"> = computeSite; fields: VArray<string[], VString<string, "required">, "required"> }, "required", "kind" | "fields" | "from" | "to" | "to.site">, VObject<{ kind: "keys" ; fields: string[] ; from: string ; to: { target: string; source: string; site: “source”; } }, { kind: VLiteral<"keys", "required"> ; from: VString<string, "required"> ; to: VObject<{ target: string ; source: string ; site: "source" }, { site: VLiteral<"source", "required"> ; source: VString<string, "required"> ; target: VString<string, "required"> }, "required", "target" | "source" | "site"> = sourceSite; fields: VArray<string[], VString<string, "required">, "required"> }, "required", "kind" | "fields" | "from" | "to" | "to.target" | "to.source" | "to.site">, VObject<{ kind: "range" ; fields: string[] ; from: string ; to: { target: string; source: string; site: “source”; } }, { kind: VLiteral<"range", "required"> ; from: VString<string, "required"> ; to: VObject<{ target: string ; source: string ; site: "source" }, { site: VLiteral<"source", "required"> ; source: VString<string, "required"> ; target: VString<string, "required"> }, "required", "target" | "source" | "site"> = sourceSite; fields: VArray<string[], VString<string, "required">, "required"> }, "required", "kind" | "fields" | "from" | "to" | "to.target" | "to.source" | "to.site">, VObject<{ kind: "values" ; fields: string[] ; from: null | string ; to: { target: string; source: string; site: “source”; } }, { kind: VLiteral<"values", "required"> ; from: VUnion<null | string, [VNull<null, "required">, VString<string, "required">], "required", never> ; to: VObject<{ target: string ; source: string ; site: "source" }, { site: VLiteral<"source", "required"> ; source: VString<string, "required"> ; target: VString<string, "required"> }, "required", "target" | "source" | "site"> = sourceSite; fields: VArray<string[], VString<string, "required">, "required"> }, "required", "kind" | "fields" | "from" | "to" | "to.target" | "to.source" | "to.site">], "required", "kind" | "fields" | "from" | "to" | "to.target" | "to.dataset" | "to.source" | "to.site" | "to.catalog"> What one step moves out of the backend, and where. Every place a table’s data is computed or stored outside the backend is a crossing: an installed executor or query compute, a customer catalog. fields name fields, never values. A site may retain what it receives: a crossing is disclosure, not a claim that the site erases it, and a revocation stops later crossings without recalling earlier ones. Two timings decide it:

standing, for background work with no caller (a dataset publication to its catalog): rows decided with no identity (ctx.auth.getUserIdentity() returns null) for one request covering every row (target.covers), before every send;
per call (a query step): decided for the protected rows the calling function has read, under its caller, before the call leaves.
rows: the named fields of from disclosed to the installed executor, or to bounded local dataset browsing. The destination is explicit.
state: aggregate states computed at the source from from’s rows, into compute. Admitted rows imply it.
keys: the exact set of from’s join keys, sent to another source to prune its scan.
range: only the least and greatest of those keys. Admitted keys imply it; a join filter refused keys and admitted range sends the range.
values: a bounded local relation from uploaded as parameters, or with from: null query literals (possibly derived from earlier protected reads), whose compared source fields are named table.field.

Complete queries authorize their input rows to one installed executor. Legacy state/key/range kinds never authorize that row disclosure. A refusal stops execution and never selects another placement.

disclosureArgs

• Const disclosureArgs: Object Arguments for the source’s .access({ destination, export }) queries. The host supplies actual information dependencies and the exact fixed destination. A table release gives the resulting record its destination table’s policy; it does not grant future reads of the source or retract previously released bytes when a source grant is later revoked.

Type declaration

Name	Type
`requests`	`VArray`<{ `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; interval?: { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; }; kind: “query”; equalities: { …; }[]; } ; `table`: `string` }[], `VObject`<{ `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; interval?: { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; }; kind: “query”; equalities: { …; }[]; } ; `table`: `string` }, { `table`: `VString`<`string`, `"required"`> ; `properties`: `VUnion`<`null` \| `string`[], [`VNull`<`null`, `"required"`>, `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>], `"required"`, `never`> ; `target`: `VUnion`<{ `kind`: `"object"` ; `id`: `string` } \| { `covers`: `undefined` \| `true` ; `interval`: `undefined` \| { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; } ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, [`VObject`<{ `kind`: `"object"` ; `id`: `string` }, { `kind`: `VLiteral`<`"object"`, `"required"`> ; `id`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"id"`>, `VObject`<{ `covers`: `undefined` \| `true` ; `interval`: `undefined` \| { field: string \| null; index: string; lower: { value?: Value; inclusive: boolean; } \| null; upper: { value?: Value; inclusive: boolean; } \| null; } ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, { `kind`: `VLiteral`<`"query"`, `"required"`> ; `equalities`: `VArray`<{ `value`: `undefined` \| `Value` ; `field`: `string` }[], `VObject`<{ `value`: `undefined` \| `Value` ; `field`: `string` }, { `field`: `VString`<`string`, `"required"`> ; `value`: `VAny`<`undefined` \| `Value`, `"optional"`, `string`> }, `"required"`, `"value"` \| `"field"` \| `value. $\{string}\`\>, ``"required"``\> ; `covers`: [`VLiteral`](/api/classes/values.VLiteral)\<`undefined` \\| ``true``, ``"optional"``\> ; `interval`: [`VObject`](/api/classes/values.VObject)\<`undefined` \\| \{ `field`: ``null`` \\| `string` ; `index`: `string` ; `lower`: ``null`` \\| \{ value?: Value; inclusive: boolean; \} ; `upper`: ``null`` \\| \{ value?: Value; inclusive: boolean; \} \}, \{ `index`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `field`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \\| `string`, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>], ``"required"``, `never`\> ; `lower`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \\| \{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, \{ `value`: [`VAny`](/api/classes/values.VAny)\<`undefined` \\| [`Value`](/api/modules/values#value), ``"optional"``, `string`\> ; `inclusive`: [`VBoolean`](/api/classes/values.VBoolean)\<`boolean`, ``"required"``\> \}, ``"required"``, ``"value"`` \\| \`value.$ {string}` \| `"inclusive"`>], `"required"`, `"value"` \| `value. $\{string}\` \\| ``"inclusive"``\> ; `upper`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \\| \{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `value`: `undefined` \\| [`Value`](/api/modules/values#value) ; `inclusive`: `boolean` \}, \{ `value`: [`VAny`](/api/classes/values.VAny)\<`undefined` \\| [`Value`](/api/modules/values#value), ``"optional"``, `string`\> ; `inclusive`: [`VBoolean`](/api/classes/values.VBoolean)\<`boolean`, ``"required"``\> \}, ``"required"``, ``"value"`` \\| \`value.$ {string}` \| `"inclusive"`>], `"required"`, `"value"` \| `value. $\{string}\` \\| ``"inclusive"``\> \}, ``"optional"``, ``"field"`` \\| ``"index"`` \\| ``"lower"`` \\| ``"upper"`` \\| ``"lower.value"`` \\| \`lower.value.$ {string}` \| `"lower.inclusive"` \| `"upper.value"` \| `upper.value. $\{string}\` \\| ``"upper.inclusive"``\> \}, ``"required"``, ``"kind"`` \\| ``"covers"`` \\| ``"interval"`` \\| ``"equalities"`` \\| ``"interval.field"`` \\| ``"interval.index"`` \\| ``"interval.lower"`` \\| ``"interval.upper"`` \\| ``"interval.lower.value"`` \\| \`interval.lower.value.$ {string}` \| `"interval.lower.inclusive"` \| `"interval.upper.value"` \| `interval.upper.value. $\{string}\` \\| ``"interval.upper.inclusive"``\>], ``"required"``, ``"kind"`` \\| ``"id"`` \\| ``"covers"`` \\| ``"interval"`` \\| ``"equalities"`` \\| ``"interval.field"`` \\| ``"interval.index"`` \\| ``"interval.lower"`` \\| ``"interval.upper"`` \\| ``"interval.lower.value"`` \\| \`interval.lower.value.$ {string}` \| `"interval.lower.inclusive"` \| `"interval.upper.value"` \| `interval.upper.value. $\{string}\` \\| ``"interval.upper.inclusive"``\> \}, ``"required"``, ``"properties"`` \\| ``"target"`` \\| ``"table"`` \\| ``"target.kind"`` \\| ``"target.id"`` \\| ``"target.covers"`` \\| ``"target.interval"`` \\| ``"target.equalities"`` \\| ``"target.interval.field"`` \\| ``"target.interval.index"`` \\| ``"target.interval.lower"`` \\| ``"target.interval.upper"`` \\| ``"target.interval.lower.value"`` \\| \`target.interval.lower.value.$ {string}` \| `"target.interval.lower.inclusive"` \| `"target.interval.upper.value"` \| `target.interval.upper.value.${string}` \| `"target.interval.upper.inclusive"`>, `"required"`>
`destination`	`VUnion`<{ `kind`: `"executor"` ; `executor`: { function: string; kind: “python”; component: string \| null; program: { revision: string; }; endpoint: string; connection: string; } \| { kind: “workload”; sourceId: string; component: string \| null; integration: string; command: string; binding: string; definitionRevision: string; credentialDigest: string; authorityDigest: string; } ; `onward`: `"unrestricted"` } \| { `kind`: `"crossing"` ; `component`: `null` \| `string` ; `crossing`: { kind: “rows”; fields: string[]; from: string; to: { site: “compute”; } \| { target: string; source: string; site: “source”; } \| { dataset: string; site: “catalog”; catalog: string; }; } \| { kind: “state”; fields: string[]; from: string; to: { site: “compute”; }; } \| { kind: “keys”; fields: string[]; from: string; to: { target: string; source: string; site: “source”; }; } \| { kind: “range”; fields: string[]; from: string; to: { target: string; source: string; site: “source”; }; } \| { kind: “values”; fields: string[]; from: string \| null; to: { target: string; source: string; site: “source”; }; } } \| { `kind`: `"virtualTableRetention"` ; `component`: `null` \| `string` ; `expiresAt`: `string` ; `tables`: `string`[] } \| { `kind`: `"sourceControl"` ; `component`: `null` \| `string` ; `target`: `string` ; `integration`: `string` ; `control`: `"check"` \| `"refresh"` } \| { `kind`: `"seriesSource"` ; `component`: `null` \| `string` ; `table`: `string` ; `source`: `string` ; `retired`: `boolean` } \| { `kind`: `"seriesMaintenance"` ; `component`: `null` \| `string` ; `series`: `string` ; `table`: `string` ; `hour`: `bigint` } \| { `kind`: `"seriesErase"` ; `component`: `null` \| `string` ; `target`: { kind: “series”; series: string; } \| { kind: “source”; series: string; source: string; } \| { generation?: number; kind: “event”; series: string; source: string; event: string; } \| { kind: “range”; series: string; from: bigint; to: bigint; } ; `table`: `string` } \| { `kind`: `"publication"` ; `component`: `null` \| `string` ; `table`: `string` ; `group`: `string` ; `selection`: `string` ; `producer`: `string` ; `run`: `string` } \| { `work`: `undefined` \| { component: string; worker: string; installation: string; effect: string \| null; } ; `kind`: `"table"` ; `component`: `null` \| `string` ; `table`: `string` ; `changes`: { id: string; before: any; after: any; }[] } \| { `kind`: `"http"` ; `method`: `string` ; `url`: `string` } \| { `release`: `undefined` \| `string` ; `work`: `undefined` \| { component: string; worker: string; installation: string; effect: string \| null; } ; `kind`: `"command"` ; `component`: `null` \| `string` ; `args`: `any` ; `target`: `string` \| { sourceId: string; } ; `integration`: `string` ; `command`: `string` ; `contract`: `string` ; `phase`: `"send"` \| `"cancel"` \| `"reconcile"` \| `"acceptance"` } \| { `kind`: `"storageShare"` ; `size`: `number` ; `expiresAt`: `number` ; `sha256`: `string` ; `recipient`: `string` ; `storageId`: `string` ; `shareId`: `string` } \| { `kind`: `"storageErase"` ; `size`: `number` ; `storageId`: `string` } \| { `kind`: `"storageRecordErase"` ; `record`: `string` } \| { `kind`: `"recordErase"` ; `record`: `string` } \| { `kind`: `"storageRevoke"` ; `recipient`: `string` ; `storageId`: `string` ; `shareId`: `string` } \| { `work`: `undefined` \| { component: string; worker: string; installation: string; effect: string \| null; } ; `kind`: `"custody"` ; `component`: `null` \| `string` }, [`VObject`<{ `kind`: `"executor"` ; `executor`: { function: string; kind: “python”; component: string \| null; program: { revision: string; }; endpoint: string; connection: string; } \| { kind: “workload”; sourceId: string; component: string \| null; integration: string; command: string; binding: string; definitionRevision: string; credentialDigest: string; authorityDigest: string; } ; `onward`: `"unrestricted"` }, { `kind`: `VLiteral`<`"executor"`, `"required"`> ; `onward`: `VLiteral`<`"unrestricted"`, `"required"`> ; `executor`: `VUnion`<{ `function`: `string` ; `kind`: `"python"` ; `component`: `null` \| `string` ; `program`: { revision: string; } ; `endpoint`: `string` ; `connection`: `string` } \| { `kind`: `"workload"` ; `sourceId`: `string` ; `component`: `null` \| `string` ; `integration`: `string` ; `command`: `string` ; `binding`: `string` ; `definitionRevision`: `string` ; `credentialDigest`: `string` ; `authorityDigest`: `string` }, [`VObject`<{ `function`: `string` ; `kind`: `"python"` ; `component`: `null` \| `string` ; `program`: { revision: string; } ; `endpoint`: `string` ; `connection`: `string` }, { `kind`: `VLiteral`<`"python"`, `"required"`> ; `component`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `function`: `VString`<`string`, `"required"`> ; `connection`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `program`: `VObject`<{ `revision`: `string` }, { `revision`: `VString`<`string`, `"required"`> }, `"required"`, `"revision"`> }, `"required"`, `"function"` \| `"kind"` \| `"component"` \| `"program"` \| `"endpoint"` \| `"connection"` \| `"program.revision"`>, `VObject`<{ `kind`: `"workload"` ; `sourceId`: `string` ; `component`: `null` \| `string` ; `integration`: `string` ; `command`: `string` ; `binding`: `string` ; `definitionRevision`: `string` ; `credentialDigest`: `string` ; `authorityDigest`: `string` }, { `kind`: `VLiteral`<`"workload"`, `"required"`> ; `component`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `integration`: `VString`<`string`, `"required"`> ; `sourceId`: `VString`<`string`, `"required"`> ; `definitionRevision`: `VString`<`string`, `"required"`> ; `command`: `VString`<`string`, `"required"`> ; `binding`: `VString`<`string`, `"required"`> ; `credentialDigest`: `VString`<`string`, `"required"`> ; `authorityDigest`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"sourceId"` \| `"component"` \| `"integration"` \| `"command"` \| `"binding"` \| `"definitionRevision"` \| `"credentialDigest"` \| `"authorityDigest"`>], `"required"`, `"function"` \| `"kind"` \| `"sourceId"` \| `"component"` \| `"program"` \| `"integration"` \| `"command"` \| `"endpoint"` \| `"binding"` \| `"connection"` \| `"program.revision"` \| `"definitionRevision"` \| `"credentialDigest"` \| `"authorityDigest"`> }, `"required"`, `"kind"` \| `"executor"` \| `"onward"` \| `"executor.function"` \| `"executor.kind"` \| `"executor.sourceId"` \| `"executor.component"` \| `"executor.program"` \| `"executor.integration"` \| `"executor.command"` \| `"executor.endpoint"` \| `"executor.binding"` \| `"executor.connection"` \| `"executor.program.revision"` \| `"executor.definitionRevision"` \| `"executor.credentialDigest"` \| `"executor.authorityDigest"`>, `VObject`<{ `kind`: `"crossing"` ; `component`: `null` \| `string` ; `crossing`: { kind: “rows”; fields: string[]; from: string; to: { site: “compute”; } \| { target: string; source: string; site: “source”; } \| { dataset: string; site: “catalog”; catalog: string; }; } \| { kind: “state”; fields: string[]; from: string; to: { site: “compute”; }; } \| { kind: “keys”; fields: string[]; from: string; to: { target: string; source: string; site: “source”; }; } \| { kind: “range”; fields: string[]; from: string; to: { target: string; source: string; site: “source”; }; } \| { kind: “values”; fields: string[]; from: string \| null; to: { target: string; source: string; site: “source”; }; } }, { `kind`: `VLiteral`<`"crossing"`, `"required"`> ; `component`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `crossing`: `VUnion`<{ `kind`: `"rows"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { site: “compute”; } \| { target: string; source: string; site: “source”; } \| { dataset: string; site: “catalog”; catalog: string; } } \| { `kind`: `"state"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { site: “compute”; } } \| { `kind`: `"keys"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { target: string; source: string; site: “source”; } } \| { `kind`: `"range"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { target: string; source: string; site: “source”; } } \| { `kind`: `"values"` ; `fields`: `string`[] ; `from`: `null` \| `string` ; `to`: { target: string; source: string; site: “source”; } }, [`VObject`<{ `kind`: `"rows"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { site: “compute”; } \| { target: string; source: string; site: “source”; } \| { dataset: string; site: “catalog”; catalog: string; } }, { `kind`: `VLiteral`<`"rows"`, `"required"`> ; `from`: `VString`<`string`, `"required"`> ; `to`: `VUnion`<{ `site`: `"compute"` } \| { `target`: `string` ; `source`: `string` ; `site`: `"source"` } \| { `dataset`: `string` ; `site`: `"catalog"` ; `catalog`: `string` }, [`VObject`<{ `site`: `"compute"` }, { `site`: `VLiteral`<`"compute"`, `"required"`> }, `"required"`, `"site"`>, `VObject`<{ `target`: `string` ; `source`: `string` ; `site`: `"source"` }, { `site`: `VLiteral`<`"source"`, `"required"`> ; `source`: `VString`<`string`, `"required"`> ; `target`: `VString`<`string`, `"required"`> }, `"required"`, `"target"` \| `"source"` \| `"site"`>, `VObject`<{ `dataset`: `string` ; `site`: `"catalog"` ; `catalog`: `string` }, { `site`: `VLiteral`<`"catalog"`, `"required"`> ; `catalog`: `VString`<`string`, `"required"`> ; `dataset`: `VString`<`string`, `"required"`> }, `"required"`, `"dataset"` \| `"site"` \| `"catalog"`>], `"required"`, `"target"` \| `"dataset"` \| `"source"` \| `"site"` \| `"catalog"`> ; `fields`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> }, `"required"`, `"kind"` \| `"fields"` \| `"from"` \| `"to"` \| `"to.target"` \| `"to.dataset"` \| `"to.source"` \| `"to.site"` \| `"to.catalog"`>, `VObject`<{ `kind`: `"state"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { site: “compute”; } }, { `kind`: `VLiteral`<`"state"`, `"required"`> ; `from`: `VString`<`string`, `"required"`> ; `to`: `VObject`<{ `site`: `"compute"` }, { `site`: `VLiteral`<`"compute"`, `"required"`> }, `"required"`, `"site"`> = computeSite; `fields`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> }, `"required"`, `"kind"` \| `"fields"` \| `"from"` \| `"to"` \| `"to.site"`>, `VObject`<{ `kind`: `"keys"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { target: string; source: string; site: “source”; } }, { `kind`: `VLiteral`<`"keys"`, `"required"`> ; `from`: `VString`<`string`, `"required"`> ; `to`: `VObject`<{ `target`: `string` ; `source`: `string` ; `site`: `"source"` }, { `site`: `VLiteral`<`"source"`, `"required"`> ; `source`: `VString`<`string`, `"required"`> ; `target`: `VString`<`string`, `"required"`> }, `"required"`, `"target"` \| `"source"` \| `"site"`> = sourceSite; `fields`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> }, `"required"`, `"kind"` \| `"fields"` \| `"from"` \| `"to"` \| `"to.target"` \| `"to.source"` \| `"to.site"`>, `VObject`<{ `kind`: `"range"` ; `fields`: `string`[] ; `from`: `string` ; `to`: { target: string; source: string; site: “source”; } }, { `kind`: `VLiteral`<`"range"`, `"required"`> ; `from`: `VString`<`string`, `"required"`> ; `to`: `VObject`<{ `target`: `string` ; `source`: `string` ; `site`: `"source"` }, { `site`: `VLiteral`<`"source"`, `"required"`> ; `source`: `VString`<`string`, `"required"`> ; `target`: `VString`<`string`, `"required"`> }, `"required"`, `"target"` \| `"source"` \| `"site"`> = sourceSite; `fields`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> }, `"required"`, `"kind"` \| `"fields"` \| `"from"` \| `"to"` \| `"to.target"` \| `"to.source"` \| `"to.site"`>, `VObject`<{ `kind`: `"values"` ; `fields`: `string`[] ; `from`: `null` \| `string` ; `to`: { target: string; source: string; site: “source”; } }, { `kind`: `VLiteral`<`"values"`, `"required"`> ; `from`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `to`: `VObject`<{ `target`: `string` ; `source`: `string` ; `site`: `"source"` }, { `site`: `VLiteral`<`"source"`, `"required"`> ; `source`: `VString`<`string`, `"required"`> ; `target`: `VString`<`string`, `"required"`> }, `"required"`, `"target"` \| `"source"` \| `"site"`> = sourceSite; `fields`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> }, `"required"`, `"kind"` \| `"fields"` \| `"from"` \| `"to"` \| `"to.target"` \| `"to.source"` \| `"to.site"`>], `"required"`, `"kind"` \| `"fields"` \| `"from"` \| `"to"` \| `"to.target"` \| `"to.dataset"` \| `"to.source"` \| `"to.site"` \| `"to.catalog"`> }, `"required"`, `"kind"` \| `"component"` \| `"crossing"` \| `"crossing.kind"` \| `"crossing.fields"` \| `"crossing.from"` \| `"crossing.to"` \| `"crossing.to.target"` \| `"crossing.to.dataset"` \| `"crossing.to.source"` \| `"crossing.to.site"` \| `"crossing.to.catalog"`>, `VObject`<{ `kind`: `"virtualTableRetention"` ; `component`: `null` \| `string` ; `expiresAt`: `string` ; `tables`: `string`[] }, { `kind`: `VLiteral`<`"virtualTableRetention"`, `"required"`> ; `component`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `tables`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> ; `expiresAt`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"component"` \| `"expiresAt"` \| `"tables"`>], `"required"`, `"kind"` \| `"component"` \| `"record"` \| `"args"` \| `"size"` \| `"expiresAt"` \| `"target"` \| `"method"` \| `"integration"` \| `"command"` \| `"series"` \| `"table"` \| `"sha256"` \| `"contract"` \| `"source"` \| `"hour"` \| `"group"` \| `"recipient"` \| `"release"` \| `"tables"` \| `"selection"` \| `"phase"` \| `"changes"` \| `"url"` \| `"control"` \| `"target.kind"` \| `"executor"` \| `"onward"` \| `"executor.function"` \| `"executor.kind"` \| `"executor.sourceId"` \| `"executor.component"` \| `"executor.program"` \| `"executor.integration"` \| `"executor.command"` \| `"executor.endpoint"` \| `"executor.binding"` \| `"executor.connection"` \| `"executor.program.revision"` \| `"executor.definitionRevision"` \| `"executor.credentialDigest"` \| `"executor.authorityDigest"` \| `"crossing"` \| `"crossing.kind"` \| `"crossing.fields"` \| `"crossing.from"` \| `"crossing.to"` \| `"crossing.to.target"` \| `"crossing.to.dataset"` \| `"crossing.to.source"` \| `"crossing.to.site"` \| `"crossing.to.catalog"` \| `"retired"` \| `"target.series"` \| `"target.source"` \| `"target.event"` \| `"target.generation"` \| `"target.from"` \| `"target.to"` \| `"producer"` \| `"run"` \| `"work"` \| `"work.component"` \| `"work.worker"` \| `"work.installation"` \| `"work.effect"` \| `args.${string}` \| `"target.sourceId"` \| `"storageId"` \| `"shareId"`>

riskBinding

• Const riskBinding: VObject<{ organization: string ; principal: string ; participant: null | string ; target: { key: string; type: string; } ; operation: string ; request: string ; session: string ; executor: string ; attempt: string ; client: string ; policyVersion: string }, { request: VString<string, "required"> ; attempt: VString<string, "required"> ; principal: VString<string, "required"> ; executor: VString<string, "required"> ; organization: VString<string, "required"> ; target: VObject<{ key: string ; type: string }, { type: VString<string, "required"> ; key: VString<string, "required"> }, "required", "key" | "type"> ; operation: VString<string, "required"> ; client: VString<string, "required"> ; session: VString<string, "required"> ; participant: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; policyVersion: VString<string, "required"> }, "required", "organization" | "principal" | "participant" | "target" | "operation" | "request" | "session" | "executor" | "attempt" | "client" | "target.key" | "policyVersion" | "target.type"> The operation owner captures this from authenticated request context. None of these identities may be taken from a caller’s proposed risk verdict.

riskObservation

• Const riskObservation: VObject<{ decision: "unavailable" | "challenge" | "allow" | "deny" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; observedAt: number ; validUntil: number ; binding: string ; policyVersion: string }, { binding: VString<string, "required"> ; policyVersion: VString<string, "required"> ; decision: VUnion<"unavailable" | "challenge" | "allow" | "deny", [VLiteral<"allow", "required">, VLiteral<"deny", "required">, VLiteral<"challenge", "required">, VLiteral<"unavailable", "required">], "required", never> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; revision: VString<string, "required"> ; observedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> }, "required", "decision" | "source" | "revision" | "observedAt" | "validUntil" | "binding" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "policyVersion">

assessment

• Const assessment: VObject<{ kind: "unavailable" | "challenge" | "allow" | "deny" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: null | string ; reason: string ; validUntil: null | number ; binding: null | string ; handling: "refuse" | "challenge" }, { kind: VUnion<"unavailable" | "challenge" | "allow" | "deny", [VLiteral<"allow", "required">, VLiteral<"deny", "required">, VLiteral<"challenge", "required">, VLiteral<"unavailable", "required">], "required", never> ; binding: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; reason: VString<string, "required"> ; handling: VUnion<"refuse" | "challenge", [VLiteral<"refuse", "required">, VLiteral<"challenge", "required">], "required", never> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; revision: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; validUntil: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> }, "required", "kind" | "source" | "revision" | "reason" | "validUntil" | "binding" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "handling"> Not exported: an exported type refers to it.

securityPopulation

• Const securityPopulation: VUnion<{ kind: "unsupported" } | { kind: "unavailable" } | { kind: "observed" ; cursor: null | string ; coverage: "partial" | "complete" ; ids: string[] ; observedAtMs: number ; validUntilMs: null | number }, [VObject<{ kind: "unsupported" }, { kind: VLiteral<"unsupported", "required"> }, "required", "kind">, VObject<{ kind: "unavailable" }, { kind: VLiteral<"unavailable", "required"> }, "required", "kind">, VObject<{ kind: "observed" ; cursor: null | string ; coverage: "partial" | "complete" ; ids: string[] ; observedAtMs: number ; validUntilMs: null | number }, { kind: VLiteral<"observed", "required"> ; observedAtMs: VFloat64<number, "required"> ; validUntilMs: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; coverage: VUnion<"partial" | "complete", [VLiteral<"complete", "required">, VLiteral<"partial", "required">], "required", never> ; ids: VArray<string[], VString<string, "required">, "required"> ; cursor: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> }, "required", "kind" | "cursor" | "coverage" | "ids" | "observedAtMs" | "validUntilMs">], "required", "kind" | "cursor" | "coverage" | "ids" | "observedAtMs" | "validUntilMs"> A population query receives the verified caller, never a caller-selected person. Its own native reads and the inspection owner still enforce access. Unsupported and unavailable populations never become empty inventories.

SERVICE_ISSUER

• Const SERVICE_ISSUER: "https://services.bijection.invalid" The issuer every service principal’s issuer extends.

SESSION_SUBJECT

• Const SESSION_SUBJECT: "session:" What an issued session’s subject is prefixed with.

CREDENTIAL_CLAIM

• Const CREDENTIAL_CLAIM: "bijectionCredential" The claim naming the credential that authenticated a service or a session it issued. Only the deployment’s own credential verification sets it.

workosEnterpriseHealthObservation

• Const workosEnterpriseHealthObservation: VObject<{ directoryEvidence: undefined | null | { evidence: { dataset?: { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; }; source: { …; }; directory: string; } ; record: null | { id: string; organization: string; directory: string | null; connectionState: string; ssoEnforced: null; connectionType: string; directoryState: string | null; certificateState: “unavailable” | “observed” | “notApplicable”; certificates: { …; }[]; } ; evidence: null | { dataset?: { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; } ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; selection: { connection: string; directory: string | null; } ; configuration: { issuer: string; clientId: string; providerOrganization: string; } }, { configuration: VObject<{ issuer: string ; clientId: string ; providerOrganization: string }, { issuer: VString<string, "required"> ; clientId: VString<string, "required"> ; providerOrganization: VString<string, "required"> }, "required", "issuer" | "clientId" | "providerOrganization"> ; selection: VObject<{ connection: string ; directory: null | string }, { connection: VString<string, "required"> ; directory: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> }, "required", "connection" | "directory"> ; source: VUnion<null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, [VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation">, VNull<null, "required">], "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> ; evidence: VUnion<null | { dataset: undefined | { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; } ; recordObservedFrom: undefined | number ; recordObservedTo: undefined | number ; capabilities: null | { evidence: “native” | “asserted” | “brokered”; consistency: “snapshot” | “observations”; coverage: “records” | “enumeration” | “snapshot” | “queryResult” | “incrementalSnapshot” | “committedPrefix” | “latestPerKey”; … 6 more …; snapshotMaxRows: string | null; } ; population: null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; erased: boolean ; publication: null | { sourceId: SourceId; scope: string; publicationId: SourcePublicationId; checkpoint: { position: { value: string; space: string; } | null; captureId: string; } | null; epoch: SourceEpoch; } ; populationCovered: boolean ; populationObservedFrom: null | number ; observedFrom: null | number ; observedTo: null | number ; continuityLost: boolean ; historyInterrupted: boolean }, [VObject<{ dataset: undefined | { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; } ; recordObservedFrom: undefined | number ; recordObservedTo: undefined | number ; capabilities: null | { evidence: “native” | “asserted” | “brokered”; consistency: “snapshot” | “observations”; coverage: “records” | “enumeration” | “snapshot” | “queryResult” | “incrementalSnapshot” | “committedPrefix” | “latestPerKey”; … 6 more …; snapshotMaxRows: string | null; } ; population: null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; erased: boolean ; publication: null | { sourceId: SourceId; scope: string; publicationId: SourcePublicationId; checkpoint: { position: { value: string; space: string; } | null; captureId: string; } | null; epoch: SourceEpoch; } ; populationCovered: boolean ; populationObservedFrom: null | number ; observedFrom: null | number ; observedTo: null | number ; continuityLost: boolean ; historyInterrupted: boolean }, { publication: VUnion<null | { sourceId: SourceId ; scope: string ; publicationId: SourcePublicationId ; checkpoint: null | { position: { value: string; space: string; } | null; captureId: string; } ; epoch: SourceEpoch }, [VObject<{ sourceId: SourceId ; scope: string ; publicationId: SourcePublicationId ; checkpoint: null | { position: { value: string; space: string; } | null; captureId: string; } ; epoch: SourceEpoch }, { sourceId: VIdentity<SourceId, "sourceId", "required"> ; epoch: VString<SourceEpoch, "required"> ; scope: VString<string, "required"> ; publicationId: VString<SourcePublicationId, "required"> ; checkpoint: VUnion<null | { position: null | { value: string; space: string; } ; captureId: string }, [VObject<{ position: null | { value: string; space: string; } ; captureId: string }, { captureId: VString<string, "required"> ; position: VUnion<null | { value: string ; space: string }, [VObject<{ value: string ; space: string }, { space: VString<string, "required"> ; value: VString<string, "required"> }, "required", "value" | "space">, VNull<null, "required">], "required", "value" | "space"> }, "required", "position" | "captureId" | "position.value" | "position.space">, VNull<null, "required">], "required", "position" | "captureId" | "position.value" | "position.space"> }, "required", "sourceId" | "scope" | "publicationId" | "checkpoint" | "epoch" | "checkpoint.position" | "checkpoint.captureId" | "checkpoint.position.value" | "checkpoint.position.space">, VNull<null, "required">], "required", "sourceId" | "scope" | "publicationId" | "checkpoint" | "epoch" | "checkpoint.position" | "checkpoint.captureId" | "checkpoint.position.value" | "checkpoint.position.space"> ; populationCovered: VBoolean<boolean, "required"> ; populationObservedFrom: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; observedFrom: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; observedTo: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; recordObservedFrom: VFloat64<undefined | number, "optional"> ; recordObservedTo: VFloat64<undefined | number, "optional"> ; continuityLost: VBoolean<boolean, "required"> ; historyInterrupted: VBoolean<boolean, "required"> ; erased: VBoolean<boolean, "required"> ; dataset: VObject<undefined | { component: null | string ; dataset: null | string ; version: null | string ; revision: null | string ; publicationId: null | SourcePublicationId ; coherent: boolean ; completeVersion: boolean }, { component: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; dataset: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; version: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; revision: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; publicationId: VUnion<null | SourcePublicationId, [VString<SourcePublicationId, "required">, VNull<null, "required">], "required", never> ; coherent: VBoolean<boolean, "required"> ; completeVersion: VBoolean<boolean, "required"> }, "optional", "component" | "dataset" | "version" | "revision" | "publicationId" | "coherent" | "completeVersion"> ; capabilities: VUnion<null | { evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, [VObject<{ evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, { consistency: VUnion<"snapshot" | "observations", [VLiteral<"observations", "required">, VLiteral<"snapshot", "required">], "required", never> = validatorSourceConsistency; evidence: VUnion<"native" | "asserted" | "brokered", [VLiteral<"native", "required">, VLiteral<"brokered", "required">, VLiteral<"asserted", "required">], "required", never> = validatorEvidenceClass; recordRefresh: VBoolean<boolean, "required"> ; reconciliation: VBoolean<boolean, "required"> ; notifications: VBoolean<boolean, "required"> ; snapshotMaxRows: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; protocol: Validator<"dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest", "required", any> ; coverage: Validator<"records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", "required", any> ; atomicity: Validator<"record" | "snapshot" | "sourceTransaction", "required", any> ; history: Validator<"observations" | "completeChanges" | "completeOccurrences" | "latestState", "required", any> }, "required", "evidence" | "consistency" | "coverage" | "reconciliation" | "history" | "protocol" | "atomicity" | "recordRefresh" | "notifications" | "snapshotMaxRows" | `coverage.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

{any}`>, VNull<null, "required">], "required", "evidence" | "consistency" | "coverage" | "reconciliation" | "history" | "protocol" | "atomicity" | "recordRefresh" | "notifications" | "snapshotMaxRows" | `coverage.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

{any}`> ; population: VUnion<null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", [Validator<"records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", "required", any>, VNull<null, "required">], "required", any> }, "required", "dataset" | "capabilities" | "population" | "erased" | "publication" | "populationCovered" | "populationObservedFrom" | "observedFrom" | "observedTo" | "continuityLost" | "historyInterrupted" | "recordObservedFrom" | "recordObservedTo" | "capabilities.evidence" | "capabilities.consistency" | "capabilities.coverage" | "capabilities.reconciliation" | "capabilities.history" | "capabilities.protocol" | "capabilities.atomicity" | "capabilities.recordRefresh" | "capabilities.notifications" | "capabilities.snapshotMaxRows" | "dataset.component" | "dataset.dataset" | "dataset.version" | "dataset.revision" | "dataset.publicationId" | "dataset.coherent" | "dataset.completeVersion" | "publication.sourceId" | "publication.scope" | "publication.publicationId" | "publication.checkpoint" | "publication.epoch" | "publication.checkpoint.position" | "publication.checkpoint.captureId" | "publication.checkpoint.position.value" | "publication.checkpoint.position.space" | `capabilities.coverage.

\{any}\` \| \`capabilities.history.

{any}` | `capabilities.protocol.

\{any}\` \| \`capabilities.atomicity.

{any}` | `population.

\{any}\`\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, ``"dataset"`` \| ``"capabilities"`` \| ``"population"`` \| ``"erased"`` \| ``"publication"`` \| ``"populationCovered"`` \| ``"populationObservedFrom"`` \| ``"observedFrom"`` \| ``"observedTo"`` \| ``"continuityLost"`` \| ``"historyInterrupted"`` \| ``"recordObservedFrom"`` \| ``"recordObservedTo"`` \| ``"capabilities.evidence"`` \| ``"capabilities.consistency"`` \| ``"capabilities.coverage"`` \| ``"capabilities.reconciliation"`` \| ``"capabilities.history"`` \| ``"capabilities.protocol"`` \| ``"capabilities.atomicity"`` \| ``"capabilities.recordRefresh"`` \| ``"capabilities.notifications"`` \| ``"capabilities.snapshotMaxRows"`` \| ``"dataset.component"`` \| ``"dataset.dataset"`` \| ``"dataset.version"`` \| ``"dataset.revision"`` \| ``"dataset.publicationId"`` \| ``"dataset.coherent"`` \| ``"dataset.completeVersion"`` \| ``"publication.sourceId"`` \| ``"publication.scope"`` \| ``"publication.publicationId"`` \| ``"publication.checkpoint"`` \| ``"publication.epoch"`` \| ``"publication.checkpoint.position"`` \| ``"publication.checkpoint.captureId"`` \| ``"publication.checkpoint.position.value"`` \| ``"publication.checkpoint.position.space"`` \| \`capabilities.coverage.

{any}` | `capabilities.history.

\{any}\` \| \`capabilities.protocol.

{any}` | `capabilities.atomicity.

\{any}\` \| \`population.

{any}`> ; directoryEvidence: VUnion<undefined | null | { evidence: { dataset?: { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; } ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; directory: string }, [VObject<{ evidence: { dataset?: { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; } ; source: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; directory: string }, { directory: VString<string, "required"> ; source: VObject<{ id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string }, { location: VObject<{ incarnation: string ; branch: null | { key: string; generation: string; } ; deployment_id: string }, { deployment_id: VString<string, "required"> ; incarnation: VString<string, "required"> ; branch: VUnion<null | { key: string ; generation: string }, [VNull<null, "required">, VObject<{ key: string ; generation: string }, { key: VString<string, "required"> ; generation: VString<string, "required"> }, "required", "key" | "generation">], "required", "key" | "generation"> }, "required", "incarnation" | "branch" | "deployment_id" | "branch.key" | "branch.generation"> ; installation: VString<string, "required"> ; protocol: VString<string, "required"> ; id: VString<string, "required"> }, "required", "id" | "installation" | "location" | "protocol" | "location.incarnation" | "location.branch" | "location.deployment_id" | "location.branch.key" | "location.branch.generation"> = subjectRefValidator; evidence: VObject<{ dataset: undefined | { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; } ; recordObservedFrom: undefined | number ; recordObservedTo: undefined | number ; capabilities: null | { evidence: “native” | “asserted” | “brokered”; consistency: “snapshot” | “observations”; coverage: “records” | “enumeration” | “snapshot” | “queryResult” | “incrementalSnapshot” | “committedPrefix” | “latestPerKey”; … 6 more …; snapshotMaxRows: string | null; } ; population: null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; erased: boolean ; publication: null | { sourceId: SourceId; scope: string; publicationId: SourcePublicationId; checkpoint: { position: { value: string; space: string; } | null; captureId: string; } | null; epoch: SourceEpoch; } ; populationCovered: boolean ; populationObservedFrom: null | number ; observedFrom: null | number ; observedTo: null | number ; continuityLost: boolean ; historyInterrupted: boolean }, { publication: VUnion<null | { sourceId: SourceId ; scope: string ; publicationId: SourcePublicationId ; checkpoint: null | { position: { value: string; space: string; } | null; captureId: string; } ; epoch: SourceEpoch }, [VObject<{ sourceId: SourceId ; scope: string ; publicationId: SourcePublicationId ; checkpoint: null | { position: { value: string; space: string; } | null; captureId: string; } ; epoch: SourceEpoch }, { sourceId: VIdentity<SourceId, "sourceId", "required"> ; epoch: VString<SourceEpoch, "required"> ; scope: VString<string, "required"> ; publicationId: VString<SourcePublicationId, "required"> ; checkpoint: VUnion<null | { position: null | { value: string; space: string; } ; captureId: string }, [VObject<{ position: null | { value: string; space: string; } ; captureId: string }, { captureId: VString<string, "required"> ; position: VUnion<null | { value: string ; space: string }, [VObject<{ value: string ; space: string }, { space: VString<string, "required"> ; value: VString<string, "required"> }, "required", "value" | "space">, VNull<null, "required">], "required", "value" | "space"> }, "required", "position" | "captureId" | "position.value" | "position.space">, VNull<null, "required">], "required", "position" | "captureId" | "position.value" | "position.space"> }, "required", "sourceId" | "scope" | "publicationId" | "checkpoint" | "epoch" | "checkpoint.position" | "checkpoint.captureId" | "checkpoint.position.value" | "checkpoint.position.space">, VNull<null, "required">], "required", "sourceId" | "scope" | "publicationId" | "checkpoint" | "epoch" | "checkpoint.position" | "checkpoint.captureId" | "checkpoint.position.value" | "checkpoint.position.space"> ; populationCovered: VBoolean<boolean, "required"> ; populationObservedFrom: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; observedFrom: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; observedTo: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; recordObservedFrom: VFloat64<undefined | number, "optional"> ; recordObservedTo: VFloat64<undefined | number, "optional"> ; continuityLost: VBoolean<boolean, "required"> ; historyInterrupted: VBoolean<boolean, "required"> ; erased: VBoolean<boolean, "required"> ; dataset: VObject<undefined | { component: null | string ; dataset: null | string ; version: null | string ; revision: null | string ; publicationId: null | SourcePublicationId ; coherent: boolean ; completeVersion: boolean }, { component: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; dataset: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; version: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; revision: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; publicationId: VUnion<null | SourcePublicationId, [VString<SourcePublicationId, "required">, VNull<null, "required">], "required", never> ; coherent: VBoolean<boolean, "required"> ; completeVersion: VBoolean<boolean, "required"> }, "optional", "component" | "dataset" | "version" | "revision" | "publicationId" | "coherent" | "completeVersion"> ; capabilities: VUnion<null | { evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, [VObject<{ evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, { consistency: VUnion<"snapshot" | "observations", [VLiteral<"observations", "required">, VLiteral<"snapshot", "required">], "required", never> = validatorSourceConsistency; evidence: VUnion<"native" | "asserted" | "brokered", [VLiteral<"native", "required">, VLiteral<"brokered", "required">, VLiteral<"asserted", "required">], "required", never> = validatorEvidenceClass; recordRefresh: VBoolean<boolean, "required"> ; reconciliation: VBoolean<boolean, "required"> ; notifications: VBoolean<boolean, "required"> ; snapshotMaxRows: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; protocol: Validator<"dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest", "required", any> ; coverage: Validator<"records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", "required", any> ; atomicity: Validator<"record" | "snapshot" | "sourceTransaction", "required", any> ; history: Validator<"observations" | "completeChanges" | "completeOccurrences" | "latestState", "required", any> }, "required", "evidence" | "consistency" | "coverage" | "reconciliation" | "history" | "protocol" | "atomicity" | "recordRefresh" | "notifications" | "snapshotMaxRows" | `coverage.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

\{any}\` \| \`capabilities.history.

{any}` | `capabilities.protocol.

\{any}\` \| \`capabilities.atomicity.

{any}` | `population.

\{any}\`\> = sourceStatusValidator.fields.evidence \}, ``"required"``, ``"evidence"`` \| ``"source"`` \| ``"directory"`` \| ``"evidence.dataset"`` \| ``"evidence.capabilities"`` \| ``"evidence.population"`` \| ``"evidence.erased"`` \| ``"evidence.publication"`` \| ``"evidence.populationCovered"`` \| ``"evidence.populationObservedFrom"`` \| ``"evidence.observedFrom"`` \| ``"evidence.observedTo"`` \| ``"evidence.continuityLost"`` \| ``"evidence.historyInterrupted"`` \| ``"evidence.recordObservedFrom"`` \| ``"evidence.recordObservedTo"`` \| ``"evidence.capabilities.evidence"`` \| ``"evidence.capabilities.consistency"`` \| ``"evidence.capabilities.coverage"`` \| ``"evidence.capabilities.reconciliation"`` \| ``"evidence.capabilities.history"`` \| ``"evidence.capabilities.protocol"`` \| ``"evidence.capabilities.atomicity"`` \| ``"evidence.capabilities.recordRefresh"`` \| ``"evidence.capabilities.notifications"`` \| ``"evidence.capabilities.snapshotMaxRows"`` \| ``"evidence.dataset.component"`` \| ``"evidence.dataset.dataset"`` \| ``"evidence.dataset.version"`` \| ``"evidence.dataset.revision"`` \| ``"evidence.dataset.publicationId"`` \| ``"evidence.dataset.coherent"`` \| ``"evidence.dataset.completeVersion"`` \| ``"evidence.publication.sourceId"`` \| ``"evidence.publication.scope"`` \| ``"evidence.publication.publicationId"`` \| ``"evidence.publication.checkpoint"`` \| ``"evidence.publication.epoch"`` \| ``"evidence.publication.checkpoint.position"`` \| ``"evidence.publication.checkpoint.captureId"`` \| ``"evidence.publication.checkpoint.position.value"`` \| ``"evidence.publication.checkpoint.position.space"`` \| \`evidence.capabilities.coverage.

{any}` | `evidence.capabilities.history.

\{any}\` \| \`evidence.capabilities.protocol.

{any}` | `evidence.capabilities.atomicity.

\{any}\` \| \`evidence.population.

{any}` | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation">, VNull<null, "required">], "optional", "evidence" | "source" | "directory" | "evidence.dataset" | "evidence.capabilities" | "evidence.population" | "evidence.erased" | "evidence.publication" | "evidence.populationCovered" | "evidence.populationObservedFrom" | "evidence.observedFrom" | "evidence.observedTo" | "evidence.continuityLost" | "evidence.historyInterrupted" | "evidence.recordObservedFrom" | "evidence.recordObservedTo" | "evidence.capabilities.evidence" | "evidence.capabilities.consistency" | "evidence.capabilities.coverage" | "evidence.capabilities.reconciliation" | "evidence.capabilities.history" | "evidence.capabilities.protocol" | "evidence.capabilities.atomicity" | "evidence.capabilities.recordRefresh" | "evidence.capabilities.notifications" | "evidence.capabilities.snapshotMaxRows" | "evidence.dataset.component" | "evidence.dataset.dataset" | "evidence.dataset.version" | "evidence.dataset.revision" | "evidence.dataset.publicationId" | "evidence.dataset.coherent" | "evidence.dataset.completeVersion" | "evidence.publication.sourceId" | "evidence.publication.scope" | "evidence.publication.publicationId" | "evidence.publication.checkpoint" | "evidence.publication.epoch" | "evidence.publication.checkpoint.position" | "evidence.publication.checkpoint.captureId" | "evidence.publication.checkpoint.position.value" | "evidence.publication.checkpoint.position.space" | `evidence.capabilities.coverage.

\{any}\` \| \`evidence.capabilities.history.

{any}` | `evidence.capabilities.protocol.

\{any}\` \| \`evidence.capabilities.atomicity.

{any}` | `evidence.population.

\{any}\` \| ``"source.id"`` \| ``"source.installation"`` \| ``"source.location"`` \| ``"source.protocol"`` \| ``"source.location.incarnation"`` \| ``"source.location.branch"`` \| ``"source.location.deployment_id"`` \| ``"source.location.branch.key"`` \| ``"source.location.branch.generation"``\> ; `record`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| \{ `id`: `string` ; `organization`: `string` ; `directory`: ``null`` \| `string` ; `connectionState`: `string` ; `ssoEnforced`: ``null`` ; `connectionType`: `string` ; `directoryState`: ``null`` \| `string` ; `certificateState`: ``"unavailable"`` \| ``"observed"`` \| ``"notApplicable"`` ; `certificates`: \{ id: string; notBefore: number \| null; notAfter: number \| null; \}[] \}, [[`VObject`](/api/classes/values.VObject)\<\{ `id`: `string` ; `organization`: `string` ; `directory`: ``null`` \| `string` ; `connectionState`: `string` ; `ssoEnforced`: ``null`` ; `connectionType`: `string` ; `directoryState`: ``null`` \| `string` ; `certificateState`: ``"unavailable"`` \| ``"observed"`` \| ``"notApplicable"`` ; `certificates`: \{ id: string; notBefore: number \| null; notAfter: number \| null; \}[] \}, \{ `id`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `organization`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `connectionType`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `connectionState`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `directory`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, `never`\> ; `directoryState`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, `never`\> ; `certificateState`: [`VUnion`](/api/classes/values.VUnion)\<``"unavailable"`` \| ``"observed"`` \| ``"notApplicable"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"observed"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"unavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"notApplicable"``, ``"required"``\>], ``"required"``, `never`\> ; `certificates`: [`VArray`](/api/classes/values.VArray)\<\{ `id`: `string` ; `notBefore`: ``null`` \| `number` ; `notAfter`: ``null`` \| `number` \}[], [`VObject`](/api/classes/values.VObject)\<\{ `id`: `string` ; `notBefore`: ``null`` \| `number` ; `notAfter`: ``null`` \| `number` \}, \{ `id`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `notBefore`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| `number`, [[`VFloat64`](/api/classes/values.VFloat64)\<`number`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, `never`\> ; `notAfter`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| `number`, [[`VFloat64`](/api/classes/values.VFloat64)\<`number`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, `never`\> \}, ``"required"``, ``"id"`` \| ``"notBefore"`` \| ``"notAfter"``\>, ``"required"``\> ; `ssoEnforced`: [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\> \}, ``"required"``, ``"id"`` \| ``"organization"`` \| ``"directory"`` \| ``"connectionState"`` \| ``"ssoEnforced"`` \| ``"connectionType"`` \| ``"directoryState"`` \| ``"certificateState"`` \| ``"certificates"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, ``"id"`` \| ``"organization"`` \| ``"directory"`` \| ``"connectionState"`` \| ``"ssoEnforced"`` \| ``"connectionType"`` \| ``"directoryState"`` \| ``"certificateState"`` \| ``"certificates"``\> \}, ``"required"``, ``"record"`` \| ``"evidence"`` \| ``"source"`` \| ``"selection"`` \| ``"configuration"`` \| ``"evidence.dataset"`` \| ``"evidence.capabilities"`` \| ``"evidence.population"`` \| ``"evidence.erased"`` \| ``"evidence.publication"`` \| ``"evidence.populationCovered"`` \| ``"evidence.populationObservedFrom"`` \| ``"evidence.observedFrom"`` \| ``"evidence.observedTo"`` \| ``"evidence.continuityLost"`` \| ``"evidence.historyInterrupted"`` \| ``"evidence.recordObservedFrom"`` \| ``"evidence.recordObservedTo"`` \| ``"evidence.capabilities.evidence"`` \| ``"evidence.capabilities.consistency"`` \| ``"evidence.capabilities.coverage"`` \| ``"evidence.capabilities.reconciliation"`` \| ``"evidence.capabilities.history"`` \| ``"evidence.capabilities.protocol"`` \| ``"evidence.capabilities.atomicity"`` \| ``"evidence.capabilities.recordRefresh"`` \| ``"evidence.capabilities.notifications"`` \| ``"evidence.capabilities.snapshotMaxRows"`` \| ``"evidence.dataset.component"`` \| ``"evidence.dataset.dataset"`` \| ``"evidence.dataset.version"`` \| ``"evidence.dataset.revision"`` \| ``"evidence.dataset.publicationId"`` \| ``"evidence.dataset.coherent"`` \| ``"evidence.dataset.completeVersion"`` \| ``"evidence.publication.sourceId"`` \| ``"evidence.publication.scope"`` \| ``"evidence.publication.publicationId"`` \| ``"evidence.publication.checkpoint"`` \| ``"evidence.publication.epoch"`` \| ``"evidence.publication.checkpoint.position"`` \| ``"evidence.publication.checkpoint.captureId"`` \| ``"evidence.publication.checkpoint.position.value"`` \| ``"evidence.publication.checkpoint.position.space"`` \| \`evidence.capabilities.coverage.

{any}` | `evidence.capabilities.history.

\{any}\` \| \`evidence.capabilities.protocol.

{any}` | `evidence.capabilities.atomicity.

\{any}\` \| \`evidence.population.

{any}` | "record.id" | "source.id" | "source.installation" | "source.location" | "source.protocol" | "source.location.incarnation" | "source.location.branch" | "source.location.deployment_id" | "source.location.branch.key" | "source.location.branch.generation" | "configuration.issuer" | "configuration.clientId" | "configuration.providerOrganization" | "directoryEvidence" | "record.organization" | "record.directory" | "record.connectionState" | "record.ssoEnforced" | "record.connectionType" | "record.directoryState" | "record.certificateState" | "record.certificates" | "selection.connection" | "selection.directory" | "directoryEvidence.evidence" | "directoryEvidence.source" | "directoryEvidence.directory" | "directoryEvidence.evidence.dataset" | "directoryEvidence.evidence.capabilities" | "directoryEvidence.evidence.population" | "directoryEvidence.evidence.erased" | "directoryEvidence.evidence.publication" | "directoryEvidence.evidence.populationCovered" | "directoryEvidence.evidence.populationObservedFrom" | "directoryEvidence.evidence.observedFrom" | "directoryEvidence.evidence.observedTo" | "directoryEvidence.evidence.continuityLost" | "directoryEvidence.evidence.historyInterrupted" | "directoryEvidence.evidence.recordObservedFrom" | "directoryEvidence.evidence.recordObservedTo" | "directoryEvidence.evidence.capabilities.evidence" | "directoryEvidence.evidence.capabilities.consistency" | "directoryEvidence.evidence.capabilities.coverage" | "directoryEvidence.evidence.capabilities.reconciliation" | "directoryEvidence.evidence.capabilities.history" | "directoryEvidence.evidence.capabilities.protocol" | "directoryEvidence.evidence.capabilities.atomicity" | "directoryEvidence.evidence.capabilities.recordRefresh" | "directoryEvidence.evidence.capabilities.notifications" | "directoryEvidence.evidence.capabilities.snapshotMaxRows" | "directoryEvidence.evidence.dataset.component" | "directoryEvidence.evidence.dataset.dataset" | "directoryEvidence.evidence.dataset.version" | "directoryEvidence.evidence.dataset.revision" | "directoryEvidence.evidence.dataset.publicationId" | "directoryEvidence.evidence.dataset.coherent" | "directoryEvidence.evidence.dataset.completeVersion" | "directoryEvidence.evidence.publication.sourceId" | "directoryEvidence.evidence.publication.scope" | "directoryEvidence.evidence.publication.publicationId" | "directoryEvidence.evidence.publication.checkpoint" | "directoryEvidence.evidence.publication.epoch" | "directoryEvidence.evidence.publication.checkpoint.position" | "directoryEvidence.evidence.publication.checkpoint.captureId" | "directoryEvidence.evidence.publication.checkpoint.position.value" | "directoryEvidence.evidence.publication.checkpoint.position.space" | `directoryEvidence.evidence.capabilities.coverage.

\{any}\` \| \`directoryEvidence.evidence.capabilities.history.

{any}` | `directoryEvidence.evidence.capabilities.protocol.

\{any}\` \| \`directoryEvidence.evidence.capabilities.atomicity.

{any}` | `directoryEvidence.evidence.population.${any}` | "directoryEvidence.source.id" | "directoryEvidence.source.installation" | "directoryEvidence.source.location" | "directoryEvidence.source.protocol" | "directoryEvidence.source.location.incarnation" | "directoryEvidence.source.location.branch" | "directoryEvidence.source.location.deployment_id" | "directoryEvidence.source.location.branch.key" | "directoryEvidence.source.location.branch.generation"> Read only through a fixed internal query which obtains the row and its exact record evidence from ctx.sources.evidence(…,{record:row._id}).

Functions

defineClassificationProfile

▸ defineClassificationProfile<Name, Required, C>(input): ClassificationProfile<Name, Required, C> A fixed classification vocabulary with explicit required resource bindings. Every generated binding protects object identity and readable properties and refuses empty or unknown classification sets on create, update and move. A profile either declares its own categories or adopts the organization’s central label registry. A registry-bound profile cannot redefine a category: the management registry is the only author, the profile records the revision it compiled, and clearances declares the directory through which the deployment acquires central clearances.

Type parameters

Name	Type
`Name`	extends `string`
`Required`	extends readonly `string`[]
`C`	extends `Record`<`string`, `ClassificationCategory`>

Parameters

Name	Type
`input`	`Object`
`input.resource`	`Name`
`input.categories`	`C`
`input.requiredOn`	`Required`

Returns

ClassificationProfile<Name, Required, C> ▸ defineClassificationProfile<Name, Required, R>(input): ClassificationProfile<Name, Required, RegistryCategories<R>>

Type parameters

Name	Type
`Name`	extends `string`
`Required`	extends readonly `string`[]
`R`	extends `LabelRegistrySnapshot`

Parameters

Name	Type
`input`	`Object`
`input.resource`	`Name`
`input.registry`	`R`
`input.requiredOn`	`Required`

Returns

ClassificationProfile<Name, Required, RegistryCategories<R>>

classificationProfile

▸ classificationProfile<Name, Required, C>(input, registry): Readonly<{ resources: Readonly<Record<Name, Readonly<{ category: Readonly<{ from: "key" }> ; clearance?: "registry" ; permissions: ["pass", "apply", "declassify"] ; dominates?: Readonly<Record<string, readonly string[]>> }>>> ; categories: Readonly<Record<keyof C & string, "any" | "all">> ; registry: null | Readonly<{ organization: string ; revision: number }> ; clearances: <Table>(options: { table: Table ; maxAge: number ; member?: string ; object?: string ; memberIndex?: string ; objectIndex?: string }) => Readonly<{ roles: Readonly<Record<`

\{Name}:cleared\`, readonly [\`

{Name}:pass`]>> ; directory: Readonly<{ table: Table = options.table; memberIndex: string ; objectIndex: string ; type: Name = resourceName; role: Readonly<{ kind: "declared" ; key: `${Name}:cleared` = role }> ; member: string ; object: string ; maxAge: number = options.maxAge }> }> ; labelName: (key: ClassificationKey<C>) => string ; labelNames: (selection: Selection) => string[] ; keyOf: (name: string) => ClassificationKey<C> | null ; readers: (options: { member: (ctx: any) => Promise<boolean> ; principalOf?: (ctx: any, actor: string) => Promise<AccessPrincipal | null> }) => Readonly<{ member: (ctx: any) => Promise<boolean> = options.member; cleared: (ctx: any, names: readonly string[]) => Promise<boolean> ; permits: (ctx: any, names: readonly string[]) => Promise<boolean> = cleared; clearedFor: (ctx: any, actor: string, names: readonly string[]) => Promise<boolean> }> ; datasetRelease: (input: { destination: string ; dataset: { dataset: string ; definition: { labels?: readonly string[] } } ; publisher: string ; requires: string }) => AccessRelease ; validator: VArray<ClassificationKey<C>[], VUnion<ClassificationKey<C>, VLiteral<ClassificationKey<C>, "required">[], "required", never>, "required"> ; release: <Destination>(input: { destination: Destination ; requires?: string ; publisher?: string ; when?: NonNullable<AccessRelease["when"]> ; accepts: readonly ClassificationKey<C>[] ; declassify?: boolean }) => AccessRelease & { destination: Destination } ; modelEgress: <Providers>(input: { providers: Providers ; requires: string ; approved: readonly ClassificationKey<C>[] }) => { destinations: { [K in keyof Providers]: Object } ; releases: { [K in keyof Providers]: AccessRelease & Object } } ; bindings: <B>(bindings: B & Record<Exclude<keyof B, Required[number]>, never>) => { [K in string | number | symbol]: B[K] extends Object ? ClassifiedBinding<A, Name, any[any][“field”]> : never } }> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Name`	extends `string`
`Required`	extends readonly `string`[]
`C`	extends `Record`<`string`, `ClassificationCategory`>

Parameters

Name	Type
`input`	`Object`
`input.resource`	`Name`
`input.categories`	`C`
`input.requiredOn`	`Required`
`registry`	`RegistryBinding` \| `null`

Returns

Readonly<{ resources: Readonly<Record<Name, Readonly<{ category: Readonly<{ from: "key" }> ; clearance?: "registry" ; permissions: ["pass", "apply", "declassify"] ; dominates?: Readonly<Record<string, readonly string[]>> }>>> ; categories: Readonly<Record<keyof C & string, "any" | "all">> ; registry: null | Readonly<{ organization: string ; revision: number }> ; clearances: <Table>(options: { table: Table ; maxAge: number ; member?: string ; object?: string ; memberIndex?: string ; objectIndex?: string }) => Readonly<{ roles: Readonly<Record<`

\{Name}:cleared\`, readonly [\`

componentWork

▸ componentWork(bindings): (destination: Destination) => Promise<boolean> Component work in a hand-written destination rule, with the access model’s meaning: a release is admitted when a binding consents to its component’s scheduled work holding the rule’s rows (custody), or names an effect that admits the destination and the release is that component’s own work. Returns false otherwise, including a consented effect’s destination reached by other work (a member’s own act, say), for the rule’s own decision. Call it inside a private policy (declare reads); restrictions stay the rule’s.

Parameters

Name	Type
`bindings`	readonly `ComponentWorkBinding`[]

Returns

fn ▸ (destination): Promise<boolean>

Parameters

Name	Type
`destination`	`Destination`

Returns

Promise<boolean>

defineAccessContracts

▸ defineAccessContracts<T>(input): Readonly<T> Native admission independently checks schema and physical index bindings.

Type parameters

Name	Type
`T`	extends `Readonly`<`Record`<`string`, `AccessContractDeclaration`>>

Parameters

Name	Type
`input`	`T`

Returns

Readonly<T>

decisionQuery

▸ decisionQuery(installation): RegisteredQuery<"internal", { checks: { key: string; type: string; permission: string; }[] }, Promise<PermissionResult[]>> Not exported: an exported type refers to it.

Parameters

Name	Type
`installation`	`DecisionInstallation`

Returns

RegisteredQuery<"internal", { checks: { key: string; type: string; permission: string; }[] }, Promise<PermissionResult[]>>

defineEvidence

▸ defineEvidence<T>(declarations): Readonly<T>

Type parameters

Name	Type
`T`	extends `Record`<`string`, `EvidenceDeclaration`>

Parameters

Name	Type
`declarations`	`T`

Returns

Readonly<T>

canonicalContact

▸ canonicalContact(kind, input): ContactIdentity Canonicalize under an explicitly declared contact type.

Parameters

Name	Type
`kind`	`ContactKind`
`input`	`string`

Returns

ContactIdentity

validateContactField

▸ validateContactField(value): void

Parameters

Name	Type
`value`	`ContactField`

Returns

void

defineInformationProtection

▸ defineInformationProtection<Field, Resource>(protection): Readonly<{ protect: <P, F>(field: F) => F }> Name one protection so every field carrying it states the same obligations.

Type parameters

Name	Type
`Field`	extends `string` = `string`
`Resource`	extends `string` = `string`

Parameters

Name	Type
`protection`	`AccessInformationProtection`<`Field`, `Resource`>

Returns

Readonly<{ protect: <P, F>(field: F) => F }>

expiryMutation

▸ expiryMutation(lifecycle): RegisteredMutation<"internal", { assignmentId: GenericId<string> }, Promise<null>> Not exported: an exported type refers to it.

Parameters

Name	Type
`lifecycle`	`AssignmentLifecycle`

Returns

RegisteredMutation<"internal", { assignmentId: GenericId<string> }, Promise<null>>

principalReference

▸ principalReference<Key>(key): AccessPrincipal<Key>

Type parameters

Name	Type
`Key`	extends `string`

Parameters

Name	Type
`key`	`Key`

Returns

AccessPrincipal<Key>

defineReleases

▸ defineReleases<Destinations, Releases>(destinations, releases): Releases Declare reusable transfer contracts against a destination vocabulary. Command argument predicates retain the exact receiver’s argument type. Native admission independently resolves every reference; this builder grants no authority.

Type parameters

Name	Type
`Destinations`	extends `Record`<`string`, `AccessDestinationTarget`>
`Releases`	extends `Record`<`string`, `ReleaseFor`<`Destinations`>>

Parameters

Name	Type
`destinations`	`Destinations`
`releases`	`Releases`

Returns

Releases

receiver

▸ receiver<C>(command): Object Name an integration command boundary. This declaration supplies no source permission or transfer consent; releases reference the installed destination.

Type parameters

Name	Type
`C`	extends `CommandHandle`<`any`>

Parameters

Name	Type
`command`	`C`

Returns

Object

Name	Type
`receiver`	`C`

createAccessReader

▸ createAccessReader<D>(definition, ctx): Pick<RequestAccessModel<D, GenericSchema>, ReaderMethod> Construct the same request API for a library’s selected declaration.

Type parameters

Name	Type
`D`	extends `GenericAccessDefinition`

Parameters

Name	Type
`definition`	`D`
`ctx`	`AccessCtx`

Returns

Pick<RequestAccessModel<D, GenericSchema>, ReaderMethod>

createAccessWriter

▸ createAccessWriter<D>(definition, ctx): RequestAccessModel<D, GenericSchema> Construct assignment operations for a mutation context.

Type parameters

Name	Type
`D`	extends `GenericAccessDefinition`

Parameters

Name	Type
`definition`	`D`
`ctx`	`AccessMutationCtx`

Returns

RequestAccessModel<D, GenericSchema>

assignmentsTable

▸ assignmentsTable(): TableDefinition<VUnion<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "person" ; holderKey: string } | { expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "service" ; holderKey: string } | { reason: undefined | string ; key: string ; type: string ; expiresAt: number ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "program" ; holderKey: string ; holderProgram: { record: string; implementation: string; installation: string; callback: string; } } | { expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "group" ; holderType: string ; holderKey: string ; holderPermission: string }, [VObject<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "person" ; holderKey: string }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"person", "required"> }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderKey" | "role.key" | "role.kind" | "role.id">, VObject<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "service" ; holderKey: string }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"service", "required"> }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderKey" | "role.key" | "role.kind" | "role.id">, VObject<{ reason: undefined | string ; key: string ; type: string ; expiresAt: number ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "program" ; holderKey: string ; holderProgram: { record: string; implementation: string; installation: string; callback: string; } }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"program", "required"> ; expiresAt: VFloat64<number, "required"> ; holderProgram: VObject<{ record: string ; implementation: string ; installation: string ; callback: string }, { installation: VString<string, "required"> ; callback: VString<string, "required"> ; record: VString<string, "required"> ; implementation: VString<string, "required"> }, "required", "record" | "implementation" | "installation" | "callback"> = programGrantRefValidator }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderKey" | "role.key" | "role.kind" | "role.id" | "holderProgram" | "holderProgram.record" | "holderProgram.implementation" | "holderProgram.installation" | "holderProgram.callback">, VObject<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "group" ; holderType: string ; holderKey: string ; holderPermission: string }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"group", "required"> ; holderType: VString<string, "required"> ; holderPermission: VString<string, "required"> }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderType" | "holderKey" | "holderPermission" | "role.key" | "role.kind" | "role.id">], "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderType" | "holderKey" | "holderPermission" | "role.key" | "role.kind" | "role.id" | "holderProgram" | "holderProgram.record" | "holderProgram.implementation" | "holderProgram.installation" | "holderProgram.callback">, { by_holder: ["holderKind", "holderType", "holderKey", "holderPermission", "type", "key", "_creationTime"] ; by_resource: ["type", "key", "holderKind", "role.kind", "role.key", "role.id", "holderKey", "_creationTime"] ; by_role: ["role.kind", "role.key", "role.id", "type", "key", "_creationTime"] ; by_key: ["key", "_creationTime"] }, {}, {}, false, {}> Not exported: an exported type refers to it.

Returns

TableDefinition<VUnion<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "person" ; holderKey: string } | { expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "service" ; holderKey: string } | { reason: undefined | string ; key: string ; type: string ; expiresAt: number ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "program" ; holderKey: string ; holderProgram: { record: string; implementation: string; installation: string; callback: string; } } | { expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "group" ; holderType: string ; holderKey: string ; holderPermission: string }, [VObject<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "person" ; holderKey: string }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"person", "required"> }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderKey" | "role.key" | "role.kind" | "role.id">, VObject<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "service" ; holderKey: string }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"service", "required"> }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderKey" | "role.key" | "role.kind" | "role.id">, VObject<{ reason: undefined | string ; key: string ; type: string ; expiresAt: number ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "program" ; holderKey: string ; holderProgram: { record: string; implementation: string; installation: string; callback: string; } }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"program", "required"> ; expiresAt: VFloat64<number, "required"> ; holderProgram: VObject<{ record: string ; implementation: string ; installation: string ; callback: string }, { installation: VString<string, "required"> ; callback: VString<string, "required"> ; record: VString<string, "required"> ; implementation: VString<string, "required"> }, "required", "record" | "implementation" | "installation" | "callback"> = programGrantRefValidator }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderKey" | "role.key" | "role.kind" | "role.id" | "holderProgram" | "holderProgram.record" | "holderProgram.implementation" | "holderProgram.installation" | "holderProgram.callback">, VObject<{ expiresAt: undefined | number ; reason: undefined | string ; key: string ; type: string ; role: { key: string; kind: “declared”; } | { kind: “tenant”; id: string; } ; holderKind: "group" ; holderType: string ; holderKey: string ; holderPermission: string }, { type: VString<string, "required"> ; key: VString<string, "required"> ; role: VUnion<{ key: string ; kind: "declared" } | { kind: "tenant" ; id: string }, [VObject<{ key: string ; kind: "declared" }, { kind: VLiteral<"declared", "required"> ; key: VString<string, "required"> }, "required", "key" | "kind">, VObject<{ kind: "tenant" ; id: string }, { kind: VLiteral<"tenant", "required"> ; id: VString<string, "required"> }, "required", "kind" | "id">], "required", "key" | "kind" | "id"> ; holderKey: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; reason: VString<undefined | string, "optional"> ; holderKind: VLiteral<"group", "required"> ; holderType: VString<string, "required"> ; holderPermission: VString<string, "required"> }, "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderType" | "holderKey" | "holderPermission" | "role.key" | "role.kind" | "role.id">], "required", "key" | "type" | "expiresAt" | "reason" | "role" | "holderKind" | "holderType" | "holderKey" | "holderPermission" | "role.key" | "role.kind" | "role.id" | "holderProgram" | "holderProgram.record" | "holderProgram.implementation" | "holderProgram.installation" | "holderProgram.callback">, { by_holder: ["holderKind", "holderType", "holderKey", "holderPermission", "type", "key", "_creationTime"] ; by_resource: ["type", "key", "holderKind", "role.kind", "role.key", "role.id", "holderKey", "_creationTime"] ; by_role: ["role.kind", "role.key", "role.id", "type", "key", "_creationTime"] ; by_key: ["key", "_creationTime"] }, {}, {}, false, {}>

requestsTable

▸ requestsTable(assignments, expire): TableDefinition<VObject<{ expiresAt: undefined | number ; comment: undefined | string ; reviewer: undefined | string ; assignmentId: undefined | string ; reviewerLabel: undefined | string ; key: string ; requestId: string ; type: string ; reason: string ; role: string ; updatedAt: number ; status: "pending" | "rejected" | "approved" | "withdrawn" ; acknowledged: boolean ; beneficiary: string ; requester: string ; requesterLabel: string }, { requestId: VString<string, "required"> ; type: VString<string, "required"> ; key: VString<string, "required"> ; role: VString<string, "required"> ; beneficiary: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; requester: VString<string, "required"> ; requesterLabel: VString<string, "required"> ; reason: VString<string, "required"> ; status: VUnion<"pending" | "rejected" | "approved" | "withdrawn", [VLiteral<"pending", "required">, VLiteral<"approved", "required">, VLiteral<"rejected", "required">, VLiteral<"withdrawn", "required">], "required", never> ; acknowledged: VBoolean<boolean, "required"> ; updatedAt: VFloat64<number, "required"> ; reviewer: VString<undefined | string, "optional"> ; reviewerLabel: VString<undefined | string, "optional"> ; comment: VString<undefined | string, "optional"> ; assignmentId: VString<undefined | string, "optional"> }, "required", "key" | "requestId" | "type" | "expiresAt" | "reason" | "role" | "updatedAt" | "status" | "comment" | "reviewer" | "acknowledged" | "assignmentId" | "beneficiary" | "requester" | "requesterLabel" | "reviewerLabel">, { by_status: ["status", "_creationTime"] ; by_requester: ["requester", "status", "_creationTime"] ; by_request: ["requester", "requestId", "_creationTime"] ; by_beneficiary: ["beneficiary", "status", "_creationTime"] ; by_requester_resource: ["requester", "type", "key", "_creationTime"] ; by_beneficiary_resource: ["beneficiary", "type", "key", "_creationTime"] ; by_resource: ["type", "key", "role", "status", "_creationTime"] }, {}, {}, false, {}> Not exported: an exported type refers to it.

Parameters

Name	Type
`assignments`	`string`
`expire`	() => `AssignmentMutation`

Returns

TableDefinition<VObject<{ expiresAt: undefined | number ; comment: undefined | string ; reviewer: undefined | string ; assignmentId: undefined | string ; reviewerLabel: undefined | string ; key: string ; requestId: string ; type: string ; reason: string ; role: string ; updatedAt: number ; status: "pending" | "rejected" | "approved" | "withdrawn" ; acknowledged: boolean ; beneficiary: string ; requester: string ; requesterLabel: string }, { requestId: VString<string, "required"> ; type: VString<string, "required"> ; key: VString<string, "required"> ; role: VString<string, "required"> ; beneficiary: VString<string, "required"> ; expiresAt: VFloat64<undefined | number, "optional"> ; requester: VString<string, "required"> ; requesterLabel: VString<string, "required"> ; reason: VString<string, "required"> ; status: VUnion<"pending" | "rejected" | "approved" | "withdrawn", [VLiteral<"pending", "required">, VLiteral<"approved", "required">, VLiteral<"rejected", "required">, VLiteral<"withdrawn", "required">], "required", never> ; acknowledged: VBoolean<boolean, "required"> ; updatedAt: VFloat64<number, "required"> ; reviewer: VString<undefined | string, "optional"> ; reviewerLabel: VString<undefined | string, "optional"> ; comment: VString<undefined | string, "optional"> ; assignmentId: VString<undefined | string, "optional"> }, "required", "key" | "requestId" | "type" | "expiresAt" | "reason" | "role" | "updatedAt" | "status" | "comment" | "reviewer" | "acknowledged" | "assignmentId" | "beneficiary" | "requester" | "requesterLabel" | "reviewerLabel">, { by_status: ["status", "_creationTime"] ; by_requester: ["requester", "status", "_creationTime"] ; by_request: ["requester", "requestId", "_creationTime"] ; by_beneficiary: ["beneficiary", "status", "_creationTime"] ; by_requester_resource: ["requester", "type", "key", "_creationTime"] ; by_beneficiary_resource: ["beneficiary", "type", "key", "_creationTime"] ; by_resource: ["type", "key", "role", "status", "_creationTime"] }, {}, {}, false, {}>

roleDefinitionsTable

▸ roleDefinitionsTable(): TableDefinition<VObject<{ guests: undefined | boolean ; maxDuration: undefined | number ; reasonRequired: undefined | boolean ; name: string ; type: string ; scope: string ; permissions: string[] }, { scope: VString<string, "required"> ; type: VString<string, "required"> ; name: VString<string, "required"> ; permissions: VArray<string[], VString<string, "required">, "required"> ; maxDuration: VFloat64<undefined | number, "optional"> ; reasonRequired: VBoolean<undefined | boolean, "optional"> ; guests: VBoolean<undefined | boolean, "optional"> }, "required", "name" | "type" | "scope" | "permissions" | "guests" | "maxDuration" | "reasonRequired">, { by_scope: ["scope", "type", "name", "_creationTime"] }, {}, {}, false, {}> Not exported: an exported type refers to it.

Returns

TableDefinition<VObject<{ guests: undefined | boolean ; maxDuration: undefined | number ; reasonRequired: undefined | boolean ; name: string ; type: string ; scope: string ; permissions: string[] }, { scope: VString<string, "required"> ; type: VString<string, "required"> ; name: VString<string, "required"> ; permissions: VArray<string[], VString<string, "required">, "required"> ; maxDuration: VFloat64<undefined | number, "optional"> ; reasonRequired: VBoolean<undefined | boolean, "optional"> ; guests: VBoolean<undefined | boolean, "optional"> }, "required", "name" | "type" | "scope" | "permissions" | "guests" | "maxDuration" | "reasonRequired">, { by_scope: ["scope", "type", "name", "_creationTime"] }, {}, {}, false, {}>

admissionGates

▸ admissionGates<Gates>(gates): Readonly<{ requirements: { readonly [Name in string | number | symbol]: Omit<Gates[Name], “kind”> } ; describe: () => { name: string ; kind: AdmissionGateKind ; permissions: string[] }[] }> Use .requirements in a resource binding or defineAccess declaration. Inspection metadata describes the gate’s owner category, never a verdict about private facts or permission to attempt a business operation.

Type parameters

Name	Type
`Gates`	extends `Readonly`<`Record`<`string`, `AdmissionGate`>>

Parameters

Name	Type
`gates`	`Gates`

Returns

Readonly<{ requirements: { readonly [Name in string | number | symbol]: Omit<Gates[Name], “kind”> } ; describe: () => { name: string ; kind: AdmissionGateKind ; permissions: string[] }[] }>

defineAllowance

▸ defineAllowance(definition): AllowanceDefinition Declare once, then import the same definition in charges and allocations.

Parameters

Name	Type
`definition`	`Object`
`definition.unit`	`string`

Returns

AllowanceDefinition

allowanceKey

▸ allowanceKey(value): string

Parameters

Name	Type
`value`	`AllowanceDefinition` \| `AllowanceReference`

Returns

string

checkedAllocations

▸ checkedAllocations(allocations, fail?): Readonly<Record<string, bigint | "unbounded">> Validate allocations when minting a delegation.

Parameters

Name	Type
`allocations`	`unknown`
`fail`	(`message`: `string`) => `never`

Returns

Readonly<Record<string, bigint | "unbounded">>

applicationAuth

▸ applicationAuth(options): Object Mount the returned handler at basePath/* and /connections/callback in your application’s server. No provider or native refresh grant reaches JS. Cookies hold opaque references; rotation and exact recovery live in Bijection.

Parameters

Name	Type
`options`	`ApplicationAuthServerOptions`

Returns

Object

Name	Type
`handle`	(`request`: `Request`) => `Promise`<`Response`>

reviewAuthIsolation

▸ reviewAuthIsolation(config, forbidden): { name: string = test.name; issuer: string = test.issuer; audiences: string[] ; outcome: "overlapping" | "isolated" ; matchingProviders: number[] ; evidence: "resolvedConfiguration" }[] Evaluate resolved issuer/audience admission. This is a configuration review, independently of whether a token has a valid signature or current lifetime.

Parameters

Name	Type
`config`	`Pick`<`ApplicationAuthConfig`, `"providers"`>
`forbidden`	readonly `AuthenticationIsolationCase`[]

Returns

{ name: string = test.name; issuer: string = test.issuer; audiences: string[] ; outcome: "overlapping" | "isolated" ; matchingProviders: number[] ; evidence: "resolvedConfiguration" }[]

isolateAuthentication

▸ isolateAuthentication<T>(config, forbidden): T Use as the default export of auth.config.ts so normal deployment analysis refuses an issuer/audience overlap with the declared unwanted contexts.

Type parameters

Name	Type
`T`	extends `Pick`<`ApplicationAuthConfig`, `"providers"`>

Parameters

Name	Type
`config`	`T`
`forbidden`	readonly `AuthenticationIsolationCase`[]

Returns

T

identityAdmin

▸ identityAdmin(options): Object Server-only native identity administration. Keep the deployment key in private server custody and retain the exact control across an unknown result.

Parameters

Name	Type
`options`	`Object`
`options.deploymentUrl`	`string`
`options.adminKey`	`string`
`options.fetch?`	typeof `fetch`

Returns

Object

Name	Type
`control`	(`request`: `ApplicationSessionControl`) => `Promise`<`ApplicationSessionControlReceipt`>
`sessions`	(`principal`: `string`) => `Promise`<`ApplicationSessionInventory`>
`receipt`	(`principal`: `string`, `requestId`: `string`) => `Promise`<`ApplicationSessionEnd`>

applicationSignInClients

▸ applicationSignInClients(_ctx): Promise<{ sourceId: string ; issuer: string ; clientId: string ; revision: string ; digest: string }[]> Public installed client facts, under the native login policy’s tracked revisions. A registration proves configuration, never provider health.

Parameters

Name	Type
`_ctx`	`AccessCtx`

Returns

Promise<{ sourceId: string ; issuer: string ; clientId: string ; revision: string ; digest: string }[]>

defineAuditEvents

▸ defineAuditEvents<Events>(events): Readonly<{ definitions: AuditEventDefinitions ; describe: () => { resources: string[] ; metadata: ValidatorJSON ; name: string ; digest: string }[] ; record: <Name>(access: object, _ctx: AccessCtx, resource: AccessResourceRef, name: Name, metadata: Infer<Events[Name]["metadata"]>) => Promise<void> }> Install .definitions in defineSchema({ … }, { auditEvents }). Runtime recording selects the installed contract; native attribution remains separate from application-authored metadata.

Type parameters

Name	Type
`Events`	extends `Record`<`string`, `AuditEventDeclaration`>

Parameters

Name	Type
`events`	`Events`

Returns

Readonly<{ definitions: AuditEventDefinitions ; describe: () => { resources: string[] ; metadata: ValidatorJSON ; name: string ; digest: string }[] ; record: <Name>(access: object, _ctx: AccessCtx, resource: AccessResourceRef, name: Name, metadata: Infer<Events[Name]["metadata"]>) => Promise<void> }>

defineAuditSubscriptions

▸ defineAuditSubscriptions(input): Object Customer-owned journal subscriptions reuse native service grants, scoped reads and command delivery. Install all three tables and exact writer functions; a destination is an installed command/binding, never a URL. The current governing query re-opens and hashes the journal body at every send, retaining native source/key fences through physical dispatch.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.table`	`string`
`input.batchesTable`	`string`
`input.requestsTable`	`string`
`input.access`	`object`
`input.ownerTable`	`string`
`input.ownerType`	`string`
`input.resource`	`AccessResource`<`any`, `any`, `any`>
`input.batchResource`	`AccessResource`<`any`, `any`, `any`>
`input.requestResource`	`AccessResource`<`any`, `any`, `any`>
`input.service`	`string`
`input.deliveryRole`	`string`
`input.destinations`	`Readonly`<`Record`<`string`, `Destination`>>

Returns

Object

Name	Type
`table`	`any`
`batches`	`any`
`requests`	`any`
`functions`	{ `read`: `RegisteredQuery`<`"internal"`, { `cursor`: `null` \| `string` ; `limit`: `number` ; `subscriptionId`: `string` }, `Promise`<`ResourceAuditPage`>> ; `create`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `owner`: `string` ; `destination`: `string` ; `fromMs`: `number` }, `Promise`<{ `subscriptionId`: `any` ; `revision`: `bigint` }>> ; `change`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `action`: `"revoke"` \| `"resume"` \| `"pause"` \| `"discard"` ; `expectedRevision`: `bigint` ; `subscriptionId`: `string` }, `Promise`<{ `subscriptionId`: `any` = row._id; `revision`: `any` = patch.revision }>> ; `prepare`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `subscriptionId`: `string` }, `Promise`<{ `batchId`: `any` = batch._id; `revision`: `any` = batch.revision; `settled`: `any` = batch.settled; `command`: `Value` } \| { `kind`: `string` = coverage }>> ; `settle`: `RegisteredMutation`<`"internal"`, { `subscriptionId`: `string` }, `Promise`<{ `kind`: `string` = “idle”; `observation`: `undefined` ; `batchId?`: `undefined` = batch._id } \| { `kind`: `string` = “pending”; `observation`: `null` \| { `revision`: `number` ; `recovery`: { next: “none” \| “send” \| “interpret” \| “publish” \| “wait” \| “reconcile” \| “attention”; reason: “attemptInFlight” \| “attemptNotDispatched” \| “providerOutcomeUnknown” \| “sendWindowExpired” \| … 10 more … \| null; nextAtMs: number \| null; } ; `delivery`: { phase: “uncertain” \| “blocked” \| “refused” \| “pending” \| “cancelled” \| “held” \| “delivered” \| “queued” \| “dispatching” \| “notApplied” \| “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” \| … 1 more … \| “unsettled”; } ; `execution`: { authorityRevoked: boolean; cancelRequested: boolean; } ; `publication`: `"none"` \| `"blocked"` \| `"running"` \| `"pending"` \| `"complete"` ; `effect`: `"unknown"` \| `"applied"` \| `"notApplied"` \| `"duplicated"` ; `canSubmit`: `boolean` ; `recoverUntil`: `number` } ; `batchId?`: `undefined` = batch._id } \| { `observation`: `undefined` ; `kind`: `string` = “settled”; `batchId`: `any` = batch._id }>> ; `governing`: `RegisteredQuery`<`"internal"`, `any`, `Promise`<(`null` \| { `validUntil`: `any` = assignment.expiresAt })[]>> }
`functions.read`	`RegisteredQuery`<`"internal"`, { `cursor`: `null` \| `string` ; `limit`: `number` ; `subscriptionId`: `string` }, `Promise`<`ResourceAuditPage`>>
`functions.create`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `owner`: `string` ; `destination`: `string` ; `fromMs`: `number` }, `Promise`<{ `subscriptionId`: `any` ; `revision`: `bigint` }>>
`functions.change`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `action`: `"revoke"` \| `"resume"` \| `"pause"` \| `"discard"` ; `expectedRevision`: `bigint` ; `subscriptionId`: `string` }, `Promise`<{ `subscriptionId`: `any` = row._id; `revision`: `any` = patch.revision }>>
`functions.prepare`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `subscriptionId`: `string` }, `Promise`<{ `batchId`: `any` = batch._id; `revision`: `any` = batch.revision; `settled`: `any` = batch.settled; `command`: `Value` } \| { `kind`: `string` = coverage }>>
`functions.settle`	`RegisteredMutation`<`"internal"`, { `subscriptionId`: `string` }, `Promise`<{ `kind`: `string` = “idle”; `observation`: `undefined` ; `batchId?`: `undefined` = batch._id } \| { `kind`: `string` = “pending”; `observation`: `null` \| { `revision`: `number` ; `recovery`: { next: “none” \| “send” \| “interpret” \| “publish” \| “wait” \| “reconcile” \| “attention”; reason: “attemptInFlight” \| “attemptNotDispatched” \| “providerOutcomeUnknown” \| “sendWindowExpired” \| … 10 more … \| null; nextAtMs: number \| null; } ; `delivery`: { phase: “uncertain” \| “blocked” \| “refused” \| “pending” \| “cancelled” \| “held” \| “delivered” \| “queued” \| “dispatching” \| “notApplied” \| “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” \| … 1 more … \| “unsettled”; } ; `execution`: { authorityRevoked: boolean; cancelRequested: boolean; } ; `publication`: `"none"` \| `"blocked"` \| `"running"` \| `"pending"` \| `"complete"` ; `effect`: `"unknown"` \| `"applied"` \| `"notApplied"` \| `"duplicated"` ; `canSubmit`: `boolean` ; `recoverUntil`: `number` } ; `batchId?`: `undefined` = batch._id } \| { `observation`: `undefined` ; `kind`: `string` = “settled”; `batchId`: `any` = batch._id }>>
`functions.governing`	`RegisteredQuery`<`"internal"`, `any`, `Promise`<(`null` \| { `validUntil`: `any` = assignment.expiresAt })[]>>
`endpoints`	{ `create`: `RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>> ; `change`: `RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>> ; `prepare`: `RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>> ; `settle`: `RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>> ; `tick`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `subscriptionId`: `string` }, `Promise`<`any`>> ; `inspect`: `RegisteredQuery`<`"public"`, { `subscriptionId`: `string` }, `Promise`<{ `subscriptionId`: `any` = row._id; `owner`: `any` = row.owner; `destination`: `any` = row.destination; `revision`: `any` = row.revision; `state`: `any` = row.state; `definitionCurrent`: `boolean` ; `coverage`: `any` = row.coverage; `fromMs`: `any` = row.fromMs; `snapshotRevision`: `any` = row.snapshotRevision; `earliestRecordingTimeMs`: `any` = row.earliestRecordingTimeMs; `settledCursor`: `any` = row.cursor; `pending`: `null` \| { `batchId`: `any` = batch._id; `revision`: `any` = batch.revision; `settled`: `any` = batch.settled; `command`: `Value` ; `observation`: `null` \| { `revision`: `number` ; `recovery`: { next: “none” \| “send” \| “interpret” \| “publish” \| “wait” \| “reconcile” \| “attention”; reason: “attemptInFlight” \| “attemptNotDispatched” \| “providerOutcomeUnknown” \| “sendWindowExpired” \| … 10 more … \| null; nextAtMs: number \| null; } ; `delivery`: { phase: “uncertain” \| “blocked” \| “refused” \| “pending” \| “cancelled” \| “held” \| “delivered” \| “queued” \| “dispatching” \| “notApplied” \| “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” \| … 1 more … \| “unsettled”; } ; `execution`: { authorityRevoked: boolean; cancelRequested: boolean; } ; `publication`: `"none"` \| `"blocked"` \| `"running"` \| `"pending"` \| `"complete"` ; `effect`: `"unknown"` \| `"applied"` \| `"notApplied"` \| `"duplicated"` ; `canSubmit`: `boolean` ; `recoverUntil`: `number` } } }>> ; `recover`: `RegisteredQuery`<`"public"`, { `requestId`: `string` ; `owner`: `string` ; `destination`: `string` ; `fromMs`: `number` } \| { `requestId`: `string` ; `action`: `"revoke"` \| `"resume"` \| `"pause"` \| `"discard"` ; `expectedRevision`: `bigint` ; `subscriptionId`: `string` }, `Promise`<`null` \| { `subscriptionId`: `any` ; `revision`: `bigint` }>> }
`endpoints.create`	`RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>>
`endpoints.change`	`RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>>
`endpoints.prepare`	`RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>>
`endpoints.settle`	`RegisteredMutation`<`"public"`, `any`, `Promise`<`any`>>
`endpoints.tick`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `subscriptionId`: `string` }, `Promise`<`any`>>
`endpoints.inspect`	`RegisteredQuery`<`"public"`, { `subscriptionId`: `string` }, `Promise`<{ `subscriptionId`: `any` = row._id; `owner`: `any` = row.owner; `destination`: `any` = row.destination; `revision`: `any` = row.revision; `state`: `any` = row.state; `definitionCurrent`: `boolean` ; `coverage`: `any` = row.coverage; `fromMs`: `any` = row.fromMs; `snapshotRevision`: `any` = row.snapshotRevision; `earliestRecordingTimeMs`: `any` = row.earliestRecordingTimeMs; `settledCursor`: `any` = row.cursor; `pending`: `null` \| { `batchId`: `any` = batch._id; `revision`: `any` = batch.revision; `settled`: `any` = batch.settled; `command`: `Value` ; `observation`: `null` \| { `revision`: `number` ; `recovery`: { next: “none” \| “send” \| “interpret” \| “publish” \| “wait” \| “reconcile” \| “attention”; reason: “attemptInFlight” \| “attemptNotDispatched” \| “providerOutcomeUnknown” \| “sendWindowExpired” \| … 10 more … \| null; nextAtMs: number \| null; } ; `delivery`: { phase: “uncertain” \| “blocked” \| “refused” \| “pending” \| “cancelled” \| “held” \| “delivered” \| “queued” \| “dispatching” \| “notApplied” \| “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” \| … 1 more … \| “unsettled”; } ; `execution`: { authorityRevoked: boolean; cancelRequested: boolean; } ; `publication`: `"none"` \| `"blocked"` \| `"running"` \| `"pending"` \| `"complete"` ; `effect`: `"unknown"` \| `"applied"` \| `"notApplied"` \| `"duplicated"` ; `canSubmit`: `boolean` ; `recoverUntil`: `number` } } }>>
`endpoints.recover`	`RegisteredQuery`<`"public"`, { `requestId`: `string` ; `owner`: `string` ; `destination`: `string` ; `fromMs`: `number` } \| { `requestId`: `string` ; `action`: `"revoke"` \| `"resume"` \| `"pause"` \| `"discard"` ; `expectedRevision`: `bigint` ; `subscriptionId`: `string` }, `Promise`<`null` \| { `subscriptionId`: `any` ; `revision`: `bigint` }>>

assertAuthorization

▸ assertAuthorization<Args>(authorize, ...args): Promise<void> Run an authorization assertion. Denial throws; returned values never grant access.

Type parameters

Name	Type
`Args`	extends `unknown`[]

Parameters

Name	Type
`authorize`	(…`args`: `Args`) => `void` \| `Promise`<`void`>
`...args`	`Args`

Returns

Promise<void>

automationCredentials

▸ automationCredentials(access): Readonly<{ create: (_ctx: AccessCtx, resource: AccessResourceRef, input: { service: string ; permissions: readonly string[] ; label: string ; expiresAt: number ; requestId: string ; functions?: readonly string[] ; participation?: string }) => Promise<{ credential: string ; secret: string | null ; created: boolean }> ; list: (_ctx: AccessCtx, resource: AccessResourceRef) => Promise<{ credentials: AutomationCredential[] }> ; rotate: (_ctx: AccessCtx, credential: string, input: { label: string ; expiresAt: number ; overlapMs: number ; requestId: string }) => Promise<{ credential: string ; secret: string | null ; created: boolean ; predecessor: string ; overlapUntil: number }> ; usage: (ctx: AccessCtx, resource: AccessResourceRef, input: { credential: string ; limit: number ; cursor?: string | null ; from?: number ; to?: number }) => Promise<{ items: { id: string ; revision: string ; recordedAtMs: number ; source: string ; outcome: "refused" | "observed" | "committed" | "execution_failed" | "authorized" ; observed_at_ms: number ; request_id: null | string ; function: null | string ; actor: null | Record<string, Value> ; body: Value }[] = observations; latestAuthenticationInPage: null | number ; coverage: { authentication: "nativeCustomerSecretPresentations" ; authorizedUse: "notCollected" ; range: "retainedJournalPage" ; complete: boolean = !page.hasMore } ; cursor: null | string ; hasMore: boolean ; retentionDays: number ; earliestRecordingTimeMs: number ; snapshotRevision: string }> ; revoke: (_ctx: AccessCtx, credential: string) => Promise<{ credential: string ; revoked: boolean }> ; functions: { create: RegisteredMutation<"public", { participation: undefined | string ; functions: undefined | string[] ; requestId: string ; resource: { key: string; type: string; } ; service: string ; expiresAt: number ; label: string ; permissions: string[] }, Promise<{ credential: string ; secret: null | string ; created: boolean }>> ; list: RegisteredQuery<"public", { resource: { key: string; type: string; } }, Promise<{ credentials: AutomationCredential[] }>> ; rotate: RegisteredMutation<"public", { requestId: string ; credential: string ; expiresAt: number ; label: string ; overlapMs: number }, Promise<{ credential: string ; secret: null | string ; created: boolean ; predecessor: string ; overlapUntil: number }>> ; usage: RegisteredQuery<"public", { cursor: undefined | null | string ; from: undefined | number ; to: undefined | number ; resource: { key: string; type: string; } ; credential: string ; limit: number }, Promise<{ items: { id: string ; revision: string ; recordedAtMs: number ; source: string ; outcome: "refused" | "observed" | "committed" | "execution_failed" | "authorized" ; observed_at_ms: number ; request_id: null | string ; function: null | string ; actor: null | Record<string, Value> ; body: Value }[] = observations; latestAuthenticationInPage: null | number ; coverage: { authentication: "nativeCustomerSecretPresentations" ; authorizedUse: "notCollected" ; range: "retainedJournalPage" ; complete: boolean = !page.hasMore } ; cursor: null | string ; hasMore: boolean ; retentionDays: number ; earliestRecordingTimeMs: number ; snapshotRevision: string }>> ; revoke: RegisteredMutation<"public", { credential: string }, Promise<{ credential: string ; revoked: boolean }>> } }> Customer-owned automation uses deployment-minted service secrets under native permission/resource restrictions. A retry recovers the original ID; the secret is returned only once.

Parameters

Name	Type
`access`	`object`

Returns

Readonly<{ create: (_ctx: AccessCtx, resource: AccessResourceRef, input: { service: string ; permissions: readonly string[] ; label: string ; expiresAt: number ; requestId: string ; functions?: readonly string[] ; participation?: string }) => Promise<{ credential: string ; secret: string | null ; created: boolean }> ; list: (_ctx: AccessCtx, resource: AccessResourceRef) => Promise<{ credentials: AutomationCredential[] }> ; rotate: (_ctx: AccessCtx, credential: string, input: { label: string ; expiresAt: number ; overlapMs: number ; requestId: string }) => Promise<{ credential: string ; secret: string | null ; created: boolean ; predecessor: string ; overlapUntil: number }> ; usage: (ctx: AccessCtx, resource: AccessResourceRef, input: { credential: string ; limit: number ; cursor?: string | null ; from?: number ; to?: number }) => Promise<{ items: { id: string ; revision: string ; recordedAtMs: number ; source: string ; outcome: "refused" | "observed" | "committed" | "execution_failed" | "authorized" ; observed_at_ms: number ; request_id: null | string ; function: null | string ; actor: null | Record<string, Value> ; body: Value }[] = observations; latestAuthenticationInPage: null | number ; coverage: { authentication: "nativeCustomerSecretPresentations" ; authorizedUse: "notCollected" ; range: "retainedJournalPage" ; complete: boolean = !page.hasMore } ; cursor: null | string ; hasMore: boolean ; retentionDays: number ; earliestRecordingTimeMs: number ; snapshotRevision: string }> ; revoke: (_ctx: AccessCtx, credential: string) => Promise<{ credential: string ; revoked: boolean }> ; functions: { create: RegisteredMutation<"public", { participation: undefined | string ; functions: undefined | string[] ; requestId: string ; resource: { key: string; type: string; } ; service: string ; expiresAt: number ; label: string ; permissions: string[] }, Promise<{ credential: string ; secret: null | string ; created: boolean }>> ; list: RegisteredQuery<"public", { resource: { key: string; type: string; } }, Promise<{ credentials: AutomationCredential[] }>> ; rotate: RegisteredMutation<"public", { requestId: string ; credential: string ; expiresAt: number ; label: string ; overlapMs: number }, Promise<{ credential: string ; secret: null | string ; created: boolean ; predecessor: string ; overlapUntil: number }>> ; usage: RegisteredQuery<"public", { cursor: undefined | null | string ; from: undefined | number ; to: undefined | number ; resource: { key: string; type: string; } ; credential: string ; limit: number }, Promise<{ items: { id: string ; revision: string ; recordedAtMs: number ; source: string ; outcome: "refused" | "observed" | "committed" | "execution_failed" | "authorized" ; observed_at_ms: number ; request_id: null | string ; function: null | string ; actor: null | Record<string, Value> ; body: Value }[] = observations; latestAuthenticationInPage: null | number ; coverage: { authentication: "nativeCustomerSecretPresentations" ; authorizedUse: "notCollected" ; range: "retainedJournalPage" ; complete: boolean = !page.hasMore } ; cursor: null | string ; hasMore: boolean ; retentionDays: number ; earliestRecordingTimeMs: number ; snapshotRevision: string }>> ; revoke: RegisteredMutation<"public", { credential: string }, Promise<{ credential: string ; revoked: boolean }>> } }>

personalCredentials

▸ personalCredentials(access): Readonly<{ create: (_ctx: AccessCtx, resource: AccessResourceRef, input: { service: string ; permissions: readonly string[] ; label: string ; expiresAt: number ; requestId: string ; functions?: readonly string[] ; participation?: string }) => Promise<{ credential: string ; secret: string | null ; created: boolean }> ; list: (_ctx: AccessCtx, resource: AccessResourceRef) => Promise<{ credentials: AutomationCredential[] }> ; rotate: (_ctx: AccessCtx, credential: string, input: { label: string ; expiresAt: number ; overlapMs: number ; requestId: string }) => Promise<{ credential: string ; secret: string | null ; created: boolean ; predecessor: string ; overlapUntil: number }> ; usage: (ctx: AccessCtx, resource: AccessResourceRef, input: { credential: string ; limit: number ; cursor?: string | null ; from?: number ; to?: number }) => Promise<{ items: { id: string ; revision: string ; recordedAtMs: number ; source: string ; outcome: "refused" | "observed" | "committed" | "execution_failed" | "authorized" ; observed_at_ms: number ; request_id: null | string ; function: null | string ; actor: null | Record<string, Value> ; body: Value }[] = observations; latestAuthenticationInPage: null | number ; coverage: { authentication: "nativeCustomerSecretPresentations" ; authorizedUse: "notCollected" ; range: "retainedJournalPage" ; complete: boolean = !page.hasMore } ; cursor: null | string ; hasMore: boolean ; retentionDays: number ; earliestRecordingTimeMs: number ; snapshotRevision: string }> ; revoke: (_ctx: AccessCtx, credential: string) => Promise<{ credential: string ; revoked: boolean }> ; functions: { create: RegisteredMutation<"public", { participation: undefined | string ; functions: undefined | string[] ; requestId: string ; resource: { key: string; type: string; } ; service: string ; expiresAt: number ; label: string ; permissions: string[] }, Promise<{ credential: string ; secret: null | string ; created: boolean }>> ; list: RegisteredQuery<"public", { resource: { key: string; type: string; } }, Promise<{ credentials: AutomationCredential[] }>> ; rotate: RegisteredMutation<"public", { requestId: string ; credential: string ; expiresAt: number ; label: string ; overlapMs: number }, Promise<{ credential: string ; secret: null | string ; created: boolean ; predecessor: string ; overlapUntil: number }>> ; usage: RegisteredQuery<"public", { cursor: undefined | null | string ; from: undefined | number ; to: undefined | number ; resource: { key: string; type: string; } ; credential: string ; limit: number }, Promise<{ items: { id: string ; revision: string ; recordedAtMs: number ; source: string ; outcome: "refused" | "observed" | "committed" | "execution_failed" | "authorized" ; observed_at_ms: number ; request_id: null | string ; function: null | string ; actor: null | Record<string, Value> ; body: Value }[] = observations; latestAuthenticationInPage: null | number ; coverage: { authentication: "nativeCustomerSecretPresentations" ; authorizedUse: "notCollected" ; range: "retainedJournalPage" ; complete: boolean = !page.hasMore } ; cursor: null | string ; hasMore: boolean ; retentionDays: number ; earliestRecordingTimeMs: number ; snapshotRevision: string }>> ; revoke: RegisteredMutation<"public", { credential: string }, Promise<{ credential: string ; revoked: boolean }>> } }> Durable personal access retains live participation and the person’s current authority, independently of browser sign-in. It supplies no provider claims or human authentication assurance.

Parameters

Name	Type
`access`	`object`

Returns

defineBillableParticipation

▸ defineBillableParticipation(input): Object Retains one exact meter report and its original native command. The count comes only from an installed query. Install table/state and export functions under module; current report and meter policy still authorize every send.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.reportsTable`	`string`
`input.stateTable`	`string`
`input.resource`	`AccessResource`<`any`, `any`, `any`>
`input.stateResource`	`AccessResource`<`any`, `any`, `any`>
`input.ownerTable`	`string`
`input.permission`	`string`
`input.population`	`FunctionReference`<`"query"`, `"internal"`, { `owner`: `string` }, typeof `type`>
`input.command`	`CommandHandle`<{ `value`: `string` ; `timestamp`: `number` ; `reportId`: `string` ; `reportDigest`: `string` }, `"resource"`>
`input.target`	`FunctionReference`<`"query"`, `"internal"`, { `owner`: `string` }, { `bindingId`: `string` }>

Returns

Object

Name	Type
`table`	`any`
`state`	`any`
`functions`	{ `report`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<{ `value`: `string` ; `command`: { kind: “command”; sourceId: SourceId \| null; requestId: RequestId; command: { integration: { module: string; export: string; }; command: string; version: 1; }; request: string; recoverUntil: number; } ; `timestamp`: `number` ; `reportId`: `GenericId`<`string`> ; `reportDigest`: `string` }>> }
`functions.report`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<{ `value`: `string` ; `command`: { kind: “command”; sourceId: SourceId \| null; requestId: RequestId; command: { integration: { module: string; export: string; }; command: string; version: 1; }; request: string; recoverUntil: number; } ; `timestamp`: `number` ; `reportId`: `GenericId`<`string`> ; `reportDigest`: `string` }>>
`endpoints`	{ `report`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<`any`>> ; `receipt`: `RegisteredQuery`<`"public"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<`null` \| { `value`: `string` ; `command`: { kind: “command”; sourceId: SourceId \| null; requestId: RequestId; command: { integration: { module: string; export: string; }; command: string; version: 1; }; request: string; recoverUntil: number; } ; `timestamp`: `number` ; `reportId`: `GenericId`<`string`> ; `reportDigest`: `string` }>> ; `status`: `RegisteredQuery`<`"public"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<`null` \| { `value`: `string` ; `command`: { `kind`: `"command"` ; `sourceId`: `null` \| `SourceId` ; `requestId`: `RequestId` ; `command`: { integration: { module: string; export: string; }; command: string; version: 1; } ; `request`: `string` ; `recoverUntil`: `number` } ; `timestamp`: `number` ; `reportId`: `GenericId`<`string`> ; `reportDigest`: `string` ; `observation`: `null` \| { `revision`: `number` ; `recovery`: { next: “none” \| “send” \| “interpret” \| “publish” \| “wait” \| “reconcile” \| “attention”; reason: “attemptInFlight” \| “attemptNotDispatched” \| “providerOutcomeUnknown” \| “sendWindowExpired” \| … 10 more … \| null; nextAtMs: number \| null; } ; `delivery`: { phase: “uncertain” \| “blocked” \| “refused” \| “pending” \| “cancelled” \| “held” \| “delivered” \| “queued” \| “dispatching” \| “notApplied” \| “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” \| … 1 more … \| “unsettled”; } ; `execution`: { authorityRevoked: boolean; cancelRequested: boolean; } ; `publication`: `"none"` \| `"blocked"` \| `"running"` \| `"pending"` \| `"complete"` ; `effect`: `"unknown"` \| `"applied"` \| `"notApplied"` \| `"duplicated"` ; `canSubmit`: `boolean` ; `recoverUntil`: `number` } }>> }
`endpoints.report`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<`any`>>
`endpoints.receipt`	`RegisteredQuery`<`"public"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<`null` \| { `value`: `string` ; `command`: { kind: “command”; sourceId: SourceId \| null; requestId: RequestId; command: { integration: { module: string; export: string; }; command: string; version: 1; }; request: string; recoverUntil: number; } ; `timestamp`: `number` ; `reportId`: `GenericId`<`string`> ; `reportDigest`: `string` }>>
`endpoints.status`	`RegisteredQuery`<`"public"`, { `requestId`: `string` ; `owner`: `string` }, `Promise`<`null` \| { `value`: `string` ; `command`: { `kind`: `"command"` ; `sourceId`: `null` \| `SourceId` ; `requestId`: `RequestId` ; `command`: { integration: { module: string; export: string; }; command: string; version: 1; } ; `request`: `string` ; `recoverUntil`: `number` } ; `timestamp`: `number` ; `reportId`: `GenericId`<`string`> ; `reportDigest`: `string` ; `observation`: `null` \| { `revision`: `number` ; `recovery`: { next: “none” \| “send” \| “interpret” \| “publish” \| “wait” \| “reconcile” \| “attention”; reason: “attemptInFlight” \| “attemptNotDispatched” \| “providerOutcomeUnknown” \| “sendWindowExpired” \| … 10 more … \| null; nextAtMs: number \| null; } ; `delivery`: { phase: “uncertain” \| “blocked” \| “refused” \| “pending” \| “cancelled” \| “held” \| “delivered” \| “queued” \| “dispatching” \| “notApplied” \| “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” \| … 1 more … \| “unsettled”; } ; `execution`: { authorityRevoked: boolean; cancelRequested: boolean; } ; `publication`: `"none"` \| `"blocked"` \| `"running"` \| `"pending"` \| `"complete"` ; `effect`: `"unknown"` \| `"applied"` \| `"notApplied"` \| `"duplicated"` ; `canSubmit`: `boolean` ; `recoverUntil`: `number` } }>>
`governing`	`RegisteredQuery`<`"internal"`, `any`, `Promise`<`any`[]>>

componentAccessPolicyFor

▸ componentAccessPolicyFor<Kind>(...kinds): ComponentAccessPolicy<Kind> A package-owned access contract whose handlers see only these resource kinds. A decision about any other kind refuses before the handler runs.

Type parameters

Name	Type
`Kind`	extends `string`

Parameters

Name	Type
`...kinds`	readonly `Kind`[]

Returns

ComponentAccessPolicy<Kind>

exposeFunctions

▸ exposeFunctions<T>(registrations, metadata): T Publish the ordinary public functions returned by a component’s root application helper. Internal helpers and native operation doors keep their own declarations. The supplied admission is shared, never a new policy.

Type parameters

Name	Type
`T`	extends `object`

Parameters

Name	Type
`registrations`	`T`
`metadata`	`Pick`<`DiscoveryDefinition`, `"admission"` \| `"appliesDelegation"`>

Returns

T

domainName

▸ domainName(value): string

Parameters

Name	Type
`value`	`string`

Returns

string

domainRoutingResources

▸ domainRoutingResources<Owner>(owner?): Object Public discovery contains only deliberately published route descriptors. Claims remain private children of their actual organization.

Type parameters

Name	Type
`Owner`	extends `string` = `"organization"`

Parameters

Name	Type
`owner`	`Owner`

Returns

Object

Name	Type
`domainClaim`	{ `parent`: `Owner` = owner; `permissions`: [`"read"`, `"create"`, `"manage"`] }
`domainClaim.parent`	`Owner`
`domainClaim.permissions`	[`"read"`, `"create"`, `"manage"`]
`signInRoute`	{ `permissions`: [`"read"`, `"create"`, `"manage"`] ; `audience`: { `read`: `"public"` = “public”; `create`: `"public"` = “public”; `manage`: `"public"` = “public” } }
`signInRoute.permissions`	[`"read"`, `"create"`, `"manage"`]
`signInRoute.audience`	{ `read`: `"public"` = “public”; `create`: `"public"` = “public”; `manage`: `"public"` = “public” }
`signInRoute.audience.read`	`"public"`
`signInRoute.audience.create`	`"public"`
`signInRoute.audience.manage`	`"public"`
`domainRequest`	{ `parent`: `"domainClaim"` = “domainClaim”; `permissions`: [`"read"`, `"create"`] }
`domainRequest.parent`	`"domainClaim"`
`domainRequest.permissions`	[`"read"`, `"create"`]

defineDomainRouting

▸ defineDomainRouting(input): Object Install claims, routes and exact internal exports. DNS is read in an action; only its internal recorder can publish evidence. The recorder rechecks the original challenge, actor, revision and current owner permission. Routes are explicit publications and cannot grant an assignment or admit an identity. The same domain may have multiple owners and multiple routes.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.claimsTable`	`string`
`input.routesTable`	`string`
`input.requestsTable`	`string`
`input.ownerType`	`string`
`input.owner`	`GenericValidator`
`input.permission`	`string`
`input.claimResource`	`AccessResource`<`any`, `any`, `any`>
`input.routeResource`	`AccessResource`<`any`, `any`, `any`>
`input.requestResource`	`AccessResource`<`any`, `any`, `any`>
`input.clients`	`Readonly`<`Record`<`string`, { `issuer`: `string` ; `clientId`: `string` }>>

Returns

Object

Name	Type
`claims`	`TableDefinition`<`VObject`<{ `owner`: `any` ; `requestId`: `string` ; `expiresAt`: `number` ; `revision`: `bigint` ; `actor`: `string` ; `observedAt`: `number` ; `token`: `string` ; `domain`: `string` ; `verifiedUntil`: `number` }, { `owner`: `GenericValidator` = input.owner; `domain`: `VString`<`string`, `"required"`> ; `token`: `VString`<`string`, `"required"`> ; `revision`: `VInt64`<`bigint`, `"required"`> ; `actor`: `VString`<`string`, `"required"`> ; `requestId`: `VString`<`string`, `"required"`> ; `expiresAt`: `VFloat64`<`number`, `"required"`> ; `verifiedUntil`: `VFloat64`<`number`, `"required"`> ; `observedAt`: `VFloat64`<`number`, `"required"`> }, `"required"`, `"requestId"` \| `"expiresAt"` \| `"owner"` \| `"revision"` \| `"actor"` \| `"observedAt"` \| `"token"` \| `"domain"` \| `owner.${any}` \| `"verifiedUntil"`>, { `by_owner`: [`"owner"`, `"_creationTime"`] ; `by_request`: [`"owner"`, `"requestId"`, `"_creationTime"`] }, {}, {}, `false`, {}> & { `isWriterOwned`: `true` } & `AccessTableBinding`<`AccessResource`<`any`, `any`, `any`, `AccessDefinitionInput`>, `any`>
`routes`	`TableDefinition`<`VObject`<{ `claim`: `GenericId`<`string`> ; `owner`: `string` ; `revision`: `bigint` ; `issuer`: `string` ; `clientId`: `string` ; `domain`: `string` ; `enabled`: `boolean` ; `client`: `string` ; `providerOrganization`: `null` \| `string` ; `verifiedUntil`: `number` }, { `owner`: `VString`<`string`, `"required"`> ; `claim`: `VId`<`GenericId`<`string`>, `"required"`> ; `domain`: `VString`<`string`, `"required"`> ; `client`: `VString`<`string`, `"required"`> ; `issuer`: `VString`<`string`, `"required"`> ; `clientId`: `VString`<`string`, `"required"`> ; `providerOrganization`: `VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`> ; `enabled`: `VBoolean`<`boolean`, `"required"`> ; `verifiedUntil`: `VFloat64`<`number`, `"required"`> ; `revision`: `VInt64`<`bigint`, `"required"`> }, `"required"`, `"claim"` \| `"owner"` \| `"revision"` \| `"issuer"` \| `"clientId"` \| `"domain"` \| `"enabled"` \| `"client"` \| `"providerOrganization"` \| `"verifiedUntil"`>, { `by_domain`: [`"domain"`, `"_creationTime"`] ; `by_claim_client`: [`"claim"`, `"client"`, `"_creationTime"`] ; `by_claim`: [`"claim"`, `"_creationTime"`] }, {}, {}, `false`, {}> & { `isWriterOwned`: `true` } & `AccessTableBinding`<`AccessResource`<`any`, `any`, `any`, `AccessDefinitionInput`>, `any`>
`requests`	`TableDefinition`<`VObject`<{ `requestId`: `string` ; `claim`: `GenericId`<`string`> ; `termsDigest`: `string` ; `resultJson`: `string` }, { `claim`: `VId`<`GenericId`<`string`>, `"required"`> ; `requestId`: `VString`<`string`, `"required"`> ; `termsDigest`: `VString`<`string`, `"required"`> ; `resultJson`: `VString`<`string`, `"required"`> }, `"required"`, `"requestId"` \| `"claim"` \| `"termsDigest"` \| `"resultJson"`>, { `by_claim`: [`"claim"`, `"_creationTime"`] ; `by_request`: [`"claim"`, `"requestId"`, `"_creationTime"`] }, {}, {}, `false`, {}> & { `isWriterOwned`: `true` } & `AccessTableBinding`<`AccessResource`<`any`, `any`, `any`, `AccessDefinitionInput`>, `any`>
`functions`	{ `claim`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `owner`: `string` ; `domain`: `string` }, `Promise`<`any`>> ; `challenge`: `RegisteredQuery`<`"internal"`, { `claimId`: `string` }, `Promise`<`any`>> ; `receipt`: `RegisteredQuery`<`"internal"`, { `requestId`: `string` ; `expectedRevision`: `bigint` ; `claimId`: `string` }, `Promise`<`Value`>> ; `record`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `observedAt`: `number` ; `token`: `string` ; `outcome`: `"unavailable"` \| `"pending"` \| `"verified"` ; `expectedRevision`: `bigint` ; `ttlSeconds`: `number` ; `claimId`: `string` }, `Promise`<`any`>> ; `publish`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `enabled`: `boolean` ; `client`: `string` ; `expectedRevision`: `bigint` ; `providerOrganization`: `null` \| `string` ; `claimId`: `string` }, `Promise`<`any`>> }
`functions.claim`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `owner`: `string` ; `domain`: `string` }, `Promise`<`any`>>
`functions.challenge`	`RegisteredQuery`<`"internal"`, { `claimId`: `string` }, `Promise`<`any`>>
`functions.receipt`	`RegisteredQuery`<`"internal"`, { `requestId`: `string` ; `expectedRevision`: `bigint` ; `claimId`: `string` }, `Promise`<`Value`>>
`functions.record`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `observedAt`: `number` ; `token`: `string` ; `outcome`: `"unavailable"` \| `"pending"` \| `"verified"` ; `expectedRevision`: `bigint` ; `ttlSeconds`: `number` ; `claimId`: `string` }, `Promise`<`any`>>
`functions.publish`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `enabled`: `boolean` ; `client`: `string` ; `expectedRevision`: `bigint` ; `providerOrganization`: `null` \| `string` ; `claimId`: `string` }, `Promise`<`any`>>
`endpoints`	{ `claim`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `owner`: `string` ; `domain`: `string` }, `Promise`<`any`>> ; `inspect`: `RegisteredQuery`<`"public"`, { `claimId`: `string` }, `Promise`<{ `claimId`: `any` = row._id; `domain`: `any` = row.domain; `revision`: `any` = row.revision; `recordName`: `string` ; `recordValue`: `any` = row.token; `expiresAt`: `any` = row.expiresAt; `verifiedUntil`: `any` = row.verifiedUntil }>> ; `verify`: { `isBijectionFunction`: `true` ; `isAction`: `true` } & { `_visibility`: `"public"` } & { `isPublic`: `true` } & { `exportCapabilities`: () => `string` } ; `publish`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `enabled`: `boolean` ; `client`: `string` ; `expectedRevision`: `bigint` ; `providerOrganization`: `null` \| `string` ; `claimId`: `string` }, `Promise`<`any`>> ; `discover`: `RegisteredQuery`<`"public"`, { `domain`: `string` }, `Promise`<{ `kind`: `string` ; `routes`: { `routeId`: `any` = row._id; `sourceId`: `any` = row.client; `clientId`: `any` = row.clientId; `issuer`: `any` = row.issuer; `providerOrganization`: `any` = row.providerOrganization; `validUntil`: `any` = row.verifiedUntil }[] }>> }
`endpoints.claim`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `owner`: `string` ; `domain`: `string` }, `Promise`<`any`>>
`endpoints.inspect`	`RegisteredQuery`<`"public"`, { `claimId`: `string` }, `Promise`<{ `claimId`: `any` = row._id; `domain`: `any` = row.domain; `revision`: `any` = row.revision; `recordName`: `string` ; `recordValue`: `any` = row.token; `expiresAt`: `any` = row.expiresAt; `verifiedUntil`: `any` = row.verifiedUntil }>>
`endpoints.verify`	{ `isBijectionFunction`: `true` ; `isAction`: `true` } & { `_visibility`: `"public"` } & { `isPublic`: `true` } & { `exportCapabilities`: () => `string` }
`endpoints.publish`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `enabled`: `boolean` ; `client`: `string` ; `expectedRevision`: `bigint` ; `providerOrganization`: `null` \| `string` ; `claimId`: `string` }, `Promise`<`any`>>
`endpoints.discover`	`RegisteredQuery`<`"public"`, { `domain`: `string` }, `Promise`<{ `kind`: `string` ; `routes`: { `routeId`: `any` = row._id; `sourceId`: `any` = row.client; `clientId`: `any` = row.clientId; `issuer`: `any` = row.issuer; `providerOrganization`: `any` = row.providerOrganization; `validUntil`: `any` = row.verifiedUntil }[] }>>

applicationAuthentication

▸ applicationAuthentication(_ctx): Promise<AuthenticationCeremony | null> Immutable facts from a successful native provider exchange. A refresh does not create another ceremony or advance authentication time.

Parameters

Name	Type
`_ctx`	`unknown`

Returns

Promise<AuthenticationCeremony | null>

defineEnterpriseAuthentication

▸ defineEnterpriseAuthentication(input): Readonly<{ table: TableDefinition<VObject<{ requestId: string ; owner: string ; validUntil: number ; configurationDigest: string ; definitionDigest: string ; recordedAt: number ; recordedBy: string ; evidenceJson: string }, { owner: Validator<string, "required", any> = input.owner; configurationDigest: VString<string, "required"> ; definitionDigest: VString<string, "required"> ; requestId: VString<string, "required"> ; recordedBy: VString<string, "required"> ; evidenceJson: VString<string, "required"> ; recordedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> }, "required", "requestId" | "owner" | "validUntil" | "configurationDigest" | "definitionDigest" | `owner.${any}` | "recordedAt" | "recordedBy" | "evidenceJson">, { by_owner: ["owner", "_creationTime"] ; by_owner_configuration: ["owner", "configurationDigest", "_creationTime"] ; by_request: ["owner", "requestId", "_creationTime"] }, {}, {}, false, {}> & { isWriterOwned: true } & AccessTableBinding<AccessResource<any, any, any, AccessDefinitionInput>, any> ; definitionDigest: string ; inspectionOwner: () => Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<any>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }> ; functions: { observe: RegisteredMutation<"internal", { owner: string ; configurationDigest: string ; requestId: string }, Promise<{ observation: any = previous._id; recovered: boolean = true }>> ; proof: RegisteredQuery<"internal", { owner: string ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; configurationDigest: string }, Promise<{ configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "blocked" ; reason: string = “No successful native authentication has been observed for this configuration” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "unavailable" ; reason: string = “The authentication observation expired” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "ready" ; reason: null = null }>> } ; endpoints: { observe: RegisteredMutation<"public", { requestId: string ; owner: string ; configurationDigest: string }, Promise<any>> ; status: RegisteredQuery<"public", { owner: string }, Promise<{ tested: boolean ; successful: boolean ; proof: { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "blocked" ; reason: string = “No successful native authentication has been observed for this configuration” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "unavailable" ; reason: string = “The authentication observation expired” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "ready" ; reason: null = null } = current }>> } }> Observed enterprise authentication is application-owned history. The only writer captures native facts itself; no endpoint accepts a caller’s claim that SSO succeeded. Install the table and exact internal writer module.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.table`	`string`
`input.owner`	`Validator`<`string`, `"required"`, `any`>
`input.resource`	`AccessResource`<`any`, `any`, `any`>
`input.configuration`	`FunctionReference`<`"query"`, `any`, { `owner`: `string` }, `Configuration`>
`input.status`	`FunctionReference`<`"query"`, `any`, { `owner`: `string` }, `any`>
`input.method`	{ `kind`: `"provider"` ; `value`: `string` } \| { `kind`: `"oidc"` ; `values`: readonly `string`[] }
`input.maximumAgeMs`	`number`

Returns

Readonly<{ table: TableDefinition<VObject<{ requestId: string ; owner: string ; validUntil: number ; configurationDigest: string ; definitionDigest: string ; recordedAt: number ; recordedBy: string ; evidenceJson: string }, { owner: Validator<string, "required", any> = input.owner; configurationDigest: VString<string, "required"> ; definitionDigest: VString<string, "required"> ; requestId: VString<string, "required"> ; recordedBy: VString<string, "required"> ; evidenceJson: VString<string, "required"> ; recordedAt: VFloat64<number, "required"> ; validUntil: VFloat64<number, "required"> }, "required", "requestId" | "owner" | "validUntil" | "configurationDigest" | "definitionDigest" | `owner.${any}` | "recordedAt" | "recordedBy" | "evidenceJson">, { by_owner: ["owner", "_creationTime"] ; by_owner_configuration: ["owner", "configurationDigest", "_creationTime"] ; by_request: ["owner", "requestId", "_creationTime"] }, {}, {}, false, {}> & { isWriterOwned: true } & AccessTableBinding<AccessResource<any, any, any, AccessDefinitionInput>, any> ; definitionDigest: string ; inspectionOwner: () => Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<any>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }> ; functions: { observe: RegisteredMutation<"internal", { owner: string ; configurationDigest: string ; requestId: string }, Promise<{ observation: any = previous._id; recovered: boolean = true }>> ; proof: RegisteredQuery<"internal", { owner: string ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; configurationDigest: string }, Promise<{ configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "blocked" ; reason: string = “No successful native authentication has been observed for this configuration” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "unavailable" ; reason: string = “The authentication observation expired” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "ready" ; reason: null = null }>> } ; endpoints: { observe: RegisteredMutation<"public", { requestId: string ; owner: string ; configurationDigest: string }, Promise<any>> ; status: RegisteredQuery<"public", { owner: string }, Promise<{ tested: boolean ; successful: boolean ; proof: { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "blocked" ; reason: string = “No successful native authentication has been observed for this configuration” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "unavailable" ; reason: string = “The authentication observation expired” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; validUntil: any ; outcome: "ready" ; reason: null = null } = current }>> } }>

defineEnterpriseProviderProof

▸ defineEnterpriseProviderProof(input): RegisteredQuery<"internal", { owner: string ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; configurationDigest: string }, Promise<{ configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } = facts.source; validUntil: null | number ; outcome: "unavailable" | "blocked" = facts.state; reason: string = “Provider state is not ready” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } = facts.source; validUntil: number ; outcome: "ready" ; reason: null = null }>> Adapt an acquired provider observation to the existing enterprise proof owner. The query is fixed by installed code; proof evaluation does no HTTP. Certificate expiry, source checkpoints and policy enforcement retain their own meaning and deadlines.

Parameters

Name	Type
`input`	`Object`
`input.query`	`FunctionReference`<`"query"`, `any`, { `owner`: `string` }, `Observation`>
`input.kind`	`Observation`[`"kind"`]
`input.maximumAgeMs`	`number`

Returns

RegisteredQuery<"internal", { owner: string ; configuration: { issuer: string; clientId: string; providerOrganization: string; } ; configurationDigest: string }, Promise<{ configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } = facts.source; validUntil: null | number ; outcome: "unavailable" | "blocked" = facts.state; reason: string = “Provider state is not ready” } | { configurationDigest: string = args.configurationDigest; definitionDigest: string ; revision: string ; source: null | { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } = facts.source; validUntil: number ; outcome: "ready" ; reason: null = null }>>

defineEnterpriseSetup

▸ defineEnterpriseSetup(input): Readonly<{ table: SetupTable<TableDefinition<VObject<{ owner: any ; revision: bigint ; configurationDigest: string ; definitionDigest: string ; configurationJson: string ; activationJson: null | string ; lastRequest: string }, { owner: GenericValidator = input.owner; configurationJson: VString<string, "required"> ; configurationDigest: VString<string, "required"> ; definitionDigest: VString<string, "required"> ; revision: VInt64<bigint, "required"> ; activationJson: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; lastRequest: VString<string, "required"> }, "required", "owner" | "revision" | "configurationDigest" | "definitionDigest" | "configurationJson" | "activationJson" | "lastRequest" | `owner.${any}`>, { by_owner: ["owner", "_creationTime"] }, {}, {}, false, {}> & { isWriterOwned: true }, AccessResource<any, any, any, AccessDefinitionInput>> ; requests: SetupTable<TableDefinition<VObject<{ requestId: string ; action: string ; revision: bigint ; setup: GenericId<string> ; termsDigest: string ; recordedAt: number }, { setup: VId<GenericId<string>, "required"> ; requestId: VString<string, "required"> ; termsDigest: VString<string, "required"> ; action: VString<string, "required"> ; revision: VInt64<bigint, "required"> ; recordedAt: VFloat64<number, "required"> }, "required", "requestId" | "action" | "revision" | "setup" | "termsDigest" | "recordedAt">, { by_setup: ["setup", "_creationTime"] ; by_request: ["setup", "requestId", "_creationTime"] }, {}, {}, false, {}> & { isWriterOwned: true }, AccessResource<any, any, any, AccessDefinitionInput>> ; definitionDigest: string ; inspect: (ctx: Pick<ReadContext, "db" | "runQuery">, owner: string) => Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }> ; functions: { status: RegisteredQuery<"public", { owner: any }, Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }>> ; configure: RegisteredMutation<"internal", { owner: any ; configuration: any ; requestId: string ; expectedRevision: bigint }, Promise<{ setup: any = row._id; revision: any ; recovered: boolean = true }>> ; activate: RegisteredMutation<"internal", { owner: any ; requestId: string ; expectedRevision: bigint ; configurationDigest: string }, Promise<{ setup: any = row._id; revision: any ; recovered: boolean = true }>> ; deactivate: RegisteredMutation<"internal", { owner: any ; requestId: string ; expectedRevision: bigint ; configurationDigest: string }, Promise<{ setup: any = row._id; revision: any ; recovered: boolean = true }>> } ; endpoints: { status: RegisteredQuery<"public", { owner: any }, Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }>> ; configure: RegisteredMutation<"public", {}, Promise<any>> ; activate: RegisteredMutation<"public", {}, Promise<any>> ; deactivate: RegisteredMutation<"public", {}, Promise<any>> } ; inspectionOwner: (anchor: FunctionReference<"query", any, { owner: string }, any>) => Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<{ configured: any = status.configured; active: any = status.active; ready: any = status.ready; revision: any ; configurationDigest: any ; definitionDigest: any = status.definitionDigest; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> }>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }> ; requireActive: (ctx: Pick<ReadContext, "db" | "runQuery">, owner: string) => Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }> }> Application-owned enterprise setup. Install both returned tables and export the internal writer functions under the exact configured module. The native committer refuses every other writer, including direct mutations.

Parameters

Name	Type	Description
`input`	`Object`	-
`input.module`	`string`	-
`input.table`	`string`	-
`input.requests`	`string`	-
`input.resource`	`AccessResource`<`any`, `any`, `any`>	-
`input.requestResource`	`AccessResource`<`any`, `any`, `any`>	-
`input.owner`	`GenericValidator`	-
`input.configuration`	`GenericValidator`	-
`input.operationPermissions?`	`Object`	Separate task configuration from activation authority. These are native permissions on the declared owner resource, in addition to table manage. A setup recipient may configure while activation stays with its sponsor.
`input.operationPermissions.resourceType`	`string`	-
`input.operationPermissions.configure`	`string`	-
`input.operationPermissions.activate`	`string`	-
`input.operationPermissions.deactivate`	`string`	-
`input.proofs`	`Readonly`<`Record`<`string`, `FunctionReference`<`"query"`, `any`, { `owner`: `string` ; `configuration`: `Value` ; `configurationDigest`: `string` }, `Proof`>>>	-

Returns

Readonly<{ table: SetupTable<TableDefinition<VObject<{ owner: any ; revision: bigint ; configurationDigest: string ; definitionDigest: string ; configurationJson: string ; activationJson: null | string ; lastRequest: string }, { owner: GenericValidator = input.owner; configurationJson: VString<string, "required"> ; configurationDigest: VString<string, "required"> ; definitionDigest: VString<string, "required"> ; revision: VInt64<bigint, "required"> ; activationJson: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; lastRequest: VString<string, "required"> }, "required", "owner" | "revision" | "configurationDigest" | "definitionDigest" | "configurationJson" | "activationJson" | "lastRequest" | `owner.${any}`>, { by_owner: ["owner", "_creationTime"] }, {}, {}, false, {}> & { isWriterOwned: true }, AccessResource<any, any, any, AccessDefinitionInput>> ; requests: SetupTable<TableDefinition<VObject<{ requestId: string ; action: string ; revision: bigint ; setup: GenericId<string> ; termsDigest: string ; recordedAt: number }, { setup: VId<GenericId<string>, "required"> ; requestId: VString<string, "required"> ; termsDigest: VString<string, "required"> ; action: VString<string, "required"> ; revision: VInt64<bigint, "required"> ; recordedAt: VFloat64<number, "required"> }, "required", "requestId" | "action" | "revision" | "setup" | "termsDigest" | "recordedAt">, { by_setup: ["setup", "_creationTime"] ; by_request: ["setup", "requestId", "_creationTime"] }, {}, {}, false, {}> & { isWriterOwned: true }, AccessResource<any, any, any, AccessDefinitionInput>> ; definitionDigest: string ; inspect: (ctx: Pick<ReadContext, "db" | "runQuery">, owner: string) => Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }> ; functions: { status: RegisteredQuery<"public", { owner: any }, Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }>> ; configure: RegisteredMutation<"internal", { owner: any ; configuration: any ; requestId: string ; expectedRevision: bigint }, Promise<{ setup: any = row._id; revision: any ; recovered: boolean = true }>> ; activate: RegisteredMutation<"internal", { owner: any ; requestId: string ; expectedRevision: bigint ; configurationDigest: string }, Promise<{ setup: any = row._id; revision: any ; recovered: boolean = true }>> ; deactivate: RegisteredMutation<"internal", { owner: any ; requestId: string ; expectedRevision: bigint ; configurationDigest: string }, Promise<{ setup: any = row._id; revision: any ; recovered: boolean = true }>> } ; endpoints: { status: RegisteredQuery<"public", { owner: any }, Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }>> ; configure: RegisteredMutation<"public", {}, Promise<any>> ; activate: RegisteredMutation<"public", {}, Promise<any>> ; deactivate: RegisteredMutation<"public", {}, Promise<any>> } ; inspectionOwner: (anchor: FunctionReference<"query", any, { owner: string }, any>) => Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<{ configured: any = status.configured; active: any = status.active; ready: any = status.ready; revision: any ; configurationDigest: any ; definitionDigest: any = status.definitionDigest; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> }>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }> ; requireActive: (ctx: Pick<ReadContext, "db" | "runQuery">, owner: string) => Promise<{ configured: false ; definitionDigest: string ; active: boolean = false; ready: boolean = false; proofs: {} = {} } | { ready: boolean ; proofs: Record<string, { source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string ; reason: null | string ; validUntil: null | number ; outcome: "unavailable" | "blocked" | "ready" ; configurationDigest: string ; definitionDigest: string }> = observed; configured: true ; setup: any = row._id; revision: any = row.revision; definitionDigest: string ; configurationDigest: any = row.configurationDigest; configuration: Value ; active: boolean ; activation: any }> }>

defineIdentityCorrelation

▸ defineIdentityCorrelation(providers): Readonly<{ resolve: (ctx: Pick<BijectionQueryCtx<any, any>, "auth" | "runQuery">, name: string) => Promise<IdentityCorrelation> ; status: RegisteredQuery<"public", { provider: string }, Promise<IdentityCorrelation>> ; inspectionOwner: (anchor: FunctionReference<"query", any, { provider: string }, IdentityCorrelation>) => Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<{ outcome: "unavailable" | "unmatched" | "matched" | "conflict" = current.kind; people: string[] ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] = current.evidence }>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }> ; request: (ctx: Parameters<typeof resolve>[0], provider: string, review: (person: string, correlation: Extract<IdentityCorrelation, { kind: "matched" }>) => Promise<unknown>) => Promise<{ correlation: { kind: "conflict" ; people: string[] ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] } | { kind: "unmatched" ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] } | { kind: "unavailable" ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] } ; request: null = null } | { correlation: { kind: "matched" ; person: string ; organization: string ; provider: string ; subject: string ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] ; validUntil: number } ; request: unknown }> }> Each installed provider maps verified immutable IDs to an authorized source query. Correlation proposes an association; reviewed identity linking keeps ownership of the actual decision. Emails establish no association.

Parameters

Name	Type
`providers`	`Readonly`<`Record`<`string`, { `issuer`: `string` ; `organizationClaim`: `string` ; `query`: `FunctionReference`<`"query"`, `any`, { `organization`: `string` ; `provider`: `string` ; `subject`: `string` }, `Population`> }>>

Returns

Readonly<{ resolve: (ctx: Pick<BijectionQueryCtx<any, any>, "auth" | "runQuery">, name: string) => Promise<IdentityCorrelation> ; status: RegisteredQuery<"public", { provider: string }, Promise<IdentityCorrelation>> ; inspectionOwner: (anchor: FunctionReference<"query", any, { provider: string }, IdentityCorrelation>) => Readonly<{ protocol: string ; anchor: FunctionReference<"query", any, any, any> ; facts: GenericValidator ; read: (ctx: InspectionReader, subject: SubjectRef) => Promise<SubjectInspection<{ outcome: "unavailable" | "unmatched" | "matched" | "conflict" = current.kind; people: string[] ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] = current.evidence }>> ; control?: (ctx: InspectionWriter, input: InspectionControlIntent) => Promise<InspectionControlReceipt> ; recoverControl?: (ctx: InspectionReader, input: InspectionControlIntent) => Promise<InspectionControlReceipt | null> }> ; request: (ctx: Parameters<typeof resolve>[0], provider: string, review: (person: string, correlation: Extract<IdentityCorrelation, { kind: "matched" }>) => Promise<unknown>) => Promise<{ correlation: { kind: "conflict" ; people: string[] ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] } | { kind: "unmatched" ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] } | { kind: "unavailable" ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] } ; request: null = null } | { correlation: { kind: "matched" ; person: string ; organization: string ; provider: string ; subject: string ; evidence: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: string }[] ; validUntil: number } ; request: unknown }> }>

identityFieldAuthority

▸ identityFieldAuthority<Row, Principal, Claims>(fields): Record<string, TransitionConditionDeclaration<Row, Principal, Claims>> Compile identity-field management through the existing native transition language. Install the returned declarations in the identity table’s access binding. Creation and deletion keep their ordinary native permissions.

Type parameters

Name	Type
`Row`	extends `Record`<`string`, `any`> = `any`
`Principal`	`any`
`Claims`	`any`

Parameters

Name	Type
`fields`	`Partial`<`Record`<keyof `Row` & `string`, `IdentityFieldAuthority`<`Row`, `Principal`, `Claims`>>>

Returns

Record<string, TransitionConditionDeclaration<Row, Principal, Claims>>

defineIdentityProjection

▸ defineIdentityProjection(input): Object One governed transaction applies independent field groups and records their actual outcomes. Install receipts and the exact internal apply export. Add writer to the target table’s writers and retain identityFieldAuthority transitions there. Source precedence is supplied by the installed observation query; it cannot bypass the target’s native authority or uniqueness rules.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.targetTable`	`string`
`input.receiptsTable`	`string`
`input.receiptResource`	`AccessResource`<`any`, `any`, `any`>
`input.observation`	`FunctionReference`<`"query"`, `"internal"`, { `key`: `string` }, typeof `type`>
`input.groups`	`Readonly`<`Record`<`string`, `Readonly`<`Record`<`string`, `GenericValidator`>>>>

Returns

Object

Name	Type
`writer`	`string`
`receipts`	`any`
`projectionDigest`	`string`
`functions`	{ `apply`: `RegisteredMutation`<`"internal"`, { `key`: `string` ; `requestId`: `string` }, `Promise`<{ `kind`: `"blocked"` ; `reason`: `"unavailable"` \| `"unmatched"` \| `"conflict"` } \| { `kind`: `"projected"` ; `requestId`: `string` ; `source`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `sourceRevision`: `string` ; `groups`: { name: string; reason: “unavailable” \| “accepted” \| “conflict” \| “sourceNotAuthoritative” \| “sameValue”; outcome: “unchanged” \| “skipped” \| “applied”; }[] ; `recordedAtMs`: `number` ; `identityId`: `string` ; `projectionDigest`: `string` ; `beforeDigest`: `string` ; `afterDigest`: `string` }>> }
`functions.apply`	`RegisteredMutation`<`"internal"`, { `key`: `string` ; `requestId`: `string` }, `Promise`<{ `kind`: `"blocked"` ; `reason`: `"unavailable"` \| `"unmatched"` \| `"conflict"` } \| { `kind`: `"projected"` ; `requestId`: `string` ; `source`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `sourceRevision`: `string` ; `groups`: { name: string; reason: “unavailable” \| “accepted” \| “conflict” \| “sourceNotAuthoritative” \| “sameValue”; outcome: “unchanged” \| “skipped” \| “applied”; }[] ; `recordedAtMs`: `number` ; `identityId`: `string` ; `projectionDigest`: `string` ; `beforeDigest`: `string` ; `afterDigest`: `string` }>>
`endpoints`	{ `preview`: `RegisteredQuery`<`"public"`, { `key`: `string` }, `Promise`<`any`>> ; `apply`: `RegisteredMutation`<`"public"`, { `key`: `string` ; `requestId`: `string` }, `Promise`<`any`>> ; `receipt`: `RegisteredQuery`<`"public"`, { `key`: `string` ; `requestId`: `string` }, `Promise`<`null` \| { `kind`: `"blocked"` ; `reason`: `"unavailable"` \| `"unmatched"` \| `"conflict"` } \| { `kind`: `"projected"` ; `requestId`: `string` ; `source`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `sourceRevision`: `string` ; `groups`: { name: string; reason: “unavailable” \| “accepted” \| “conflict” \| “sourceNotAuthoritative” \| “sameValue”; outcome: “unchanged” \| “skipped” \| “applied”; }[] ; `recordedAtMs`: `number` ; `identityId`: `string` ; `projectionDigest`: `string` ; `beforeDigest`: `string` ; `afterDigest`: `string` }>> }
`endpoints.preview`	`RegisteredQuery`<`"public"`, { `key`: `string` }, `Promise`<`any`>>
`endpoints.apply`	`RegisteredMutation`<`"public"`, { `key`: `string` ; `requestId`: `string` }, `Promise`<`any`>>
`endpoints.receipt`	`RegisteredQuery`<`"public"`, { `key`: `string` ; `requestId`: `string` }, `Promise`<`null` \| { `kind`: `"blocked"` ; `reason`: `"unavailable"` \| `"unmatched"` \| `"conflict"` } \| { `kind`: `"projected"` ; `requestId`: `string` ; `source`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `sourceRevision`: `string` ; `groups`: { name: string; reason: “unavailable” \| “accepted” \| “conflict” \| “sourceNotAuthoritative” \| “sameValue”; outcome: “unchanged” \| “skipped” \| “applied”; }[] ; `recordedAtMs`: `number` ; `identityId`: `string` ; `projectionDigest`: `string` ; `beforeDigest`: `string` ; `afterDigest`: `string` }>>

definePolicySlot

▸ definePolicySlot<Args, Returns>(definition): PolicySlot<ObjectType<Args>, Infer<Returns>> Declare a policy dependency of this component. Name it in a policy query’s policy.calls; the application binds a query with exactly these validators and declared policy.reads per installation. Deployment refuses a missing, extra or incompatible binding. The decision stays current: no code is retained.

Type parameters

Name	Type
`Args`	extends `PropertyValidators`
`Returns`	extends `Validator`<`any`, `any`, `any`>

Parameters

Name	Type
`definition`	`Object`
`definition.name`	`string`
`definition.args`	`Args`
`definition.returns`	`Returns`

Returns

PolicySlot<ObjectType<Args>, Infer<Returns>>

currentPolicyQuery

▸ currentPolicyQuery<Q>(query, args): Promise<FunctionReturnType<Q>> Consult an explicitly declared shared policy query at the live parent. Its actual current read dependencies fence this decision’s release. The executing query must list the reference in policy.calls; both the branch and current parent declarations must admit it. Available only in private policy evaluation, with the same actual requester and program provenance. Ordinary data queries retain their selected snapshot basis.

Type parameters

Name	Type
`Q`	extends `FunctionReference`<`"query"`, `"public"` \| `"internal"`>

Parameters

Name	Type
`query`	`Q`
`args`	`FunctionArgs`<`Q`>

Returns

Promise<FunctionReturnType<Q>>

policyExecution

▸ policyExecution(): Promise<PolicyExecution> Inspect the actual execution holder inside a private policy.

Returns

Promise<PolicyExecution>

invitationEmail

▸ invitationEmail(value): string

Parameters

Name	Type
`value`	`string`

Returns

string

onboardingResources

▸ onboardingResources(): Object Invitations and receipts each enforce their mandatory participant condition. Sharing an organization grants no access to either resource. Bind both resources with defineOnboarding.

Returns

Object

Name	Type
`invitation`	{ `permissions`: [`"read"`, `"create"`, `"manage"`] ; `audience`: { `read`: `"public"` = “public”; `create`: `"public"` = “public”; `manage`: `"public"` = “public” } }
`invitation.permissions`	[`"read"`, `"create"`, `"manage"`]
`invitation.audience`	{ `read`: `"public"` = “public”; `create`: `"public"` = “public”; `manage`: `"public"` = “public” }
`invitation.audience.read`	`"public"`
`invitation.audience.create`	`"public"`
`invitation.audience.manage`	`"public"`
`invitationReceipt`	{ `parent`: `"invitation"` = “invitation”; `permissions`: [`"read"`, `"create"`, `"manage"`] ; `audience`: { `read`: `"public"` = “public”; `create`: `"public"` = “public”; `manage`: `"public"` = “public” } }
`invitationReceipt.parent`	`"invitation"`
`invitationReceipt.permissions`	[`"read"`, `"create"`, `"manage"`]
`invitationReceipt.audience`	{ `read`: `"public"` = “public”; `create`: `"public"` = “public”; `manage`: `"public"` = “public” }
`invitationReceipt.audience.read`	`"public"`
`invitationReceipt.audience.create`	`"public"`
`invitationReceipt.audience.manage`	`"public"`

onboardingVisibility

▸ onboardingVisibility(service): AccessCondition Install on a root-level invitation resource with public read/manage audiences. This mandatory native condition limits disclosure to the issuer, the exact verified recipient and the declared native finalizer. Creation stays behind the factory’s exclusive issuer writer and its native grant-permission check. Declare issuer, subject, email and emailVerified claim types in the model.

Parameters

Name	Type
`service`	`string`

Returns

AccessCondition

defineOnboarding

▸ defineOnboarding(input): Object Invitations and one-purpose administration tasks share native assignments, retained sponsor decisions and ordinary request receipts. Acceptance records the verified recipient; a declared external finalizer then atomically creates the participation and acceptance receipt under its own native grant authority. No callback restores an issuer’s identity or accepts a caller-supplied role. Install table/receipts, export functions under module, and endpoints separately.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.table`	`string`
`input.receiptsTable`	`string`
`input.access`	`object`
`input.resource`	`AccessResource`<`any`, `any`, `any`>
`input.receiptResource`	`AccessResource`<`any`, `any`, `any`>
`input.service`	`string`
`input.workflows`	`Readonly`<`Record`<`string`, `Workflow`>>

Returns

Object

Name	Type
`table`	`TableDefinition`<`VObject`<{ `expiresAt`: `number` ; `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `role`: `string` ; `participation`: `null` \| `string` ; `scopeKey`: `string` ; `workflow`: `string` ; `definitionDigest`: `string` ; `termsDigest`: `string` ; `programDigest`: `string` ; `sponsorIssuer`: `string` ; `sponsorSubject`: `string` ; `recipientIssuer`: `string` ; `recipientEmail`: `string` ; `acceptedIssuer`: `string` ; `acceptedSubject`: `string` ; `scopeType`: `string` ; `sponsor`: `string` ; `participationExpiresAt`: `null` \| `number` ; `createdRequestId`: `string` ; `sponsorEvidence`: `string` ; `sponsorBinding`: `string` ; `acceptedBy`: `null` \| `string` ; `completionReceipt`: `null` \| `string` ; `lastResult`: `null` \| `string` }, { `workflow`: `VString`<`string`, `"required"`> ; `definitionDigest`: `VString`<`string`, `"required"`> ; `programDigest`: `VString`<`string`, `"required"`> ; `scopeType`: `VString`<`string`, `"required"`> ; `scopeKey`: `VString`<`string`, `"required"`> ; `role`: `VString`<`string`, `"required"`> ; `sponsor`: `VString`<`string`, `"required"`> ; `sponsorIssuer`: `VString`<`string`, `"required"`> ; `sponsorSubject`: `VString`<`string`, `"required"`> ; `recipientIssuer`: `VString`<`string`, `"required"`> ; `recipientEmail`: `VString`<`string`, `"required"`> ; `expiresAt`: `VFloat64`<`number`, `"required"`> ; `participationExpiresAt`: `VUnion`<`null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`> ; `createdRequestId`: `VString`<`string`, `"required"`> ; `termsDigest`: `VString`<`string`, `"required"`> ; `sponsorEvidence`: `VString`<`string`, `"required"`> ; `sponsorBinding`: `VString`<`string`, `"required"`> ; `revision`: `VInt64`<`bigint`, `"required"`> ; `state`: `VUnion`<`"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"`, [`VLiteral`<`"invited"`, `"required"`>, `VLiteral`<`"claimed"`, `"required"`>, `VLiteral`<`"accepted"`, `"required"`>, `VLiteral`<`"completed"`, `"required"`>, `VLiteral`<`"revoked"`, `"required"`>], `"required"`, `never`> ; `acceptedBy`: `VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`> ; `acceptedIssuer`: `VString`<`string`, `"required"`> ; `acceptedSubject`: `VString`<`string`, `"required"`> ; `participation`: `VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`> ; `completionReceipt`: `VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`> ; `lastResult`: `VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`> }, `"required"`, `"expiresAt"` \| `"revision"` \| `"state"` \| `"role"` \| `"participation"` \| `"scopeKey"` \| `"workflow"` \| `"definitionDigest"` \| `"termsDigest"` \| `"programDigest"` \| `"sponsorIssuer"` \| `"sponsorSubject"` \| `"recipientIssuer"` \| `"recipientEmail"` \| `"acceptedIssuer"` \| `"acceptedSubject"` \| `"scopeType"` \| `"sponsor"` \| `"participationExpiresAt"` \| `"createdRequestId"` \| `"sponsorEvidence"` \| `"sponsorBinding"` \| `"acceptedBy"` \| `"completionReceipt"` \| `"lastResult"`>, { `by_create`: [`"sponsor"`, `"createdRequestId"`, `"_creationTime"`] ; `by_recipient`: [`"recipientIssuer"`, `"recipientEmail"`, `"state"`, `"_creationTime"`] ; `by_state`: [`"state"`, `"_creationTime"`] }, {}, {}, `false`, {}> & { `isWriterOwned`: `true` } & `AccessTableBinding`<`AccessResource`<`any`, `any`, `any`, `AccessDefinitionInput`>, `any`>
`receipts`	`TableDefinition`<`VObject`<{ `requestId`: `string` ; `state`: `string` ; `termsDigest`: `string` ; `invitation`: `GenericId`<`string`> ; `sponsorIssuer`: `string` ; `sponsorSubject`: `string` ; `recipientIssuer`: `string` ; `recipientEmail`: `string` ; `acceptedIssuer`: `string` ; `acceptedSubject`: `string` ; `resultJson`: `string` }, { `invitation`: `VId`<`GenericId`<`string`>, `"required"`> ; `requestId`: `VString`<`string`, `"required"`> ; `termsDigest`: `VString`<`string`, `"required"`> ; `resultJson`: `VString`<`string`, `"required"`> ; `sponsorIssuer`: `VString`<`string`, `"required"`> ; `sponsorSubject`: `VString`<`string`, `"required"`> ; `recipientIssuer`: `VString`<`string`, `"required"`> ; `recipientEmail`: `VString`<`string`, `"required"`> ; `acceptedIssuer`: `VString`<`string`, `"required"`> ; `acceptedSubject`: `VString`<`string`, `"required"`> ; `state`: `VString`<`string`, `"required"`> }, `"required"`, `"requestId"` \| `"state"` \| `"termsDigest"` \| `"invitation"` \| `"sponsorIssuer"` \| `"sponsorSubject"` \| `"recipientIssuer"` \| `"recipientEmail"` \| `"acceptedIssuer"` \| `"acceptedSubject"` \| `"resultJson"`>, { `by_invitation`: [`"invitation"`, `"_creationTime"`] ; `by_request`: [`"invitation"`, `"requestId"`, `"_creationTime"`] }, {}, {}, `false`, {}> & { `isWriterOwned`: `true` } & `AccessTableBinding`<`AccessResource`<`any`, `any`, `any`, `AccessDefinitionInput`>, `any`>
`functions`	{ `issue`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `expiresAt`: `number` ; `scopeKey`: `string` ; `workflow`: `string` ; `recipientIssuer`: `string` ; `recipientEmail`: `string` ; `scopeType`: `string` ; `participationExpiresAt`: `null` \| `number` }, `Promise`<{ `invitationId`: `any` ; `revision`: `bigint` ; `state`: `"invited"` ; `participation`: `null` = null }>> ; `accept`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>> ; `finalize`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>> ; `revoke`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>> ; `perform`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `input`: `any` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`Value`>> ; `complete`: `RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>> }
`functions.issue`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `expiresAt`: `number` ; `scopeKey`: `string` ; `workflow`: `string` ; `recipientIssuer`: `string` ; `recipientEmail`: `string` ; `scopeType`: `string` ; `participationExpiresAt`: `null` \| `number` }, `Promise`<{ `invitationId`: `any` ; `revision`: `bigint` ; `state`: `"invited"` ; `participation`: `null` = null }>>
`functions.accept`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>>
`functions.finalize`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>>
`functions.revoke`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>>
`functions.perform`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `input`: `any` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`Value`>>
`functions.complete`	`RegisteredMutation`<`"internal"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<{ `revision`: `bigint` ; `state`: `"revoked"` \| `"completed"` \| `"accepted"` \| `"claimed"` \| `"invited"` ; `participation`: `null` \| `string` ; `invitationId`: `string` }>>
`endpoints`	{ `issue`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `expiresAt`: `number` ; `scopeKey`: `string` ; `workflow`: `string` ; `recipientIssuer`: `string` ; `recipientEmail`: `string` ; `scopeType`: `string` ; `participationExpiresAt`: `null` \| `number` }, `Promise`<`any`>> ; `accept`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>> ; `finalize`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>> ; `revoke`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>> ; `perform`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `input`: `any` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>> ; `complete`: `RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>> ; `inspect`: `RegisteredQuery`<`"public"`, { `invitationId`: `string` }, `Promise`<{ `invitationId`: `any` = row._id; `revision`: `any` = row.revision; `state`: `any` = row.state; `participation`: `any` = row.participation; `workflow`: `any` = row.workflow; `scope`: { `type`: `any` = row.scopeType; `key`: `any` = row.scopeKey } ; `recipientEmail`: `any` = row.recipientEmail; `expiresAt`: `any` = row.expiresAt; `participationExpiresAt`: `any` = row.participationExpiresAt; `completionReceipt`: `any` = row.completionReceipt; `operation`: `Value` }>> ; `pending`: `RegisteredQuery`<`"public"`, { `cursor`: `null` \| `string` ; `limit`: `number` ; `state`: `"accepted"` \| `"claimed"` }, `Promise`<{ `page`: { `invitationId`: `any` = row._id; `revision`: `any` = row.revision; `state`: `any` = row.state; `participation`: `any` = row.participation }[] ; `isDone`: `boolean` ; `continueCursor`: `string` ; `splitCursor?`: `null` \| `string` ; `pageStatus?`: `null` \| `"SplitRecommended"` \| `"SplitRequired"` }>> ; `recover`: `RegisteredQuery`<`"public"`, { `requestId`: `string` ; `terms`: `any` ; `invitationId`: `string` }, `Promise`<{ `kind`: `string` = “recovered”; `result`: `Value` = prior.result } \| { `result?`: `undefined` ; `kind`: `string` = “notFound” }>> }
`endpoints.issue`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `expiresAt`: `number` ; `scopeKey`: `string` ; `workflow`: `string` ; `recipientIssuer`: `string` ; `recipientEmail`: `string` ; `scopeType`: `string` ; `participationExpiresAt`: `null` \| `number` }, `Promise`<`any`>>
`endpoints.accept`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>>
`endpoints.finalize`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>>
`endpoints.revoke`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>>
`endpoints.perform`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `input`: `any` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>>
`endpoints.complete`	`RegisteredMutation`<`"public"`, { `requestId`: `string` ; `invitationId`: `string` ; `expectedRevision`: `bigint` }, `Promise`<`any`>>
`endpoints.inspect`	`RegisteredQuery`<`"public"`, { `invitationId`: `string` }, `Promise`<{ `invitationId`: `any` = row._id; `revision`: `any` = row.revision; `state`: `any` = row.state; `participation`: `any` = row.participation; `workflow`: `any` = row.workflow; `scope`: { `type`: `any` = row.scopeType; `key`: `any` = row.scopeKey } ; `recipientEmail`: `any` = row.recipientEmail; `expiresAt`: `any` = row.expiresAt; `participationExpiresAt`: `any` = row.participationExpiresAt; `completionReceipt`: `any` = row.completionReceipt; `operation`: `Value` }>>
`endpoints.pending`	`RegisteredQuery`<`"public"`, { `cursor`: `null` \| `string` ; `limit`: `number` ; `state`: `"accepted"` \| `"claimed"` }, `Promise`<{ `page`: { `invitationId`: `any` = row._id; `revision`: `any` = row.revision; `state`: `any` = row.state; `participation`: `any` = row.participation }[] ; `isDone`: `boolean` ; `continueCursor`: `string` ; `splitCursor?`: `null` \| `string` ; `pageStatus?`: `null` \| `"SplitRecommended"` \| `"SplitRequired"` }>>
`endpoints.recover`	`RegisteredQuery`<`"public"`, { `requestId`: `string` ; `terms`: `any` ; `invitationId`: `string` }, `Promise`<{ `kind`: `string` = “recovered”; `result`: `Value` = prior.result } \| { `result?`: `undefined` ; `kind`: `string` = “notFound” }>>

operatorIdentity

▸ operatorIdentity(): AuthProvider Explicitly trust this installation’s member identities in auth.config.ts. The deployment owner supplies the issuer and immutable deployment audience. Authentication grants no operation, read, or approval permission.

Returns

AuthProvider

organizationAdmission

▸ organizationAdmission<Permission>(input): Readonly<{ requirements: Readonly<Record<string, { on: [Permission, …Permission[]] ; onOrigins: readonly AuthorityOrigin[] ; when: AccessCondition ; decision?: { actors: readonly ("service" | "person")[] ; authentication: Readonly<{ maxAgeMs: number ; acrValues: readonly string[] ; requiredMethods: readonly string[] }> ; unless: AccessCondition } }>> ; describe: () => { permissions: Permission[] ; origins: AuthorityOrigin[] ; profiles: { name: string ; authentication: null | Readonly<{ maxAgeMs: number ; acrValues: readonly string[] ; requiredMethods: readonly string[] }> }[] } }> Organization admission narrows tenant pass; it never creates membership. Choose the covered origins explicitly. Delegated claims cannot satisfy a direct authentication requirement; mediated admission needs its own reviewed native approval requirement.

Type parameters

Name	Type
`Permission`	extends `string`

Parameters

Name	Type
`input`	`Object`
`input.on`	readonly [`Permission`, …Permission[]]
`input.onOrigins`	readonly `AuthorityOrigin`[]
`input.profiles`	`Readonly`<`Record`<`string`, { `selected`: `AccessCondition` ; `when`: `AccessCondition` ; `authentication?`: `PermissionAuthentication` }>>

Returns

Readonly<{ requirements: Readonly<Record<string, { on: [Permission, …Permission[]] ; onOrigins: readonly AuthorityOrigin[] ; when: AccessCondition ; decision?: { actors: readonly ("service" | "person")[] ; authentication: Readonly<{ maxAgeMs: number ; acrValues: readonly string[] ; requiredMethods: readonly string[] }> ; unless: AccessCondition } }>> ; describe: () => { permissions: Permission[] ; origins: AuthorityOrigin[] ; profiles: { name: string ; authentication: null | Readonly<{ maxAgeMs: number ; acrValues: readonly string[] ; requiredMethods: readonly string[] }> }[] } }>

organizationShares

▸ organizationShares(access): Object Organization shares are standing, source-reviewed positive projections. Source approval requires current <type>:share on the exact source. Executing the review records recipient acceptance with <type>:acceptShare. Reads require current recipient <type>:pass; either side can revoke with <type>:revokeShare. Source tenant membership is never conferred.

Parameters

Name	Type
`access`	`object`

Returns

Object

Name	Type
`define`	(`options`: `Omit`<`Parameters`<typeof `defineDataRelease`>[`0`], `"sharing"` \| `"is_standing"` \| `"component"` \| `"input"`> & { `source`: `AccessResourceRef` ; `recipient`: `AccessResourceRef` ; `recipientField`: `string` }) => `DataReleaseDefinition`

readPolicy

▸ readPolicy<DataModel>(decide, options?): RegisteredQuery<"internal", { requests: { properties: string[] | null; target: { kind: “object”; id: string; } | { covers?: true; interval?: { field: string | null; index: string; lower: { value?: Value; inclusive: boolean; } | null; upper: { …; } | null; }; kind: “query”; equalities: { …; }[]; }; table: string; }[] }, Promise<ReadAccessResults>> A read rule that decides each request of the native batch on its own. decide sees one request; the batch and its result list stay native.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel` = `GenericDataModel`

Parameters

Name	Type
`decide`	(`ctx`: `BijectionQueryCtx`<`DataModel`>, `request`: `ReadAccessRequest`) => `Decision`<`ReadAccessResult`>
`options?`	`Object`
`options.reads?`	readonly `Extract`<keyof `DataModel`, `string`>[]
`options.calls?`	readonly `FunctionReference`<`"query"`, `"public"` \| `"internal"`, `any`, `any`>[]

Returns

RegisteredQuery<"internal", { requests: { properties: string[] | null; target: { kind: “object”; id: string; } | { covers?: true; interval?: { field: string | null; index: string; lower: { value?: Value; inclusive: boolean; } | null; upper: { …; } | null; }; kind: “query”; equalities: { …; }[]; }; table: string; }[] }, Promise<ReadAccessResults>>

mandatePolicy

▸ mandatePolicy<Target, Args, DataModel>(command, decide): RegisteredQuery<"internal", [{ phase: VUnion<"review_mandate" | "issue_mandate" | "revoke_mandate", [VLiteral<"review_mandate", "required">, VLiteral<"issue_mandate", "required">, VLiteral<"revoke_mandate", "required">], "required", never> ; actor: VString<string, "required"> ; initiator: VString<string, "required"> ; requester: VString<string, "required"> ; continuation: VObject<{ kind: "organization" ; service: string ; credential: string ; expiresAt: number }, { kind: VLiteral<"organization", "required"> ; service: VString<string, "required"> ; credential: VString<string, "required"> ; expiresAt: VFloat64<number, "required"> }, "required", "kind" | "service" | "credential" | "expiresAt"> ; delivery: VAny<any, "required", string> ; condition: VAny<any, "required", string> ; target: Target = command.target; args: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Args[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Args[Property]> }>, Args, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

{Args[Property][“fieldPaths”]}` }[keyof Args] & string> ; approval: VAny<any, "required", string> ; terms: VAny<any, "optional", string> }] extends [PropertyValidators] ? [{}] : OneArgArray<DefaultFunctionArgs>[0], Promise<(null | { validUntil: number } | { recheckAt: number })[]>> Consent to issue, review or withdraw one organizational commitment. Every ordinary command decision and source disclosure remains required. The native owner supplies the actor and exact retained effect.

Type parameters

Name	Type
`Target`	extends `Validator`<`any`, `"required"`, `any`>
`Args`	extends `PropertyValidators`
`DataModel`	extends `GenericDataModel` = `GenericDataModel`

Parameters

Name	Type
`command`	`Object`
`command.target`	`Target`
`command.args`	`Args`
`decide`	(`ctx`: `BijectionQueryCtx`<`DataModel`>, `input`: `Omit`<`CommandMandateInput`, `"target"` \| `"args"`> & { `target`: `Target`[`"type"`] ; `args`: `ObjectType`<`Args`> }) => `Decision`<`CommandDecision`>

Returns

RegisteredQuery<"internal", [{ phase: VUnion<"review_mandate" | "issue_mandate" | "revoke_mandate", [VLiteral<"review_mandate", "required">, VLiteral<"issue_mandate", "required">, VLiteral<"revoke_mandate", "required">], "required", never> ; actor: VString<string, "required"> ; initiator: VString<string, "required"> ; requester: VString<string, "required"> ; continuation: VObject<{ kind: "organization" ; service: string ; credential: string ; expiresAt: number }, { kind: VLiteral<"organization", "required"> ; service: VString<string, "required"> ; credential: VString<string, "required"> ; expiresAt: VFloat64<number, "required"> }, "required", "kind" | "service" | "credential" | "expiresAt"> ; delivery: VAny<any, "required", string> ; condition: VAny<any, "required", string> ; target: Target = command.target; args: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Args[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Args[Property]> }>, Args, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

requireDirectPerson

▸ requireDirectPerson(): Promise<void> Require a directly signed-in person using host-owned authentication. Native conversation grants are deliberately absent from public identity facts, so inspecting those facts cannot authorize consent or another personal decision. Backend only; this check makes no permission grant.

Returns

Promise<void>

isPerson

▸ isPerson(identity): boolean Whether identity is a person signed in directly: the only caller whose approval, review, grant or share may be recorded as a person’s decision.

Parameters

Name	Type
`identity`	{ `issuer`: `string` ; `subject?`: `string` ; `delegationId?`: `unknown` } \| `null` \| `undefined`

Returns

boolean

decideEach

▸ decideEach<R>(requests, decide): Promise<ReadAccessResults> Decide each request of a batch on its own, in order. A return inside decide settles only its own request; a throw refuses the batch.

Type parameters

Name
`R`

Parameters

Name	Type
`requests`	readonly `R`[]
`decide`	(`request`: `R`) => `ReadAccessResult` \| `Promise`<`ReadAccessResult`>

Returns

Promise<ReadAccessResults>

resourceAudit

▸ resourceAudit(access): Object Resource audit uses the original sealed deployment journal. Recording requires <type>:pass; every query page requires current <type>:audit. One audited invocation belongs to one resource scope. This API runs in application queries/mutations, against the current deployment journal.

Parameters

Name	Type
`access`	`object`

Returns

Object

Name	Type
`record`	(`_ctx`: `AccessCtx`, `resource`: `AccessResourceRef`, `body`: `AuditLogBody`) => `Promise`<`void`>
`page`	(`_ctx`: `AccessCtx`, `resource`: `AccessResourceRef`, `options`: { `limit`: `number` ; `cursor?`: `string` \| `null` ; `from?`: `number` ; `to?`: `number` }) => `Promise`<`ResourceAuditPage`>
`follow`	(`_ctx`: `AccessCtx`, `resource`: `AccessResourceRef`, `options`: { `limit`: `number` ; `cursor?`: `string` \| `null` ; `from?`: `number` }) => `Promise`<`ResourceAuditPage`>

resourceAuthority

▸ resourceAuthority(options): ResourceAuthority<"readWrite"> Declare one complete programmable resource authority for a table inside an installed component. Application tables use the native access model (defineAccess with .access(access.resources.<type>, ...)); activation refuses a programmable policy at the application root. Use a read-only handle for component source tables and views, and a handle with write for component-owned local tables. All checks retain the runtime’s ordinary dependency, current-policy, original/final write, delegation and per-release enforcement.

Parameters

Name	Type
`options`	`ResourceAuthorityOptions` & { `write`: `NonNullable`<`ResourceAuthorityOptions`[`"write"`]> }

Returns

ResourceAuthority<"readWrite"> ▸ resourceAuthority(options): ResourceAuthority<"read">

Parameters

Name	Type
`options`	`ResourceAuthorityOptions` & { `write?`: `never` ; `writeBasis?`: `never` ; `writeReads?`: `never` }

Returns

ResourceAuthority<"read">

riskBindingDigest

▸ riskBindingDigest(binding): string Exact request identity shared by the immutable operation owner and its authenticated external assessment. Changing any context changes the digest.

Parameters

Name	Type
`binding`	`RiskBinding`

Returns

string

defineRiskCheck

▸ defineRiskCheck(input): Readonly<{ evidence: Readonly<{}> ; check: RegisteredQuery<"internal", { request: string }, Promise<{ kind: "matched" ; values: Record<string, string> } | { kind: "unmatched" }>> ; inspect: RegisteredQuery<"internal", { request: string }, Promise<{ kind: "unavailable" | "challenge" | "allow" | "deny" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: null | string ; reason: string ; validUntil: null | number ; binding: null | string ; handling: "refuse" | "challenge" }>> ; requirement: (permission: string, bindingField: string) => PermissionRequirement ; verification: (check: CheckContractReference<{ request: string }, ContextCheckResult>, request?: string) => KnowledgeDeclaration }> External risk narrows existing authority through native expiring evidence. The two queries are fixed by installed code. Their owner authenticates the provider and captures the original request; evaluation performs no HTTP. Export check, analyze it, then pass its generated check contract to verification. The ordinary interaction owns attempts, facts and expiry.

Parameters

Name	Type	Description
`input`	`Object`	-
`input.on`	`string`	-
`input.predicate`	`string`	-
`input.scope`	`"principal"` \| `"participant"`	-
`input.policyVersion`	`string`	-
`input.binding`	`FunctionReference`<`"query"`, `"internal"`, { `request`: `string` }, `RiskBinding` \| `null`>	-
`input.observation`	`FunctionReference`<`"query"`, `"internal"`, { `binding`: `string` ; `policyVersion`: `string` }, `RiskObservation` \| `null`>	-
`input.reads`	readonly `string`[]	-
`input.maximumObservationAgeMs`	`number`	-
`input.validForMs`	`number`	-
`input.unavailable`	`"refuse"` \| `"challenge"`	Both choices withhold evidence. The owner may present a challenge or refuse and retry acquisition later; neither silently permits an effect.

Returns

Readonly<{ evidence: Readonly<{}> ; check: RegisteredQuery<"internal", { request: string }, Promise<{ kind: "matched" ; values: Record<string, string> } | { kind: "unmatched" }>> ; inspect: RegisteredQuery<"internal", { request: string }, Promise<{ kind: "unavailable" | "challenge" | "allow" | "deny" ; source: null | { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; }; protocol: string; } ; revision: null | string ; reason: string ; validUntil: null | number ; binding: null | string ; handling: "refuse" | "challenge" }>> ; requirement: (permission: string, bindingField: string) => PermissionRequirement ; verification: (check: CheckContractReference<{ request: string }, ContextCheckResult>, request?: string) => KnowledgeDeclaration }>

defineSecurityModule

▸ defineSecurityModule(input): Object Security management composes existing owners and their original receipts. Install these endpoints in the application’s security module. Provider inventories are fixed internal queries; factor secrets stay with providers.

Parameters

Name	Type
`input`	`Object`
`input.authorize`	(`ctx`: `BijectionQueryCtx`<`any`, `any`>) => `Promise`<`unknown`>
`input.sections`	`Readonly`<`Record`<`string`, `SecuritySection` \| `null`>>

Returns

Object

Name	Type
`overview`	`RegisteredQuery`<`"public"`, {}, `Promise`<`any`>>
`page`	`RegisteredQuery`<`"public"`, { `cursor`: `undefined` \| `string` ; `limit`: `number` ; `section`: `string` }, `Promise`<{ `kind`: `"unsupported"` } \| { `kind`: `"unavailable"` } \| { `kind`: `"observed"` ; `observedAtMs`: `number` = population.observedAtMs; `validUntilMs`: `null` \| `number` = population.validUntilMs; `coverage`: `"partial"` \| `"complete"` = population.coverage; `items`: ({ `kind`: `"unavailable"` ; `subject`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } } \| { `kind`: `"observed"` ; `observation`: `Readonly`<{ `subject`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAtMs`: `number` ; `facts`: `unknown` ; `waits`: `Readonly`<{ `items`: { `key`: `string` ; `code`: `string` ; `message`: `string` ; `targets`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }[] ; `nextCheckAtMs`: `null` \| `number` }[] ; `coverage`: `"partial"` \| `"complete"` }> ; `links`: `Readonly`<{ `items`: { `target`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `evidence`: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }; revision: string; }[] ; `relation`: `"uses"` \| `"causedBy"` \| `"produced"` }[] ; `coverage`: `"partial"` \| `"complete"` }> ; `evidence`: `Readonly`<{ `items`: { `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `revision`: `string` }[] ; `coverage`: `"partial"` \| `"complete"` }> ; `controls`: { `key`: `string` ; `target`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `label`: `string` ; `expectedRevision`: `string` }[] }> })[] ; `cursor`: `null` \| `string` = population.cursor }>>
`control`	`RegisteredMutation`<`"public"`, { `key`: `string` ; `requestId`: `RequestId` ; `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `expectedRevision`: `string` }, `Promise`<{ `intent`: { key: string; requestId: RequestId; subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }; expectedRevision: string; } ; `recordedAtMs`: `number` ; `recoverUntilMs`: `number` }>>
`recover`	`RegisteredQuery`<`"public"`, { `key`: `string` ; `requestId`: `RequestId` ; `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `expectedRevision`: `string` }, `Promise`<`null` \| { `intent`: { key: string; requestId: RequestId; subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }; expectedRevision: string; } ; `recordedAtMs`: `number` ; `recoverUntilMs`: `number` }>>
`inspectionOwners`	`RegisteredQuery`<`"public"`, {}, `Promise`<{ `location`: `Readonly`<`ResourceLocation`> ; `installation`: `string` ; `protocol`: `string` }[]>>
`inspectSubject`	`RegisteredQuery`<`"public"`, { `context`: `undefined` \| { definition_digest: string; } ; `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } }, `Promise`<{ `kind`: `"unavailable"` ; `subject`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `context`: { `definition_digest`: `string` } = basis } \| { `kind`: `"observed"` ; `observation`: `Readonly`<{ `subject`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAtMs`: `number` ; `facts`: `unknown` ; `waits`: `Readonly`<{ `items`: { `key`: `string` ; `code`: `string` ; `message`: `string` ; `targets`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }[] ; `nextCheckAtMs`: `null` \| `number` }[] ; `coverage`: `"partial"` \| `"complete"` }> ; `links`: `Readonly`<{ `items`: { `target`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `evidence`: { subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }; revision: string; }[] ; `relation`: `"uses"` \| `"causedBy"` \| `"produced"` }[] ; `coverage`: `"partial"` \| `"complete"` }> ; `evidence`: `Readonly`<{ `items`: { `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `revision`: `string` }[] ; `coverage`: `"partial"` \| `"complete"` }> ; `controls`: { `key`: `string` ; `target`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `label`: `string` ; `expectedRevision`: `string` }[] }> ; `context`: { `definition_digest`: `string` } = basis }>>
`explainSubject`	`RegisteredQuery`<`"public"`, { `context`: `undefined` \| { definition_digest: string; } ; `maxDepth`: `undefined` \| `number` ; `maxNodes`: `undefined` \| `number` ; `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } }, `Promise`<{ `root`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `scope`: `Readonly`<{ `maxDepth`: `number` ; `maxNodes`: `number` ; `direction`: `"outgoing"` ; `relationships`: (`"uses"` \| `"causedBy"` \| `"produced"` \| `"waitingFor"`)[] }> ; `nodes`: `SubjectInspection`<`unknown`>[] ; `edges`: `Readonly`<{ `from`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `to`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `relation`: `"uses"` \| `"causedBy"` \| `"produced"` \| `"waitingFor"` ; `waitKey`: `null` \| `string` }>[] ; `frontier`: { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` }[] ; `coverage`: `Readonly`<{ `traversal`: `"bounded"` \| `"complete"` ; `observations`: `"partial"` \| `"complete"` ; `history`: `"notRequested"` }> ; `context`: { `definition_digest`: `string` } = basis }>>
`controlSubject`	`RegisteredMutation`<`"public"`, { `key`: `string` ; `requestId`: `RequestId` ; `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `expectedRevision`: `string` }, `Promise`<{ `intent`: { key: string; requestId: RequestId; subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }; expectedRevision: string; } ; `recordedAtMs`: `number` ; `recoverUntilMs`: `number` }>>
`recoverSubjectControl`	`RegisteredQuery`<`"public"`, { `key`: `string` ; `requestId`: `RequestId` ; `subject`: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `expectedRevision`: `string` }, `Promise`<`null` \| { `intent`: { key: string; requestId: RequestId; subject: { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; }; expectedRevision: string; } ; `recordedAtMs`: `number` ; `recoverUntilMs`: `number` }>>

defineNativeSessionSecurity

▸ defineNativeSessionSecurity(input): Object Ready-to-install native session section. Export functions in module, then pass section to defineSecurityModule. Provider sessions remain a separate inventory and revocation owner.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`

Returns

Object

Name	Type
`section`	{ `owner`: `Readonly`<{ `protocol`: `string` ; `anchor`: `FunctionReference`<`"query"`, `any`, `any`, `any`> ; `facts`: `GenericValidator` ; `read`: (`ctx`: `InspectionReader`, `subject`: `SubjectRef`) => `Promise`<`SubjectInspection`<`any`>> ; `control?`: (`ctx`: `InspectionWriter`, `input`: `InspectionControlIntent`) => `Promise`<`InspectionControlReceipt`> ; `recoverControl?`: (`ctx`: `InspectionReader`, `input`: `InspectionControlIntent`) => `Promise`<`InspectionControlReceipt` \| `null`> }> ; `population`: `FunctionReference`<`"query"`, `"internal"`, { `principal`: `string` ; `limit`: `number` ; `cursor`: `null` \| `string` }, { `kind`: `"unsupported"` } \| { `kind`: `"unavailable"` } \| { `kind`: `"observed"` ; `cursor`: `null` \| `string` ; `coverage`: `"partial"` \| `"complete"` ; `ids`: `string`[] ; `observedAtMs`: `number` ; `validUntilMs`: `null` \| `number` }> }
`section.owner`	`Readonly`<{ `protocol`: `string` ; `anchor`: `FunctionReference`<`"query"`, `any`, `any`, `any`> ; `facts`: `GenericValidator` ; `read`: (`ctx`: `InspectionReader`, `subject`: `SubjectRef`) => `Promise`<`SubjectInspection`<`any`>> ; `control?`: (`ctx`: `InspectionWriter`, `input`: `InspectionControlIntent`) => `Promise`<`InspectionControlReceipt`> ; `recoverControl?`: (`ctx`: `InspectionReader`, `input`: `InspectionControlIntent`) => `Promise`<`InspectionControlReceipt` \| `null`> }>
`section.population`	`FunctionReference`<`"query"`, `"internal"`, { `principal`: `string` ; `limit`: `number` ; `cursor`: `null` \| `string` }, { `kind`: `"unsupported"` } \| { `kind`: `"unavailable"` } \| { `kind`: `"observed"` ; `cursor`: `null` \| `string` ; `coverage`: `"partial"` \| `"complete"` ; `ids`: `string`[] ; `observedAtMs`: `number` ; `validUntilMs`: `null` \| `number` }>
`functions`	{ `status`: `RegisteredQuery`<`"internal"`, { `sessionId`: `string` }, `Promise`<`null` \| { `expiresAt`: `number` ; `active`: `boolean` ; `issuer`: `string` ; `sessionId`: `string` ; `client`: `string` ; `endedAt`: `null` \| `number` }>> ; `population`: `RegisteredQuery`<`"internal"`, { `cursor`: `null` \| `string` ; `principal`: `string` ; `limit`: `number` }, `Promise`<{ `kind`: `"observed"` ; `observedAtMs`: `number` ; `validUntilMs`: `null` \| `number` ; `coverage`: `"complete"` ; `ids`: `string`[] ; `cursor`: `null` \| `string` }>> ; `receipt`: `RegisteredQuery`<`"internal"`, { `requestId`: `string` }, `Promise`<`any`>> }
`functions.status`	`RegisteredQuery`<`"internal"`, { `sessionId`: `string` }, `Promise`<`null` \| { `expiresAt`: `number` ; `active`: `boolean` ; `issuer`: `string` ; `sessionId`: `string` ; `client`: `string` ; `endedAt`: `null` \| `number` }>>
`functions.population`	`RegisteredQuery`<`"internal"`, { `cursor`: `null` \| `string` ; `principal`: `string` ; `limit`: `number` }, `Promise`<{ `kind`: `"observed"` ; `observedAtMs`: `number` ; `validUntilMs`: `null` \| `number` ; `coverage`: `"complete"` ; `ids`: `string`[] ; `cursor`: `null` \| `string` }>>
`functions.receipt`	`RegisteredQuery`<`"internal"`, { `requestId`: `string` }, `Promise`<`any`>>

serviceIssuer

▸ serviceIssuer(service): string The issuer of service’s tokens.

Parameters

Name	Type
`service`	`string`

Returns

string

serviceTokenIdentifier

▸ serviceTokenIdentifier(service): string The token identifier of service itself: the subject its grants name.

Parameters

Name	Type
`service`	`string`

Returns

string

defineInspectionOwner

▸ defineInspectionOwner<Facts>(owner): InspectionOwner<Facts> Configuration is authored code; subjects can only select an admitted anchor.

Type parameters

Name
`Facts`

Parameters

Name	Type
`owner`	`InspectionOwner`<`Facts`>

Returns

InspectionOwner<Facts>

ownerObservation

▸ ownerObservation<Facts>(subject, input): SubjectInspection<Facts> Construct an observation, without storing or inferring another lifecycle.

Type parameters

Name
`Facts`

Parameters

Name	Type
`subject`	`SubjectRef`
`input`	`Object`
`input.revision`	`string`
`input.facts`	`Facts`
`input.waits?`	readonly `InspectionWait`[]
`input.links?`	readonly `InspectionLink`[]
`input.evidence?`	readonly `InspectionEvidence`[]
`input.controls?`	readonly `InspectionControl`[]
`input.coverage?`	`"complete"` \| `"partial"`

Returns

SubjectInspection<Facts>

inspectionSubject

▸ inspectionSubject(owner, id): Promise<SubjectRef>

Parameters

Name	Type
`owner`	`Pick`<`InspectionOwner`, `"protocol"` \| `"anchor"`>
`id`	`string`

Returns

Promise<SubjectRef>

defineWorkosEnterpriseHealthReader

▸ defineWorkosEnterpriseHealthReader(input): RegisteredQuery<"internal", { owner: string }, Promise<{ selection: { connection: string ; directory: null | string } ; configuration: { issuer: string ; clientId: string ; providerOrganization: string } ; source: { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; evidence: { dataset: undefined | { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; } ; recordObservedFrom: undefined | number ; recordObservedTo: undefined | number ; capabilities: null | { evidence: “native” | “asserted” | “brokered”; consistency: “snapshot” | “observations”; coverage: “records” | “enumeration” | “snapshot” | “queryResult” | “incrementalSnapshot” | “committedPrefix” | “latestPerKey”; … 6 more …; snapshotMaxRows: string | null; } ; population: null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; erased: boolean ; publication: null | { sourceId: SourceId; scope: string; publicationId: SourcePublicationId; checkpoint: { position: { value: string; space: string; } | null; captureId: string; } | null; epoch: SourceEpoch; } ; populationCovered: boolean ; populationObservedFrom: null | number ; observedFrom: null | number ; observedTo: null | number ; continuityLost: boolean ; historyInterrupted: boolean } ; record: { id: string ; organization: string ; directory: null | string ; connectionState: string ; ssoEnforced: null ; connectionType: string ; directoryState: null | string ; certificateState: "unavailable" | "observed" | "notApplicable" ; certificates: { id: string; notBefore: number | null; notAfter: number | null; }[] } } | { selection: { connection: string ; directory: null | string } ; configuration: { issuer: string ; clientId: string ; providerOrganization: string } ; source: { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; record: null = null; evidence: null = null }>> Install the concrete source reader beside the health proof module. The table, owner index, reviewed configuration and inspection anchor are fixed by code. It always reads the exact row’s evidence, never population freshness.

Parameters

Name	Type
`input`	`Object`
`input.table`	`string`
`input.index?`	`string`
`input.ownerField?`	`string`
`input.configuration`	`FunctionReference`<`"query"`, `"internal"`, { `owner`: `string` }, `Pick`<`Observation`, `"configuration"` \| `"selection"`>>
`input.anchor`	`FunctionReference`<`"query"`, `"internal"`, { `owner`: `string` }, `Observation`>

Returns

RegisteredQuery<"internal", { owner: string }, Promise<{ selection: { connection: string ; directory: null | string } ; configuration: { issuer: string ; clientId: string ; providerOrganization: string } ; source: { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; evidence: { dataset: undefined | { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; } ; recordObservedFrom: undefined | number ; recordObservedTo: undefined | number ; capabilities: null | { evidence: “native” | “asserted” | “brokered”; consistency: “snapshot” | “observations”; coverage: “records” | “enumeration” | “snapshot” | “queryResult” | “incrementalSnapshot” | “committedPrefix” | “latestPerKey”; … 6 more …; snapshotMaxRows: string | null; } ; population: null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; erased: boolean ; publication: null | { sourceId: SourceId; scope: string; publicationId: SourcePublicationId; checkpoint: { position: { value: string; space: string; } | null; captureId: string; } | null; epoch: SourceEpoch; } ; populationCovered: boolean ; populationObservedFrom: null | number ; observedFrom: null | number ; observedTo: null | number ; continuityLost: boolean ; historyInterrupted: boolean } ; record: { id: string ; organization: string ; directory: null | string ; connectionState: string ; ssoEnforced: null ; connectionType: string ; directoryState: null | string ; certificateState: "unavailable" | "observed" | "notApplicable" ; certificates: { id: string; notBefore: number | null; notAfter: number | null; }[] } } | { selection: { connection: string ; directory: null | string } ; configuration: { issuer: string ; clientId: string ; providerOrganization: string } ; source: { id: string ; installation: string ; location: { incarnation: string; branch: { key: string; generation: string; } | null; deployment_id: string; } ; protocol: string } ; record: null = null; evidence: null = null }>>

defineWorkosEnterpriseHealth

▸ defineWorkosEnterpriseHealth(input): Object Concrete WorkOS interpretation over native acquired observations. Export the returned internal functions under module. Missing provider APIs and gaps never become positive readiness evidence. This factory performs no network I/O.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.read`	`FunctionReference`<`"query"`, `"internal"`, { `owner`: `string` }, `Observation`>
`input.maximumAgeMs`	`number`

Returns

Object

Name	Type
`inspectionOwner`	`Readonly`<{ `protocol`: `string` ; `anchor`: `FunctionReference`<`"query"`, `any`, `any`, `any`> ; `facts`: `GenericValidator` ; `read`: (`ctx`: `InspectionReader`, `subject`: `SubjectRef`) => `Promise`<`SubjectInspection`<{ `directoryEvidence`: `undefined` \| `null` \| { evidence: { dataset?: { component: string \| null; dataset: string \| null; version: string \| null; revision: string \| null; publicationId: SourcePublicationId \| null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; }; source: { …; }; directory: string; } ; `record`: `null` \| { id: string; organization: string; directory: string \| null; connectionState: string; ssoEnforced: null; connectionType: string; directoryState: string \| null; certificateState: “unavailable” \| “observed” \| “notApplicable”; certificates: { …; }[]; } ; `evidence`: `null` \| { dataset?: { component: string \| null; dataset: string \| null; version: string \| null; revision: string \| null; publicationId: SourcePublicationId \| null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; } ; `source`: `null` \| { id: string; installation: string; location: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; }; protocol: string; } ; `selection`: { connection: string; directory: string \| null; } ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } }>> ; `control?`: (`ctx`: `InspectionWriter`, `input`: `InspectionControlIntent`) => `Promise`<`InspectionControlReceipt`> ; `recoverControl?`: (`ctx`: `InspectionReader`, `input`: `InspectionControlIntent`) => `Promise`<`InspectionControlReceipt` \| `null`> }>
`functions`	{ `connection`: `RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>> ; `certificate`: `RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>> ; `policy`: `RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>> ; `directory`: `RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>> ; `status`: `RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = result.facts.configuration; `selection`: { `connection`: `string` ; `directory`: `null` \| `string` } = result.facts.selection; `connection`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } = result.connection; `certificate`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } = result.certificate; `policy`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } = result.policy; `directory`: { `state`: `null` \| `string` ; `coverage`: `string` ; `proof`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` } = result.directory } ; `source`: `null` \| { `sourceId`: `SourceId` ; `scope`: `string` ; `publicationId`: `SourcePublicationId` ; `checkpoint`: `null` \| { position: { value: string; space: string; } \| null; captureId: string; } ; `epoch`: `SourceEpoch` } ; `repair`: `null` \| { `action`: `string` = “refreshSource”; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = result.facts.source } ; `validUntil`: `null` \| `number` }>> ; `connectionProof`: `RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>> ; `certificateProof`: `RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>> ; `policyProof`: `RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>> ; `directoryProof`: `RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>> }
`functions.connection`	`RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>>
`functions.certificate`	`RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>>
`functions.policy`	`RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>>
`functions.directory`	`RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } \| { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` }>>
`functions.status`	`RegisteredQuery`<`"internal"`, { `owner`: `string` }, `Promise`<{ `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = result.facts.configuration; `selection`: { `connection`: `string` ; `directory`: `null` \| `string` } = result.facts.selection; `connection`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `kind`: `"connection"` ; `active`: `null` \| `boolean` } = result.connection; `certificate`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"certificate"` ; `expiresAt`: `null` \| `number` ; `state`: `"unavailable"` \| `"blocked"` \| `"ready"` } = result.certificate; `policy`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `revision`: `string` ; `observedAt`: `number` ; `validUntil`: `number` ; `kind`: `"policy"` ; `state`: `"unavailable"` ; `ssoEnforced`: `null` = null } = result.policy; `directory`: { `state`: `null` \| `string` ; `coverage`: `string` ; `proof`: { `configuration`: { `issuer`: `string` ; `clientId`: `string` ; `providerOrganization`: `string` } = facts.configuration; `kind`: `"directory"` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } ; `revision`: `string` ; `observedAt`: `number` = directoryObservedAt; `validUntil`: `number` ; `state`: `"unavailable"` \| `"ready"` ; `checkpoint`: `null` \| `string` ; `publicationRevision`: `null` \| `SourcePublicationId` ; `complete`: `boolean` } = result.directory } ; `source`: `null` \| { `sourceId`: `SourceId` ; `scope`: `string` ; `publicationId`: `SourcePublicationId` ; `checkpoint`: `null` \| { position: { value: string; space: string; } \| null; captureId: string; } ; `epoch`: `SourceEpoch` } ; `repair`: `null` \| { `action`: `string` = “refreshSource”; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = result.facts.source } ; `validUntil`: `null` \| `number` }>>
`functions.connectionProof`	`RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>>
`functions.certificateProof`	`RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>>
`functions.policyProof`	`RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>>
`functions.directoryProof`	`RegisteredQuery`<`"internal"`, { `owner`: `string` ; `configuration`: { issuer: string; clientId: string; providerOrganization: string; } ; `configurationDigest`: `string` }, `Promise`<{ `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `null` \| `number` ; `outcome`: `"unavailable"` \| `"blocked"` = facts.state; `reason`: `string` = “Provider state is not ready” } \| { `configurationDigest`: `string` = args.configurationDigest; `definitionDigest`: `string` ; `revision`: `string` ; `source`: `null` \| { `id`: `string` ; `installation`: `string` ; `location`: { incarnation: string; branch: { key: string; generation: string; } \| null; deployment_id: string; } ; `protocol`: `string` } = facts.source; `validUntil`: `number` ; `outcome`: `"ready"` ; `reason`: `null` = null }>>

​Interfaces

​References

​bothAccessResults

​servicePrincipal

​AccessInspection

​AccessInspectionBasis

​AccessRecoveryOffer

​AccessTrace

​DisclosureArgs

​ExecutionDescriptor

​ReadAccessArgs

​Type Aliases

​RetainedPermission

​Type declaration

​AccessReadExecution

​AccessInstallation

​Type declaration

​AssignmentListing

​AccessResourceDefinition

​AccessDefinitionInput

​AccessDefinitionRequirement

​Type declaration

​AccessResourceBinding

​Type parameters

​AccessDocumentBinding

​Type parameters

​SourceReadAccessBinding

​Type parameters

​Type declaration

​PrincipalSourceTable

​Type parameters

​Type declaration

​Binding

​Type declaration

​ClassifiedRead

​Type parameters

​ProfileCondition

​Type declaration

Type parameters

Parameters

Returns

​ReadPermission

​Type parameters

​ProfileReadCondition

​Type declaration

Type parameters

Parameters

Returns

​ClassifiedBinding

​Type parameters

​ClassificationCategory

​Type declaration

​ClassificationKey

​Type parameters

​LabelRegistrySnapshot

​Type declaration

​RegistryCategories

​Type parameters

​RegistryBinding

​ClassificationProfile

​Type parameters

​Selection

​Destination

​ComponentInstallationAccessRequest

​Type declaration

​ComponentWorkerAccessRequest

​Type parameters

​Type declaration

​ComponentAccessRequest

​ComponentWorkConsentOptions

​Type parameters

​Type declaration

​ComponentDataConsent

​Type declaration

​CompiledComponentBinding

​Type declaration

​ComponentWorkBinding

​AccessClaimType

​CompiledConferEnvelope

​Type declaration

Interfaces

References

bothAccessResults

servicePrincipal

AccessInspection

AccessInspectionBasis

AccessRecoveryOffer

AccessTrace

DisclosureArgs

ExecutionDescriptor

ReadAccessArgs

Type Aliases

RetainedPermission

Type declaration

AccessReadExecution

AccessInstallation

Type declaration

AssignmentListing

AccessResourceDefinition

AccessDefinitionInput

AccessDefinitionRequirement

Type declaration

AccessResourceBinding

Type parameters

AccessDocumentBinding

Type parameters

SourceReadAccessBinding

Type parameters

Type declaration

PrincipalSourceTable

Type parameters

Type declaration

Binding

Type declaration

ClassifiedRead

Type parameters

ProfileCondition

Type declaration

ReadPermission

Type parameters

ProfileReadCondition

Type declaration

ClassifiedBinding

Type parameters

ClassificationCategory

Type declaration

ClassificationKey

Type parameters

LabelRegistrySnapshot

Type declaration

RegistryCategories

Type parameters

RegistryBinding

ClassificationProfile

Type parameters

Selection

Destination

ComponentInstallationAccessRequest

Type declaration

ComponentWorkerAccessRequest

Type parameters

Type declaration

ComponentAccessRequest

ComponentWorkConsentOptions

Type parameters

Type declaration

ComponentDataConsent

Type declaration

CompiledComponentBinding

Type declaration

ComponentWorkBinding

AccessClaimType

CompiledConferEnvelope

Type declaration

AssignmentHolder

AssignmentDocument

AccessCtx

Type declaration

AccessMutationCtx

Type declaration