@wildo-ai/saas-models 1.1.4 → 1.1.5

package/dist/esm/compliance/audit-trails/auditable-events.shared.schema.d.ts

@@ -1,7 +1,11 @@
+import { AuditApplicationReadAccess } from './audit-trail-config.shared.schemas';
 import { z } from "zod";
+import { ExternalProvider_Connection_DelegationMode } from "@wildo-ai/external-connectors-models";
+import { RegistrationAcquisitionChannel } from "../../config/entity-identity-config.shared.schemas";
 import { ResourceOperationRiskLevel, ResourceOperationVariantType } from "../../resources/resources.shared.schemas";
 import { CoreResourceOperation } from "../../resources/resources.shared.core.definitions";
 import { PlatformAccessGrantAutoApprovalReason, PlatformAccessGrantLifecycleTransition, PlatformAccessGrantScope, PlatformAccessGrantStatus } from "../../security/authorizations/platform-access-grants.shared.schemas";
+import { SystemOfRecordPartitionAssignmentTransition } from "../../systems-of-record/system-of-record-partition-assignments.shared.schemas";
 import { ExecutionContext_ExecutionType } from "../../runtime/execution-context.shared.schemas";
 import { AuthScopeType, SsoConnectionType } from "../../security/authentications/authentication.shared.schemas";
 import { WebhookEndpointProbeOutcome } from "../../notifications/m2m/webhook-config.shared.schemas";
@@ -54,6 +58,11 @@ export declare enum CoreAuditableEventType {
     ORGANIZATION_OWNER_FLOOR_BREACHED = "organization_owner_floor_breached",
     ORGANIZATION_CREATED = "organization_created",
     ORGANIZATION_UPDATED = "organization_updated",
+    /**
+     * The engine assigned an organization its `type`, at boot, with no actor — see
+     * {@link AuditableEvent_Organization_TypeAssignedEventDataSchema} for why this is not an `ORGANIZATION_UPDATED`.
+     */
+    ORGANIZATION_TYPE_ASSIGNED = "organization_type_assigned",
     ORGANIZATION_DELETED = "organization_deleted",
     /** The tenant was MARKED for deletion (soft-delete). Its access dies here; its data dies at the purge. */
     ORGANIZATION_DELETION_REQUESTED = "organization_deletion_requested",
@@ -93,10 +102,42 @@ export declare enum CoreAuditableEventType {
     ORGANIZATION_UNIT_MEMBER_REMOVED = "organization_unit_member_removed",
     USER_SSO_LOGIN = "user_sso_login",
     USER_SSO_LOGIN_FAILED = "user_sso_login_failed",
+    /**
+     * A tenant that mandates its identity provider refused a local sign-in or an acquisition.
+     *
+     * Emitted since #1214/#1242 by `_enforceEnterpriseSsoOnLocalFirstFactor` (every local first-factor
+     * door), by the grace-login gate's three refusal clauses, and by the registration door's
+     * `blockForSSODomains` block. `enforcementPolicy` carries WHICH clause refused, because "the tenant
+     * allows no fallback" and "this account has spent its grace logins" have different remedies and a
+     * bare `sso_required` cannot tell them apart.
+     *
+     * ONE refusal site remains unwired and is tracked on #1242: the SOCIAL-vs-enforcement refusal in
+     * `oauth2-authentication.backend.service.ts`, whose sibling provider-restriction refusal ten lines
+     * below it already emits `logOAuth2ProviderBlocked`.
+     *
+     * Deliberately NOT emitted by the fail-closed refusals that share the same error — a Redis read
+     * that failed, the outer catch. Those are infrastructure outcomes, and recording them as an
+     * enforcement decision would assert a policy judgement nobody made.
+     */
     USER_SSO_ENFORCEMENT_BLOCKED = "user_sso_enforcement_blocked",
     USER_TOKEN_REFRESHED = "user_token_refreshed",
     ORGANIZATION_SSO_CONFIGURATION_CHANGED = "organization_sso_configuration_changed",
+    /** A change to where an organization's security events are exported: enabled, or a field other than the destination edited. INFO. */
     ORGANIZATION_SIEM_EXPORT_CONFIGURED = "organization_siem_export_configured",
+    /**
+     * Security-event export was turned OFF (#986). Its own kind, at CRITICAL, because the envelope's rule
+     * is that severity is a property of the event TYPE and danger rides the row's `riskLevel` — and
+     * `riskLevel` never reaches the SIEM. As one INFO kind, "export disabled" was filtered out by any
+     * organization that raised its severity minimum, on the one destination that most needed it.
+     * Delivered to the destination that STOPPED, as its last event (`dispatchToRetiredSiemSink`).
+     */
+    ORGANIZATION_SIEM_EXPORT_DISABLED = "organization_siem_export_disabled",
+    /**
+     * Security-event export was re-pointed at another destination (#986). WARNING: a destination move is
+     * how an attacker who reached the tenant's administration diverts the trail. Delivered to BOTH the
+     * old and the new destination.
+     */
+    ORGANIZATION_SIEM_EXPORT_DESTINATION_CHANGED = "organization_siem_export_destination_changed",
     ORGANIZATION_PROVIDER_CREDENTIAL_SET = "organization_provider_credential_set",
     ORGANIZATION_PROVIDER_CREDENTIAL_ROTATED = "organization_provider_credential_rotated",
     ORGANIZATION_PROVIDER_CREDENTIAL_USED = "organization_provider_credential_used",
@@ -183,6 +224,15 @@ export declare enum CoreAuditableEventType {
     FILE_UPLOAD_GRANT_ISSUED = "file_upload_grant_issued",
     FILE_UPLOAD_GRANT_REDEEMED = "file_upload_grant_redeemed",
     FILE_UPLOAD_GRANT_REVOKED = "file_upload_grant_revoked",
+    /**
+     * File share links (#1567). A share is a bearer link that serves ONE file to whoever holds it, with no
+     * session at all — the widest disclosure the file plane can make, so minting one is audited like a
+     * grant. `ISSUED` carries the file, its owning record/field binding, the expiry and the use budget —
+     * never the token value. `REVOKED` is "stop sharing this file" (`DELETE /files/:fileId/shares`) and
+     * carries how many live links it ended; a revocation that ended none records nothing.
+     */
+    FILE_SHARE_LINK_ISSUED = "file_share_link_issued",
+    FILE_SHARE_LINKS_REVOKED = "file_share_links_revoked",
     /**
      * A scanner concluded that an uploaded file is INFECTED, and the file was quarantined.
      *
@@ -224,6 +274,27 @@ export declare enum CoreAuditableEventType {
     RESOURCE_OPERATION_DENIED = "resource_operation_denied",
     CROSS_TENANT_ADMINISTRATIVE_ACCESS = "cross_tenant_administrative_access",
     PLATFORM_ACCESS_GRANT_LIFECYCLE = "platform_access_grant_lifecycle",
+    /**
+     * A remote partition of a system of record was assigned to, moved between, or removed from an
+     * organization unit.
+     *
+     * ONE event for the whole life of the edge, with a {@link SystemOfRecordPartitionAssignmentTransition}
+     * field — the `platformAccessGrants` shape rather than three event types. Three types would put the
+     * same row's timeline in three buckets a reviewer has to reassemble, and the questions an auditor
+     * actually asks ("who has been able to see the German company, and since when?") are answered by
+     * reading one bucket in order.
+     *
+     * ## Why this exists beside the automatic row
+     *
+     * All three write verbs are HIGH, which is inside `AUTOMATIC_AUDIT_RISK_FLOOR`, so
+     * `RESOURCE_OPERATION_PERFORMED` already fires for each. What that row cannot carry is the thing a
+     * reviewer needs: which unit, and — on a move — which unit it was BEFORE. A generic operation row
+     * says an assignment changed; this one says what it changed from and to.
+     *
+     * assurance-control: WILDO.ACCESS.LEAST_PRIVILEGE — the reach of each remote partition is recorded.
+     * assurance-control: WILDO.ACCESS.PRIVILEGE_EVIDENCE — evidence of the full life of that reach.
+     */
+    SYSTEM_OF_RECORD_PARTITION_ASSIGNMENT_LIFECYCLE = "system_of_record_partition_assignment_lifecycle",
     /**
      * An operator enumerated an APPLICATION-WIDE directory — a collection read that is deliberately
      * not confined to any one tenant.
@@ -264,13 +335,17 @@ export declare enum CoreAuditableEventType {
     PLATFORM_DIRECTORY_ACCESS = "platform_directory_access",
     SYSTEM_CONTEXT_READ = "system_context_read",
     SYSTEM_CONTEXT_WRITE = "system_context_write",
+    /** Platform owner publication of application/service configuration; safe field names, caller and outcome only. */
+    PLATFORM_CONFIGURATION_PUBLICATION = "platform_configuration_publication",
     RETAINED_DATA_ACCESS = "retained_data_access",
+    GOVERNED_DOCUMENT_INTERACTION_RECORDED = "governed_document_interaction_recorded",
     SUBJECT_DATA_EXPORT = "subject_data_export",
     COLLECTION_DATA_EXPORT = "collection_data_export",
     HTTP_API_READ_THROUGH_ACCESS = "http_api_read_through_access",
     HTTP_API_EXTERNAL_ERASURE = "http_api_external_erasure",
     HTTP_API_NON_ERASURE_ACKNOWLEDGED = "http_api_non_erasure_acknowledged",
     PROVIDER_OPERATION_CALL = "provider_operation_call",
+    PROVIDER_OPERATION_DENIED = "provider_operation_denied",
     MCP_TOOL_CALL = "mcp_tool_call",
     AGENT_TOOL_APPROVAL_MODIFIED = "agent_tool_approval_modified",
     /** A user-delegated `authorization_code` access token was minted for a third-party client
@@ -382,6 +457,65 @@ export declare function describeAuditVocabulary(lead: string, meanings: Readonly
     readonly name: string;
     readonly meaning: string;
 }>>): string;
+/**
+ * Why the browser door to a provider operation refused a request (#367). A CLOSED vocabulary: the door
+ * resolves exactly one of these per refusal, in the order listed, and a reviewer groups by it.
+ *
+ * Deliberately NOT a reuse of {@link ResourceOperationDenialReason}. The two doors ask different
+ * questions of different declarations — that one checks an operation variant's roles and a row's scope,
+ * this one checks an application's browser-reachability policy and whose third-party account is named —
+ * and sharing members would make "insufficient roles" mean two things in one column.
+ */
+/**
+ * What a provider operation's `requiredScopes` check concluded for one call (#979).
+ *
+ * Carried on {@link AuditableEvent_ProviderOperationCall_EventDataSchema} only when the operation declares required
+ * scopes; an operation declaring none carries no scope field at all, rather than a verdict about nothing.
+ */
+export declare enum ProviderOperationScopeCheck {
+    /** The grant recorded its scopes and every required one is among them. The call proceeded. */
+    VERIFIED = "verified",
+    /**
+     * The spent credential records no granted scopes — a pasted key, the application's own credential, or a vendor
+     * that did not echo `scope`. The call proceeded UNCHECKED, and this row is what says so.
+     */
+    NOT_RECORDED = "not_recorded",
+    /** The grant recorded its scopes and lacks at least one required scope. The call was refused before any request. */
+    MISSING = "missing"
+}
+export declare enum ProviderOperationDenialReason {
+    /**
+     * The caller authenticated without a person — an application API key, a machine identity. This door
+     * exists for a signed-in person's browser, and the policy's roles and the target-authorization port
+     * both reason about a person; a backend caller has the executor and the typed client instead.
+     */
+    MISSING_USER_SESSION = "missing_user_session",
+    /**
+     * The application's `providers.browserOperations` names no policy for this provider and operation.
+     * The fail-closed default: nothing is reachable from a browser unless declared. Also the answer for an
+     * operation that does not exist, so a refusal never reveals what a catalogue contains.
+     */
+    NOT_BROWSER_REACHABLE = "not_browser_reachable",
+    /** The request names a connection shape — owner scope × delegation — the operation's policy does not admit. */
+    CONNECTION_NOT_ADMITTED = "connection_not_admitted",
+    /**
+     * The policy declares roles and the target is the caller's OWN user account, over which nobody holds a
+     * role. A policy mistake rather than a caller's, recorded as its own reason so it is not read as a
+     * person lacking a role they could be granted.
+     */
+    ROLES_NOT_APPLICABLE_TO_TARGET = "roles_not_applicable_to_target",
+    /**
+     * The target-authorization port refused: the caller named an organization they do not belong to
+     * organization-wide, or a user account that is not their own.
+     */
+    TARGET_NOT_AUTHORIZED = "target_not_authorized",
+    /**
+     * The caller may act for the account, and holds none of the policy's roles — after hierarchy
+     * expansion, in the scope of that account. Checked AFTER {@link TARGET_NOT_AUTHORIZED}, so a person
+     * naming a tenant they do not belong to is recorded as that, not as a person short of a role.
+     */
+    INSUFFICIENT_ROLES = "insufficient_roles"
+}
 /**
  * Why the authorizer refused an operation. A CLOSED vocabulary — the authorizer resolves exactly
  * one of these per refusal, and a SOC dashboard groups by it.
@@ -392,6 +526,20 @@ export declare function describeAuditVocabulary(lead: string, meanings: Readonly
  * enumeration.
  */
 export declare enum ResourceOperationDenialReason {
+    /**
+     * The application requires consent purposes before it may be used
+     * (`compliance.serviceConsentRequirement`), and this person has not granted them (#534). The person is
+     * authenticated and may hold every role the operation needs; what is missing is their own decision.
+     * Distinct from every role/scope reason, because the remedy is the person's choice, not an administrator's.
+     */
+    SERVICE_CONSENT_REQUIRED = "service_consent_required",
+    /**
+     * ONE operation declared the purpose its own processing rests on
+     * (`ResourceOperationConsentGateDeclaration`), and this person has not granted it (#1258 Step 3).
+     * Distinct from {@link SERVICE_CONSENT_REQUIRED}: only this operation was refused, never the whole
+     * application.
+     */
+    CAPABILITY_CONSENT_REQUIRED = "capability_consent_required",
     /**
      * No initiator identity or roles on the execution context. Fail-closed: the authorizer refuses
      * rather than assuming an anonymous caller.
@@ -457,7 +605,70 @@ export declare enum ResourceOperationDenialReason {
      *
      * assurance-control: WILDO.ACCESS.AUTHORIZATION_DECISION_AUDIT
      */
-    APPLICATION_WIDE_ELEVATION_MISSING = "application_wide_elevation_missing"
+    APPLICATION_WIDE_ELEVATION_MISSING = "application_wide_elevation_missing",
+    /**
+     * The caller tried to GRANT authority it does not itself hold — a privilege-escalation attempt,
+     * refused by the role-ceiling gate (`assertRequestedRolesWithinCallerCeiling`).
+     *
+     * Its own member rather than {@link INSUFFICIENT_ROLES}, for the same reason
+     * {@link APPLICATION_WIDE_ELEVATION_MISSING} is: the caller PASSED the operation's role check —
+     * an `ORG_ADMIN` really may update a membership — and was refused on the CONTENT of the write.
+     * Folding the two together would make the single refusal an access review most wants to see
+     * indistinguishable from the everyday "you are not an admin", and a reviewer asking "has anyone
+     * tried to escalate?" would have nothing to count.
+     *
+     * Uniquely among the members here, the row carries {@link
+     * AuditableEvent_ResourceOperationDenied_EventDataSchema.escalatedRoles} — the roles that were
+     * actually asked for. `requiredRoles` and `initiatorRoles` cannot express it: neither is the set
+     * the caller tried to confer on somebody else.
+     *
+     * Raised OUTSIDE the authorization phase — the gate runs in custom-implementation prefixes, after
+     * the authorizer has returned — so it does not reach `classifyAuthorizationDenial`. The gate emits
+     * it directly through the same chokepoint, keeping the dedup window, the logarithmic escalation
+     * ladder and the loss counters.
+     *
+     * assurance-control: WILDO.ACCESS.LEAST_PRIVILEGE — an attempt to grant authority the caller does
+     * not hold is refused AND recorded.
+     * assurance-control: WILDO.ACCESS.AUTHORIZATION_DECISION_AUDIT
+     */
+    ROLE_CEILING_EXCEEDED = "role_ceiling_exceeded",
+    /**
+     * A high-impact action was refused because the operation ITSELF demands a fresh re-proof of
+     * identity (`requiresStepUpAuthentication`), and the caller presented none.
+     *
+     * The caller is authenticated and may hold every role the operation needs. What is missing is a
+     * ceremony, so this belongs with {@link SERVICE_CONSENT_REQUIRED} rather than with
+     * {@link INSUFFICIENT_ROLES}: the remedy is an act by the same person, not a grant by an
+     * administrator.
+     *
+     * Paired with {@link STEP_UP_REQUIRED_BY_FRESHNESS} for the reason the two consent members are
+     * paired — the missing thing is the same and the party that DEMANDED it is not, and the two read
+     * very differently in a review. A burst of these is somebody repeatedly attempting an action the
+     * application has declared dangerous; a burst of the other is sessions ageing out.
+     *
+     * Raised OUTSIDE the authorization phase, like {@link ROLE_CEILING_EXCEEDED}: the step-up gate is
+     * a private check at the services-registry tier that throws without passing through the
+     * authorizer, so it reaches no `classifyAuthorizationDenial`. It emits through the same chokepoint
+     * instead, keeping the dedup window, the escalation ladder and the loss counters.
+     *
+     * assurance-control: WILDO.IDENTITY.STEP_UP_AUTHENTICATION — a refused high-impact action is
+     * recorded, not merely refused.
+     * assurance-control: WILDO.ACCESS.AUTHORIZATION_DECISION_AUDIT
+     */
+    STEP_UP_REQUIRED_BY_OPERATION = "step_up_required_by_operation",
+    /**
+     * The same refusal, demanded by the USER TYPE's freshness policy (`UserTypeAuthPolicy.stepUpAuth`)
+     * rather than by the operation: the caller's authentication is older than the declared maximum age.
+     *
+     * Distinct from {@link STEP_UP_REQUIRED_BY_OPERATION} because the two send a reviewer to different
+     * places — one to the operation's own declaration, the other to the user-type policy — and because
+     * only this one varies with how long a person has been signed in. The refusal's own error context
+     * already carried the distinction before either was audited; this keeps it in the durable record.
+     *
+     * assurance-control: WILDO.IDENTITY.STEP_UP_AUTHENTICATION
+     * assurance-control: WILDO.ACCESS.AUTHORIZATION_DECISION_AUDIT
+     */
+    STEP_UP_REQUIRED_BY_FRESHNESS = "step_up_required_by_freshness"
 }
 /** SSO configuration change type. */
 export declare enum SsoConfigChangeType {
@@ -521,8 +732,26 @@ export declare enum MachineAccessOperation {
      */
     A2A_TASKS_LIST = "a2a_tasks_list",
     MCP_TOOLS_LIST = "mcp_tools_list",
-    MCP_TOOLS_CALL = "mcp_tools_call"
+    MCP_TOOLS_CALL = "mcp_tools_call",
+    /**
+     * A MACHINE principal's READ / LIST / SEARCH on a DECLARED cross-tenant REST door
+     * (`admitsCrossTenantPlatformAdministration`) — today the application audit-log door.
+     *
+     * Deliberately NOT every REST call a machine makes: the plain resource API is audited per operation
+     * through `RESOURCE_OPERATION_PERFORMED`, which carries `machineCredentialId`. These three exist because a
+     * declared crossing's only other row, `CROSS_TENANT_ADMINISTRATIVE_ACCESS`, is written per TENANT REACHED —
+     * so a machine read returning only application-wide rows, or nothing, left no row naming who read (#297).
+     * One member per verb, like the A2A task members: a LIST enumerates, a READ fetches a row somebody named.
+     */
+    API_READ = "api_read",
+    API_LIST = "api_list",
+    API_SEARCH = "api_search"
 }
+/**
+ * The MACHINE_ACCESS identifier for an executed REST read, or `undefined` for any verb that is not one.
+ * The one place the core-operation → audit-vocabulary mapping lives, so a recorder never spells it.
+ */
+export declare function resolveApiReadMachineAccessOperation(operation: CoreResourceOperation | undefined): MachineAccessOperation | undefined;
 export declare const AuditableEventTypeSchema: z.ZodUnion<readonly [z.ZodEnum<typeof CoreAuditableEventType>, z.ZodString]>;
 export declare const AuditableEvent_User_LoginEventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_LOGIN>;
@@ -836,6 +1065,7 @@ export declare const AuditableEvent_OrganizationMember_RoleChangedEventDataSchem
     requestedRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     operation: z.ZodString;
     changedBy: z.ZodString;
+    justification: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Per-unit role assignment on an `ORGANIZATION_UNIT_MEMBERS` row.
@@ -973,6 +1203,85 @@ export declare const AuditableEvent_Organization_UpdatedEventDataSchema: z.ZodOb
     changes: z.ZodRecord<z.ZodString, z.ZodAny>;
     updatedBy: z.ZodString;
 }, z.core.$strip>;
+/**
+ * WHY an organization was assigned the type it now carries, when no person chose it.
+ *
+ * A closed vocabulary, deliberately named rather than implied: the assignment is only defensible because the answer
+ * was DERIVED, and a reader of the audit row must be able to see which derivation produced it without re-deriving
+ * the application's configuration — or its membership rows — as they stood at that boot. The two members answer
+ * from different evidence, which is exactly why a single "derived" value would not do: one is a fact about the
+ * DECLARATION and stays true however the tenant changes, the other is a fact about the ORGANIZATION on one day.
+ */
+export declare enum OrganizationTypeAssignmentBasis {
+    /**
+     * The application declares exactly one organization type, so an organization whose type resolves to nothing —
+     * none stored, or one the declaration no longer carries — can only be that type: it is the only policy the
+     * application has. Nothing is guessed, and nothing about the organization was read.
+     */
+    SOLE_DECLARED_TYPE = "sole_declared_type",
+    /**
+     * The application declares several organization types, and exactly one of them covers every user type held by
+     * this organization's own members — so the others are types this organization cannot be. Nothing is guessed: it
+     * is the coverage test the first-administrator organization's type is already derived by, asked of the members.
+     *
+     * Narrower than {@link SOLE_DECLARED_TYPE} in what it proves. It reports the answer for the membership as it
+     * stood at that boot; an organization whose members later span two declared types would not derive again. That is
+     * why the row records the basis rather than only the outcome — a reviewer asking "could this have been wrong?"
+     * needs to know which question was answered.
+     */
+    MEMBER_USER_TYPES = "member_user_types",
+    /**
+     * An operator promoted this organization to the one that OWNS the application, through
+     * `organizations.promoteToOwnerOrganization` (#1054).
+     *
+     * The odd one out of the three, and deliberately kept in the same event rather than given its own.
+     * What the event records is "this organization's `type` changed, and here is what decided it" — true
+     * of all three — and an access reviewer asking "how did this tenant come to be typed this way?" must
+     * find one row wherever the answer lies, not two events they have to know to look for separately.
+     *
+     * What differs is everything a derivation does not have: there IS an actor (the audit row carries
+     * them, and {@link AuditableEvent_Organization_TypeAssignedEventData.justification} carries their
+     * stated reason), the previous type is always present, and the decision was a human's. A row
+     * carrying this basis is the only one on which `justification` may appear — the other two are
+     * derivations, and a derivation has nothing to justify.
+     */
+    OPERATOR_PROMOTION = "operator_promotion"
+}
+/**
+ * An organization whose type resolved to nothing — none stored, or one no longer declared — was assigned one by the
+ * engine at boot.
+ *
+ * ## Why this is its own event rather than an `ORGANIZATION_UPDATED`
+ *
+ * An organization's type is not a label. It decides which user types its members hold, which authentication
+ * methods they may use, and which step-up policy applies to them — so assigning one changes what every member of
+ * that tenant can do at sign-in. Folded into a generic `changes` map it would be an authentication-relevant
+ * change with no actor, filed where an access review does not look.
+ *
+ * ## Who the actor is, per basis
+ *
+ * For the two DERIVATIONS there is none, and that is the point: organizations minted before the type was required
+ * (the platform's own seeds, the first-administrator bootstrap) were typeless, and the engine repairs them before
+ * the first read that would refuse them. `basis` is what makes that repair legible as a derivation instead of a
+ * write nobody made, and those rows carry no `userId` because the application-scope repair has no initiator.
+ *
+ * For {@link OrganizationTypeAssignmentBasis.OPERATOR_PROMOTION} there IS one. It rides where every other
+ * operator action's actor does — on the audit ROW, resolved from the execution context — rather than as a field
+ * here, so an access review reads it the same way it reads a suspension or an ownership grant. What this schema
+ * adds for that basis is the one thing the row cannot carry: the operator's stated REASON (`RESOURCE_OPERATION_PERFORMED`
+ * carries no request payload, which is how `grantOwnership`'s required justification went unrecorded for months — #593).
+ *
+ * assurance-control: WILDO.AUDIT.SECURITY_EVENT — an authentication-relevant attribute of a tenant changed, and the
+ * record says what decided it and, when a person did, who and why.
+ */
+export declare const AuditableEvent_Organization_TypeAssignedEventDataSchema: z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_TYPE_ASSIGNED>;
+    organizationId: z.ZodString;
+    organizationType: z.ZodString;
+    previousType: z.ZodOptional<z.ZodString>;
+    basis: z.ZodEnum<typeof OrganizationTypeAssignmentBasis>;
+    justification: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const AuditableEvent_Organization_DeletedEventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_DELETED>;
     organizationId: z.ZodString;
@@ -1101,13 +1410,14 @@ export declare const AuditableEvent_Organization_ActivatedEventDataSchema: z.Zod
  */
 export declare const ApplicationAuthPolicySnapshotSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 /**
- * The application's authored authentication policy changed between two boots.
+ * The application's authored authentication or audit-viewer admission policy changed between two boots.
  *
  * The per-user-type authentication policy (`userTypes.<type>.auth` — MFA, password, and lockout
  * requirements) is STATIC application configuration authored in code and taken into effect at backend
  * startup. A change to it — most consequentially a WEAKENING such as turning MFA off — is a
  * security-posture decision that, before this event, left no product-side record: only the source
- * history showed it. This event closes that gap.
+ * history showed it. This event closes that gap. The effective `auditTrail.applicationReadAccess`
+ * posture is recorded separately from the user-type snapshots and compared independently.
  *
  * It is emitted at boot, by the system, when the resolved policy snapshot differs from the last one
  * recorded in the trail (detected by comparing against the most recent event of this type for the
@@ -1129,6 +1439,10 @@ export declare const AuditableEvent_ApplicationAuthPolicyChanged_EventDataSchema
     snapshotDigest: z.ZodString;
     before: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     after: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    auditApplicationReadAccess: z.ZodOptional<z.ZodObject<{
+        before: z.ZodNullable<z.ZodEnum<typeof AuditApplicationReadAccess>>;
+        after: z.ZodEnum<typeof AuditApplicationReadAccess>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * A governed lifecycle transition changed a subject's `status`.
@@ -1188,6 +1502,11 @@ export declare const AuditableEvent_OrganizationUnit_UpdatedEventDataSchema: z.Z
     updatedBy: z.ZodString;
 }, z.core.$strip>;
 export declare const AuditableEvent_User_SSOLoginEventDataSchema: z.ZodObject<{
+    assurance: z.ZodOptional<z.ZodObject<{
+        decision: z.ZodEnum<typeof import("../..").ExternalAssuranceDecision>;
+        reason: z.ZodEnum<typeof import("../..").ExternalAssuranceReason>;
+        enforcement: z.ZodEnum<typeof import("../..").ExternalAssuranceEnforcement>;
+    }, z.core.$strip>>;
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_SSO_LOGIN>;
     userId: z.ZodString;
     email: z.ZodEmail;
@@ -1202,6 +1521,11 @@ export declare const AuditableEvent_User_SSOLoginEventDataSchema: z.ZodObject<{
     sessionId: z.ZodString;
 }, z.core.$strip>;
 export declare const AuditableEvent_User_SSOLoginFailedEventDataSchema: z.ZodObject<{
+    assurance: z.ZodOptional<z.ZodObject<{
+        decision: z.ZodEnum<typeof import("../..").ExternalAssuranceDecision>;
+        reason: z.ZodEnum<typeof import("../..").ExternalAssuranceReason>;
+        enforcement: z.ZodEnum<typeof import("../..").ExternalAssuranceEnforcement>;
+    }, z.core.$strip>>;
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_SSO_LOGIN_FAILED>;
     email: z.ZodOptional<z.ZodEmail>;
     providerRef: z.ZodOptional<z.ZodString>;
@@ -1214,12 +1538,29 @@ export declare const AuditableEvent_User_SSOLoginFailedEventDataSchema: z.ZodObj
     ipAddress: z.ZodString;
     userAgent: z.ZodString;
 }, z.core.$strip>;
+/**
+ * A sign-in was refused because the claiming scope requires SSO (#1242).
+ *
+ * `organizationId` was REQUIRED here, and that is what made the event unemittable at half its own
+ * refusal sites: `enforcement.requireSSO` lives on the POLYMORPHIC SSO config, so an APPLICATION-scope
+ * policy refuses sign-ins for the application itself and there is no organization to name. Requiring
+ * one would have left exactly those refusals with no trail — the outcome this CRITICAL event exists to
+ * prevent. It now carries either scope and refuses anything but exactly one, following
+ * `EMERGENCY_ACCESS_USED`, which was widened for the same reason on the same config.
+ *
+ * `attemptedProviderRef` and `attemptedConnectionType` are OPTIONAL because two of the four refusal
+ * sites have no attempted provider at all: a password sign-in and a registration are refused BECAUSE
+ * no SSO was attempted. Requiring them would have forced a placeholder, and a placeholder in an
+ * audit row is worse than an absent field — it is a fact nobody can distinguish from a real one.
+ */
 export declare const AuditableEvent_User_SSOEnforcementBlockedEventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_SSO_ENFORCEMENT_BLOCKED>;
     email: z.ZodEmail;
-    attemptedProviderRef: z.ZodString;
-    attemptedConnectionType: z.ZodEnum<typeof SsoConnectionType>;
-    organizationId: z.ZodString;
+    attemptedProviderRef: z.ZodOptional<z.ZodString>;
+    attemptedConnectionType: z.ZodOptional<z.ZodEnum<typeof SsoConnectionType>>;
+    scopeType: z.ZodEnum<typeof AuthScopeType>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    applicationId: z.ZodOptional<z.ZodString>;
     enforcementPolicy: z.ZodString;
     ipAddress: z.ZodString;
     userAgent: z.ZodString;
@@ -1240,12 +1581,33 @@ export declare const AuditableEvent_Organization_SSOConfigurationChangedEventDat
     changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strip>;
 export declare const AuditableEvent_Organization_SIEMExportConfiguredEventDataSchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    changedBy: z.ZodString;
+    changeType: z.ZodEnum<typeof SiemExportChangeType>;
+    webhookUrlDomain: z.ZodOptional<z.ZodString>;
+    eventFormatConfigured: z.ZodOptional<z.ZodString>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_SIEM_EXPORT_CONFIGURED>;
+}, z.core.$strip>;
+/** Export turned OFF (#986). Same fields; its own kind so it classifies CRITICAL. */
+export declare const AuditableEvent_Organization_SIEMExportDisabledEventDataSchema: z.ZodObject<{
     organizationId: z.ZodString;
     changedBy: z.ZodString;
     changeType: z.ZodEnum<typeof SiemExportChangeType>;
     webhookUrlDomain: z.ZodOptional<z.ZodString>;
     eventFormatConfigured: z.ZodOptional<z.ZodString>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_SIEM_EXPORT_DISABLED>;
+}, z.core.$strip>;
+/** Export re-pointed at another destination (#986). Same fields; its own kind so it classifies WARNING. */
+export declare const AuditableEvent_Organization_SIEMExportDestinationChangedEventDataSchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    changedBy: z.ZodString;
+    changeType: z.ZodEnum<typeof SiemExportChangeType>;
+    webhookUrlDomain: z.ZodOptional<z.ZodString>;
+    eventFormatConfigured: z.ZodOptional<z.ZodString>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_SIEM_EXPORT_DESTINATION_CHANGED>;
 }, z.core.$strip>;
 /**
  * A tenant granted this application authority to act as it toward a third party.
@@ -1298,6 +1660,7 @@ export declare const AuditableEvent_OrganizationProviderCredential_UsedEventData
     secretSlug: z.ZodString;
     resolvedFrom: z.ZodEnum<typeof ProviderCredentialResolutionSource>;
     credentialId: z.ZodOptional<z.ZodString>;
+    credentialSetByUserId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * The grant ended — by the tenant removing it, or by the tenant itself being purged.
@@ -1316,6 +1679,7 @@ export declare const AuditableEvent_OrganizationProviderCredential_DeletedEventD
     deletedBy: z.ZodOptional<z.ZodString>;
     credentialId: z.ZodString;
     reason: z.ZodEnum<typeof ProviderCredentialDeletionReason>;
+    vendorRevocation: z.ZodOptional<z.ZodEnum<typeof import("../..").ProviderOAuth2RevocationOutcome>>;
 }, z.core.$strip>;
 /**
  * A PERSON connected their own account at a third party to this application.
@@ -1389,6 +1753,8 @@ export declare const AuditableEvent_OrganizationProviderConnection_GrantedEventD
     grantedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     accountRef: z.ZodOptional<z.ZodString>;
     replacedExistingConnection: z.ZodBoolean;
+    delegation: z.ZodOptional<z.ZodEnum<typeof ExternalProvider_Connection_DelegationMode>>;
+    organizationWideUseAcknowledged: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 /**
  * The stored VALUE changed for a person's credential that already existed.
@@ -1428,25 +1794,34 @@ export declare const AuditableEvent_UserProviderCredential_UsedEventDataSchema:
     credentialId: z.ZodString;
 }, z.core.$strip>;
 /**
- * The person's grant ended — by them removing it, or by their own erasure.
+ * The person's grant ended — by them removing it, by their own erasure, or by their account being deleted.
  *
  * `reason` matters more here than on the organization sibling. A credential removed by a cascade
  * from a subject-erasure request is EVIDENCE that the erasure reached this store, and it is the
  * evidence an operator produces when asked whether a person's third-party keys were destroyed. The
  * row itself is gone by then, so the event is all that remains.
  *
+ * `deletedBy` exists for the one reason whose actor is NOT the person: `reason: USER_DELETED`, an
+ * account deletion (#1016) — an administrator's hard delete or the invitation sweep reaping a pending
+ * user — where it names the deleting principal (the administrator's user id, or the `SYSTEM` sentinel).
+ * Absent on the owner's own revoke, whose actor is `userId` by construction.
+ *
  * assurance-control: WILDO.IDENTITY.DELEGATED_AUTHORIZATION — evidence that delegated authority
  * was withdrawn.
- * assurance-control: WILDO.PRIVACY.ERASURE — evidence that erasure destroyed the subject's
- * third-party credentials.
+ * assurance-control: WILDO.PRIVACY.ERASURE_PROPAGATION — evidence that erasure destroyed the
+ * subject's third-party credentials: one row per destroyed credential with `reason: USER_ERASED`,
+ * written by the credential resource's parent-cascade removal observer because the erasure cascade
+ * removes these rows through the raw repository (#975).
  */
 export declare const AuditableEvent_UserProviderCredential_DeletedEventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_PROVIDER_CREDENTIAL_DELETED>;
     userId: z.ZodString;
     providerRef: z.ZodString;
     secretSlug: z.ZodString;
+    deletedBy: z.ZodOptional<z.ZodString>;
     credentialId: z.ZodString;
     reason: z.ZodEnum<typeof ProviderCredentialDeletionReason>;
+    vendorRevocation: z.ZodOptional<z.ZodEnum<typeof import("../..").ProviderOAuth2RevocationOutcome>>;
 }, z.core.$strip>;
 /**
  * One `webhookConfig.testEndpoint` attempt — an admin causing the platform to open an
@@ -1553,6 +1928,8 @@ export declare const AuditableEvent_User_RegisteredEventDataSchema: z.ZodObject<
     email: z.ZodString;
     ipAddress: z.ZodString;
     userAgent: z.ZodString;
+    acquisitionChannel: z.ZodOptional<z.ZodEnum<typeof RegistrationAcquisitionChannel>>;
+    providerRef: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const AuditableEvent_User_EmailVerifiedEventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_EMAIL_VERIFIED>;
@@ -1859,7 +2236,8 @@ export declare const AuditableEvent_FieldAccess_EventDataSchema: z.ZodObject<{
  *
  * ## Correlation across a cascade
  *
- * Every execution surface emits — API, internal call, and repository-only — so one tenant deletion
+ * The framework-managed lane covers API, internal call and repository-only writes; OVERRIDE_ALL
+ * implementations own their committed emission. A framework-managed tenant deletion
  * produces one row per cascaded child. The top-level `correlationId` is inherited by every sub-call
  * context and preserved across mid-flight operation corrections, so it groups the whole fan-out to one request;
  * `subCallDepth` separates the initiating operation (0) from what it cascaded into.
@@ -1868,7 +2246,8 @@ export declare const AuditableEvent_FieldAccess_EventDataSchema: z.ZodObject<{
  *
  * `changedFields` names every field the write touched — a field NAME is not personal data, so it is
  * always safe and always recorded. `fieldEvidence` carries before/after VALUES only for fields the
- * schema marks `.isAuditEvidence()`.
+ * schema marks `.isAuditEvidence()`. The separate `reason` records an explicitly selected operator
+ * justification, not an arbitrary request payload or a copy of a mutable resource reason field.
  *
  * Values are limited on purpose: audit rows replicate to the per-org SIEM and to the immutable
  * ledger, and **the immutable ledger cannot be scrubbed** — so copying arbitrary personal data into
@@ -1889,11 +2268,13 @@ export declare const AuditableEvent_ResourceOperationPerformed_EventDataSchema:
     isBulkOperation: z.ZodOptional<z.ZodBoolean>;
     resourceId: z.ZodOptional<z.ZodString>;
     affectedRecordCount: z.ZodOptional<z.ZodNumber>;
+    affectedResourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     initiatorRoles: z.ZodArray<z.ZodString>;
     executionType: z.ZodEnum<typeof ExecutionContext_ExecutionType>;
     machineCredentialAuthMethod: z.ZodOptional<z.ZodString>;
     machineCredentialId: z.ZodOptional<z.ZodString>;
     subCallDepth: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
     changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     fieldEvidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         before: z.ZodOptional<z.ZodUnknown>;
@@ -2022,6 +2403,31 @@ export declare const AuditableEvent_PlatformAccessGrantLifecycle_EventDataSchema
     autoApprovalReason: z.ZodOptional<z.ZodEnum<typeof PlatformAccessGrantAutoApprovalReason>>;
     decidedByUserId: z.ZodOptional<z.ZodString>;
     decisionReason: z.ZodOptional<z.ZodString>;
+    grantedMachineCredential: z.ZodOptional<z.ZodObject<{
+        authMethod: z.ZodEnum<typeof import("../..").MachineAuthMethod>;
+        credentialId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * One transition in the life of a system-of-record partition assignment.
+ *
+ * Read it to answer "who could see this remote company, and when did that start or stop". The row
+ * names both units on a move, so a timeline reconstructed from these events is complete without
+ * joining anything: each row carries the state it left as well as the state it reached.
+ *
+ * assurance-control: WILDO.ACCESS.LEAST_PRIVILEGE
+ * assurance-control: WILDO.ACCESS.PRIVILEGE_EVIDENCE
+ */
+export declare const AuditableEvent_SystemOfRecordPartitionAssignmentLifecycle_EventDataSchema: z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.SYSTEM_OF_RECORD_PARTITION_ASSIGNMENT_LIFECYCLE>;
+    transition: z.ZodEnum<typeof SystemOfRecordPartitionAssignmentTransition>;
+    assignmentId: z.ZodString;
+    system: z.ZodString;
+    remoteKey: z.ZodString;
+    organizationUnitId: z.ZodOptional<z.ZodString>;
+    previousOrganizationUnitId: z.ZodOptional<z.ZodString>;
+    justification: z.ZodOptional<z.ZodString>;
+    assignedByUserId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const AuditableEvent_CrossTenantAdministrativeAccess_EventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.CROSS_TENANT_ADMINISTRATIVE_ACCESS>;
@@ -2036,6 +2442,10 @@ export declare const AuditableEvent_CrossTenantAdministrativeAccess_EventDataSch
     admissionDeclared: z.ZodBoolean;
     initiatorRoles: z.ZodArray<z.ZodString>;
     executionType: z.ZodEnum<typeof ExecutionContext_ExecutionType>;
+    machineCredential: z.ZodOptional<z.ZodObject<{
+        authMethod: z.ZodEnum<typeof import("../..").MachineAuthMethod>;
+        credentialId: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * An application-wide directory enumeration.
@@ -2067,6 +2477,8 @@ export declare const AuditableEvent_ResourceOperationDenied_EventDataSchema: z.Z
     isBulkOperation: z.ZodOptional<z.ZodBoolean>;
     attemptedResourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     requiredRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    escalatedRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    refusedSurface: z.ZodOptional<z.ZodString>;
     initiatorRoles: z.ZodArray<z.ZodString>;
     executionType: z.ZodEnum<typeof ExecutionContext_ExecutionType>;
     machineCredentialAuthMethod: z.ZodOptional<z.ZodString>;
@@ -2109,6 +2521,44 @@ export declare const AuditableEvent_RetainedDataAccess_EventDataSchema: z.ZodObj
     organizationId: z.ZodOptional<z.ZodString>;
     ipAddress: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * A person met a governed document, and this is the release they met.
+ *
+ * `interaction` is the composed record from `composeGovernedDocumentInteraction`, which has already
+ * refused anything the release does not permit and marked anything the workflow has not finished.
+ * It is nested rather than flattened so there is ONE shape for a governed-document interaction — a
+ * second, flatter copy here would be a second thing to keep in step with the release vocabulary.
+ *
+ * The SUBJECT is the audit envelope's own actor attribution plus `userId` here, never a third
+ * spelling inside the record; see the interaction schema's JSDoc for why.
+ *
+ * assurance-control: WILDO.PRIVACY.CONSENT_RECORD
+ */
+export declare const AuditableEvent_GovernedDocument_InteractionRecordedEventDataSchema: z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.GOVERNED_DOCUMENT_INTERACTION_RECORDED>;
+    userId: z.ZodOptional<z.ZodString>;
+    anonymousUserId: z.ZodOptional<z.ZodString>;
+    interaction: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        interactionKind: z.ZodEnum<typeof import("../..").GovernedDocumentInteractionKind>;
+        release: z.ZodObject<{
+            document: z.ZodObject<{
+                documentRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                documentVersion: z.ZodNumber;
+            }, z.core.$strict>;
+            releaseId: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+            releaseVersion: z.ZodNumber;
+        }, z.core.$strict>;
+        documentClass: z.ZodEnum<typeof import("../..").GovernedDocumentClass>;
+        locale: z.ZodString;
+        jurisdictionRefs: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">>;
+        releaseApprovalState: z.ZodEnum<typeof import("../..").GovernedDocumentReleaseApprovalState>;
+        acceptanceMode: z.ZodOptional<z.ZodEnum<typeof import("../..").GovernedDocumentAcceptanceMode>>;
+        occurredAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    advisoryKinds: z.ZodArray<z.ZodString>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * A DATA SUBJECT EXPORT — the compliance record of the framework assembling everything it holds
  * about one person and disclosing it.
@@ -2209,6 +2659,32 @@ export declare const AuditableEvent_ProviderOperationCall_EventDataSchema: z.Zod
     connectionDelegation: z.ZodString;
     status: z.ZodOptional<z.ZodNumber>;
     failureKind: z.ZodOptional<z.ZodString>;
+    scopeCheck: z.ZodOptional<z.ZodEnum<typeof ProviderOperationScopeCheck>>;
+    missingScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    initiatorUserId: z.ZodOptional<z.ZodString>;
+    executionType: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The browser door REFUSED a provider operation (#367) — see the enum member for why this is not a
+ * failed call.
+ *
+ * Ids and shape only, like its call sibling: the request's `input` is never recorded. What the caller
+ * ASKED FOR is recorded even when it names nothing real, because a refusal records an attempt rather
+ * than proving the provider or operation exists.
+ *
+ * assurance-control: WILDO.ACCESS.AUTHORIZATION_DECISION_AUDIT
+ */
+export declare const AuditableEvent_ProviderOperationDenied_EventDataSchema: z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.PROVIDER_OPERATION_DENIED>;
+    denialReason: z.ZodEnum<typeof ProviderOperationDenialReason>;
+    providerRef: z.ZodString;
+    operationId: z.ZodString;
+    connectionOwnerScope: z.ZodString;
+    connectionOwnerId: z.ZodOptional<z.ZodString>;
+    connectionDelegation: z.ZodString;
+    requiredRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    heldRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     initiatorUserId: z.ZodOptional<z.ZodString>;
     executionType: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
@@ -2240,6 +2716,7 @@ export declare const AuditableEvent_McpToolCall_EventDataSchema: z.ZodObject<{
     outcome: z.ZodString;
     connectionOwnerScope: z.ZodOptional<z.ZodString>;
     credentialId: z.ZodOptional<z.ZodString>;
+    credentialSetByUserId: z.ZodOptional<z.ZodString>;
     initiatorUserId: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
     agentRef: z.ZodOptional<z.ZodString>;
@@ -2315,6 +2792,9 @@ export declare const AuditableEvent_HttpApiReadThroughAccess_EventDataSchema: z.
  * assurance-control: WILDO.AUDIT.ATTRIBUTION — the outbound deletion names the subject it served
  * and the external system it reached; the erasure report is the per-request receipt, this row is
  * the queryable trail.
+ *
+ * assurance-control: WILDO.PRIVACY.ERASURE_PROPAGATION — an erasure that deleted rows in an external
+ * system leaves a durable record naming that system and how many rows it deleted there.
  */
 export declare const AuditableEvent_HttpApiExternalErasure_EventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.HTTP_API_EXTERNAL_ERASURE>;
@@ -2338,6 +2818,9 @@ export declare const AuditableEvent_HttpApiExternalErasure_EventDataSchema: z.Zo
  *
  * assurance-control: WILDO.AUDIT.ATTRIBUTION — an acknowledged erasure hole is recorded per
  * resource, per erasure request, never as a standing posture.
+ *
+ * assurance-control: WILDO.PRIVACY.ERASURE_PROPAGATION — a store the erasure deliberately did not
+ * reach is recorded as such, so the accounting cannot read as complete.
  */
 export declare const AuditableEvent_HttpApiNonErasureAcknowledged_EventDataSchema: z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.HTTP_API_NON_ERASURE_ACKNOWLEDGED>;
@@ -2535,7 +3018,7 @@ export declare const AuditableEvent_User_RefreshTokenReuseDetectedEventDataSchem
 export declare const AuditableEvent_DataSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
 export declare const AuditableEvent_BaseSchema: z.ZodObject<{
     _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    eventId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    eventId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
     userId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
     organizationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
     applicationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
@@ -2642,6 +3125,13 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     operationIdentifier: z.ZodOptional<z.ZodString>;
     subjectUserId: z.ZodOptional<z.ZodString>;
     subjectNextStatus: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_TYPE_ASSIGNED>;
+    organizationId: z.ZodString;
+    organizationType: z.ZodString;
+    previousType: z.ZodOptional<z.ZodString>;
+    basis: z.ZodEnum<typeof OrganizationTypeAssignmentBasis>;
+    justification: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_MEMBER_INVITED>;
     organizationId: z.ZodString;
@@ -2670,6 +3160,7 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     requestedRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     operation: z.ZodString;
     changedBy: z.ZodString;
+    justification: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_MEMBER_STATUS_CHANGED>;
     organizationId: z.ZodString;
@@ -2808,6 +3299,11 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     deletedBy: z.ZodString;
     appRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodObject<{
+    assurance: z.ZodOptional<z.ZodObject<{
+        decision: z.ZodEnum<typeof import("../..").ExternalAssuranceDecision>;
+        reason: z.ZodEnum<typeof import("../..").ExternalAssuranceReason>;
+        enforcement: z.ZodEnum<typeof import("../..").ExternalAssuranceEnforcement>;
+    }, z.core.$strip>>;
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_SSO_LOGIN>;
     userId: z.ZodString;
     email: z.ZodEmail;
@@ -2821,6 +3317,11 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     userAgent: z.ZodString;
     sessionId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
+    assurance: z.ZodOptional<z.ZodObject<{
+        decision: z.ZodEnum<typeof import("../..").ExternalAssuranceDecision>;
+        reason: z.ZodEnum<typeof import("../..").ExternalAssuranceReason>;
+        enforcement: z.ZodEnum<typeof import("../..").ExternalAssuranceEnforcement>;
+    }, z.core.$strip>>;
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_SSO_LOGIN_FAILED>;
     email: z.ZodOptional<z.ZodEmail>;
     providerRef: z.ZodOptional<z.ZodString>;
@@ -2835,9 +3336,11 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_SSO_ENFORCEMENT_BLOCKED>;
     email: z.ZodEmail;
-    attemptedProviderRef: z.ZodString;
-    attemptedConnectionType: z.ZodEnum<typeof SsoConnectionType>;
-    organizationId: z.ZodString;
+    attemptedProviderRef: z.ZodOptional<z.ZodString>;
+    attemptedConnectionType: z.ZodOptional<z.ZodEnum<typeof SsoConnectionType>>;
+    scopeType: z.ZodEnum<typeof AuthScopeType>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    applicationId: z.ZodOptional<z.ZodString>;
     enforcementPolicy: z.ZodString;
     ipAddress: z.ZodString;
     userAgent: z.ZodString;
@@ -2855,12 +3358,29 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     affectedProviderRef: z.ZodOptional<z.ZodString>;
     changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strip>, z.ZodObject<{
+    organizationId: z.ZodString;
+    changedBy: z.ZodString;
+    changeType: z.ZodEnum<typeof SiemExportChangeType>;
+    webhookUrlDomain: z.ZodOptional<z.ZodString>;
+    eventFormatConfigured: z.ZodOptional<z.ZodString>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_SIEM_EXPORT_CONFIGURED>;
+}, z.core.$strip>, z.ZodObject<{
+    organizationId: z.ZodString;
+    changedBy: z.ZodString;
+    changeType: z.ZodEnum<typeof SiemExportChangeType>;
+    webhookUrlDomain: z.ZodOptional<z.ZodString>;
+    eventFormatConfigured: z.ZodOptional<z.ZodString>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_SIEM_EXPORT_DISABLED>;
+}, z.core.$strip>, z.ZodObject<{
     organizationId: z.ZodString;
     changedBy: z.ZodString;
     changeType: z.ZodEnum<typeof SiemExportChangeType>;
     webhookUrlDomain: z.ZodOptional<z.ZodString>;
     eventFormatConfigured: z.ZodOptional<z.ZodString>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_SIEM_EXPORT_DESTINATION_CHANGED>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_PROVIDER_CREDENTIAL_SET>;
     organizationId: z.ZodString;
@@ -2883,6 +3403,7 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     secretSlug: z.ZodString;
     resolvedFrom: z.ZodEnum<typeof ProviderCredentialResolutionSource>;
     credentialId: z.ZodOptional<z.ZodString>;
+    credentialSetByUserId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.ORGANIZATION_PROVIDER_CREDENTIAL_DELETED>;
     organizationId: z.ZodString;
@@ -2891,12 +3412,17 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     deletedBy: z.ZodOptional<z.ZodString>;
     credentialId: z.ZodString;
     reason: z.ZodEnum<typeof ProviderCredentialDeletionReason>;
+    vendorRevocation: z.ZodOptional<z.ZodEnum<typeof import("../..").ProviderOAuth2RevocationOutcome>>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.APPLICATION_AUTH_POLICY_CHANGED>;
     changedUserTypes: z.ZodArray<z.ZodString>;
     snapshotDigest: z.ZodString;
     before: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     after: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    auditApplicationReadAccess: z.ZodOptional<z.ZodObject<{
+        before: z.ZodNullable<z.ZodEnum<typeof AuditApplicationReadAccess>>;
+        after: z.ZodEnum<typeof AuditApplicationReadAccess>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.WEBHOOK_ENDPOINT_TEST_DISPATCHED>;
     organizationId: z.ZodOptional<z.ZodString>;
@@ -2967,6 +3493,8 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     email: z.ZodString;
     ipAddress: z.ZodString;
     userAgent: z.ZodString;
+    acquisitionChannel: z.ZodOptional<z.ZodEnum<typeof RegistrationAcquisitionChannel>>;
+    providerRef: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.USER_EMAIL_VERIFIED>;
     userId: z.ZodString;
@@ -3140,11 +3668,13 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     isBulkOperation: z.ZodOptional<z.ZodBoolean>;
     resourceId: z.ZodOptional<z.ZodString>;
     affectedRecordCount: z.ZodOptional<z.ZodNumber>;
+    affectedResourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     initiatorRoles: z.ZodArray<z.ZodString>;
     executionType: z.ZodEnum<typeof ExecutionContext_ExecutionType>;
     machineCredentialAuthMethod: z.ZodOptional<z.ZodString>;
     machineCredentialId: z.ZodOptional<z.ZodString>;
     subCallDepth: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
     changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     fieldEvidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         before: z.ZodOptional<z.ZodUnknown>;
@@ -3161,6 +3691,8 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     isBulkOperation: z.ZodOptional<z.ZodBoolean>;
     attemptedResourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     requiredRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    escalatedRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    refusedSurface: z.ZodOptional<z.ZodString>;
     initiatorRoles: z.ZodArray<z.ZodString>;
     executionType: z.ZodEnum<typeof ExecutionContext_ExecutionType>;
     machineCredentialAuthMethod: z.ZodOptional<z.ZodString>;
@@ -3181,6 +3713,10 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     admissionDeclared: z.ZodBoolean;
     initiatorRoles: z.ZodArray<z.ZodString>;
     executionType: z.ZodEnum<typeof ExecutionContext_ExecutionType>;
+    machineCredential: z.ZodOptional<z.ZodObject<{
+        authMethod: z.ZodEnum<typeof import("../..").MachineAuthMethod>;
+        credentialId: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.PLATFORM_DIRECTORY_ACCESS>;
     resourceType: z.ZodString;
@@ -3205,6 +3741,20 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     autoApprovalReason: z.ZodOptional<z.ZodEnum<typeof PlatformAccessGrantAutoApprovalReason>>;
     decidedByUserId: z.ZodOptional<z.ZodString>;
     decisionReason: z.ZodOptional<z.ZodString>;
+    grantedMachineCredential: z.ZodOptional<z.ZodObject<{
+        authMethod: z.ZodEnum<typeof import("../..").MachineAuthMethod>;
+        credentialId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.SYSTEM_OF_RECORD_PARTITION_ASSIGNMENT_LIFECYCLE>;
+    transition: z.ZodEnum<typeof SystemOfRecordPartitionAssignmentTransition>;
+    assignmentId: z.ZodString;
+    system: z.ZodString;
+    remoteKey: z.ZodString;
+    organizationUnitId: z.ZodOptional<z.ZodString>;
+    previousOrganizationUnitId: z.ZodOptional<z.ZodString>;
+    justification: z.ZodOptional<z.ZodString>;
+    assignedByUserId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.RETAINED_DATA_ACCESS>;
     accessingUserId: z.ZodString;
@@ -3216,6 +3766,30 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     organizationId: z.ZodOptional<z.ZodString>;
     ipAddress: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.GOVERNED_DOCUMENT_INTERACTION_RECORDED>;
+    userId: z.ZodOptional<z.ZodString>;
+    anonymousUserId: z.ZodOptional<z.ZodString>;
+    interaction: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        interactionKind: z.ZodEnum<typeof import("../..").GovernedDocumentInteractionKind>;
+        release: z.ZodObject<{
+            document: z.ZodObject<{
+                documentRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                documentVersion: z.ZodNumber;
+            }, z.core.$strict>;
+            releaseId: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+            releaseVersion: z.ZodNumber;
+        }, z.core.$strict>;
+        documentClass: z.ZodEnum<typeof import("../..").GovernedDocumentClass>;
+        locale: z.ZodString;
+        jurisdictionRefs: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">>;
+        releaseApprovalState: z.ZodEnum<typeof import("../..").GovernedDocumentReleaseApprovalState>;
+        acceptanceMode: z.ZodOptional<z.ZodEnum<typeof import("../..").GovernedDocumentAcceptanceMode>>;
+        occurredAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    advisoryKinds: z.ZodArray<z.ZodString>;
+    ipAddress: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     eventType: z.ZodLiteral<CoreAuditableEventType.SUBJECT_DATA_EXPORT>;
     purpose: z.ZodString;
@@ -3266,6 +3840,21 @@ export declare const AuditableEvent_TypedDataSchema: z.ZodDiscriminatedUnion<[z.
     connectionDelegation: z.ZodString;
     status: z.ZodOptional<z.ZodNumber>;
     failureKind: z.ZodOptional<z.ZodString>;
+    scopeCheck: z.ZodOptional<z.ZodEnum<typeof ProviderOperationScopeCheck>>;
+    missingScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    initiatorUserId: z.ZodOptional<z.ZodString>;
+    executionType: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    eventType: z.ZodLiteral<CoreAuditableEventType.PROVIDER_OPERATION_DENIED>;
+    denialReason: z.ZodEnum<typeof ProviderOperationDenialReason>;
+    providerRef: z.ZodString;
+    operationId: z.ZodString;
+    connectionOwnerScope: z.ZodString;
+    connectionOwnerId: z.ZodOptional<z.ZodString>;
+    connectionDelegation: z.ZodString;
+    requiredRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    heldRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     initiatorUserId: z.ZodOptional<z.ZodString>;
     executionType: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
@@ -3382,6 +3971,7 @@ export type AuditableEvent_User_SessionExpiredEventData = z.infer<typeof Auditab
 export type AuditableEvent_User_AppRolesChangedEventData = z.infer<typeof AuditableEvent_User_AppRolesChangedEventDataSchema>;
 export type AuditableEvent_Application_SuperAdminFloorBreachedEventData = z.infer<typeof AuditableEvent_Application_SuperAdminFloorBreachedEventDataSchema>;
 export type AuditableEvent_Organization_OwnerFloorBreachedEventData = z.infer<typeof AuditableEvent_Organization_OwnerFloorBreachedEventDataSchema>;
+export type AuditableEvent_Organization_TypeAssignedEventData = z.infer<typeof AuditableEvent_Organization_TypeAssignedEventDataSchema>;
 export type AuditableEvent_User_DeletedEventData = z.infer<typeof AuditableEvent_User_DeletedEventDataSchema>;
 export type AuditableEvent_OrganizationMember_InvitedEventData = z.infer<typeof AuditableEvent_OrganizationMember_InvitedEventDataSchema>;
 export type AuditableEvent_OrganizationMember_JoinedEventData = z.infer<typeof AuditableEvent_OrganizationMember_JoinedEventDataSchema>;
@@ -3409,6 +3999,8 @@ export type AuditableEvent_User_SSOEnforcementBlockedEventData = z.infer<typeof
 export type AuditableEvent_User_TokenRefreshedEventData = z.infer<typeof AuditableEvent_User_TokenRefreshedEventDataSchema>;
 export type AuditableEvent_Organization_SSOConfigurationChangedEventData = z.infer<typeof AuditableEvent_Organization_SSOConfigurationChangedEventDataSchema>;
 export type AuditableEvent_Organization_SIEMExportConfiguredEventData = z.infer<typeof AuditableEvent_Organization_SIEMExportConfiguredEventDataSchema>;
+export type AuditableEvent_Organization_SIEMExportDisabledEventData = z.infer<typeof AuditableEvent_Organization_SIEMExportDisabledEventDataSchema>;
+export type AuditableEvent_Organization_SIEMExportDestinationChangedEventData = z.infer<typeof AuditableEvent_Organization_SIEMExportDestinationChangedEventDataSchema>;
 export type AuditableEvent_OrganizationProviderCredential_SetEventData = z.infer<typeof AuditableEvent_OrganizationProviderCredential_SetEventDataSchema>;
 export type AuditableEvent_OrganizationProviderCredential_RotatedEventData = z.infer<typeof AuditableEvent_OrganizationProviderCredential_RotatedEventDataSchema>;
 export type AuditableEvent_OrganizationProviderCredential_UsedEventData = z.infer<typeof AuditableEvent_OrganizationProviderCredential_UsedEventDataSchema>;
@@ -3455,11 +4047,13 @@ export type AuditableEvent_ResourceOperationPerformed_EventData = z.infer<typeof
 export type AuditableEvent_PlatformDirectoryAccess_EventData = z.infer<typeof AuditableEvent_PlatformDirectoryAccess_EventDataSchema>;
 export type AuditableEvent_ResourceOperationDenied_EventData = z.infer<typeof AuditableEvent_ResourceOperationDenied_EventDataSchema>;
 export type AuditableEvent_RetainedDataAccess_EventData = z.infer<typeof AuditableEvent_RetainedDataAccess_EventDataSchema>;
+export type AuditableEvent_GovernedDocument_InteractionRecordedEventData = z.infer<typeof AuditableEvent_GovernedDocument_InteractionRecordedEventDataSchema>;
 export type AuditableEvent_SubjectDataExport_EventData = z.infer<typeof AuditableEvent_SubjectDataExport_EventDataSchema>;
 export type AuditableEvent_CollectionDataExport_EventData = z.infer<typeof AuditableEvent_CollectionDataExport_EventDataSchema>;
 export type AuditableEvent_User_SessionEvictedEventData = z.infer<typeof AuditableEvent_User_SessionEvictedEventDataSchema>;
 export type AuditableEvent_HttpApiReadThroughAccess_EventData = z.infer<typeof AuditableEvent_HttpApiReadThroughAccess_EventDataSchema>;
 export type AuditableEvent_ProviderOperationCall_EventData = z.infer<typeof AuditableEvent_ProviderOperationCall_EventDataSchema>;
+export type AuditableEvent_ProviderOperationDenied_EventData = z.infer<typeof AuditableEvent_ProviderOperationDenied_EventDataSchema>;
 export type AuditableEvent_HttpApiExternalErasure_EventData = z.infer<typeof AuditableEvent_HttpApiExternalErasure_EventDataSchema>;
 export type AuditableEvent_HttpApiNonErasureAcknowledged_EventData = z.infer<typeof AuditableEvent_HttpApiNonErasureAcknowledged_EventDataSchema>;
 export type AuditableEvent_User_CrossFrontendHandoffIssuedEventData = z.infer<typeof AuditableEvent_User_CrossFrontendHandoffIssuedEventDataSchema>;