@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/session-retention.js

@@ -1,450 +0,0 @@
-import { isTerminalSessionWorkflowStatus } from "./workflow-status.js";
-import { createForbiddenFieldNamePredicate, privateResourceHandlePattern, PUBLIC_SAFE_SECRET_PATTERNS, scanPublicSafePayload } from "./sdk-secrets.js";
-export const SESSION_RETENTION_SCHEMA_VERSION = 1;
-export const SESSION_DELETION_MANIFEST_KIND = "aex.session_deletion_manifest.v1";
-export const SESSION_DELETION_JOB_KIND = "aex.session_deletion_job.v1";
-export const SESSION_DELETION_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
-export const SESSION_RETENTION_REDACTION_SCANNER_VERSION = 1;
-export const SESSION_DELETION_REASONS = ["manual_delete", "retention_gc"];
-export const SESSION_DELETION_MANIFEST_MODES = ["dry_run", "final"];
-export const SESSION_DELETION_CANDIDATE_STATUSES = ["selected", "blocked"];
-export const SESSION_DELETION_BLOCKERS = [
-    "non_terminal",
-    "retention_policy_disabled",
-    "missing_terminal_at",
-    "unexpired",
-    "held",
-    "retention_exempt",
-    "unresolved_cleanup",
-    "unresolved_custody"
-];
-export const SESSION_DELETION_COUNT_CLASSES = [
-    "object_store_objects",
-    "files",
-    "logs",
-    "events",
-    "assets",
-    "db_event_rows",
-    "db_file_rows",
-    "capture_failures",
-    "storage_samples",
-    "custody_manifests"
-];
-export const SESSION_DELETION_COUNT_STATUSES = ["counted", "not_counted", "partial", "failed"];
-export const SESSION_DELETION_JOB_STATUSES = [
-    "queued",
-    "planning",
-    "blocked",
-    "manifest_written",
-    "deleting",
-    "delete_failed",
-    "completed",
-    "failed"
-];
-export const SESSION_DELETION_PROOF_STATUSES = [
-    "not_started",
-    "running",
-    "completed",
-    "failed"
-];
-export const SESSION_DELETION_WRITE_STATUSES = ["not_written", "written", "write_failed"];
-export const SESSION_RETENTION_EXCLUDED_VALUE_CLASSES = [
-    "raw_paths",
-    "object_keys",
-    "filenames",
-    "object_sizes",
-    "hashes",
-    "provider_ids",
-    "vault_ids",
-    "resource_ids",
-    "resource_handles",
-    "signed_urls"
-];
-export class SessionRetentionValidationError extends Error {
-    code = "session_retention_contract_invalid";
-    constructor(message) {
-        super(message);
-        this.name = "SessionRetentionValidationError";
-    }
-}
-export class SessionRetentionRedactionError extends Error {
-    code = "session_retention_payload_not_public_safe";
-    findings;
-    constructor(findings) {
-        super(`session retention payload contains non-public data at ${formatFindingPaths(findings)}`);
-        this.name = "SessionRetentionRedactionError";
-        this.findings = Object.freeze([...findings]);
-    }
-}
-export function createSessionDeletionManifestWriter(store) {
-    return {
-        async writeSessionDeletionManifest(input) {
-            return writeSessionDeletionManifest(store, input);
-        }
-    };
-}
-export async function writeSessionDeletionManifest(store, input) {
-    const manifest = buildSessionDeletionManifest(input);
-    await store.putSessionDeletionManifestObject({
-        sessionId: manifest.session.sessionId,
-        workspaceId: manifest.session.workspaceId,
-        contentType: SESSION_DELETION_MANIFEST_CONTENT_TYPE,
-        manifest
-    });
-    return Object.freeze({
-        status: "written",
-        schemaVersion: SESSION_RETENTION_SCHEMA_VERSION,
-        sessionId: manifest.session.sessionId,
-        workspaceId: manifest.session.workspaceId,
-        writtenAt: manifest.generatedAt,
-        mode: manifest.mode
-    });
-}
-export function buildSessionRetentionPolicy(input = {}) {
-    if (input.automaticDeletion) {
-        if (input.retentionDays === undefined) {
-            throw new SessionRetentionValidationError("automatic retention deletion requires an explicit positive retentionDays value");
-        }
-        return Object.freeze({
-            mode: "delete_after_days",
-            manualDelete: "enabled",
-            automaticDeletion: "enabled",
-            retentionDays: positiveInteger(input.retentionDays, "policy.retentionDays")
-        });
-    }
-    if (input.retentionDays !== undefined) {
-        throw new SessionRetentionValidationError("retentionDays is not allowed when automatic retention deletion is disabled");
-    }
-    return Object.freeze({
-        mode: "retain_indefinitely",
-        manualDelete: "enabled",
-        automaticDeletion: "disabled"
-    });
-}
-export function evaluateSessionDeletionCandidate(input) {
-    const now = assertTimestamp(input.now, "candidate.now");
-    const session = normalizeCandidateSession(input.session);
-    const policy = normalizePolicy(input.policy);
-    const blockers = [];
-    addSessionBlockers(blockers, session, now);
-    let eligibleAt;
-    if (input.reason === "retention_gc") {
-        if (policy.mode !== "delete_after_days" || policy.retentionDays === undefined) {
-            blockers.push(blocker("retention_policy_disabled", now));
-        }
-        else if (!session.terminalAt) {
-            blockers.push(blocker("missing_terminal_at", now));
-        }
-        else {
-            eligibleAt = addDaysIso(session.terminalAt, policy.retentionDays);
-            if (Date.parse(now) < Date.parse(eligibleAt)) {
-                blockers.push(blocker("unexpired", now));
-            }
-        }
-    }
-    else {
-        eligibleAt = now;
-    }
-    return Object.freeze({
-        status: blockers.length === 0 ? "selected" : "blocked",
-        reason: input.reason,
-        evaluatedAt: now,
-        ...(eligibleAt ? { eligibleAt } : {}),
-        blockers: Object.freeze(blockers)
-    });
-}
-export function buildSessionDeletionManifest(input) {
-    const candidate = input.candidate ??
-        evaluateSessionDeletionCandidate({
-            session: input.session,
-            reason: input.request.reason,
-            now: input.generatedAt,
-            ...(input.policy ? { policy: input.policy } : {})
-        });
-    const normalizedCandidate = normalizeCandidate(candidate);
-    const session = normalizeManifestSession(input.session, normalizedCandidate.eligibleAt);
-    const summary = buildSessionDeletionSummary(input.counts ?? [], normalizedCandidate);
-    const manifest = Object.freeze({
-        schemaVersion: SESSION_RETENTION_SCHEMA_VERSION,
-        kind: SESSION_DELETION_MANIFEST_KIND,
-        generatedAt: assertTimestamp(input.generatedAt, "manifest.generatedAt"),
-        mode: input.mode,
-        session,
-        request: normalizeRequest(input.request),
-        candidate: normalizedCandidate,
-        summary,
-        redaction: Object.freeze({
-            policy: "counts_status_timestamps_only",
-            scannerVersion: SESSION_RETENTION_REDACTION_SCANNER_VERSION,
-            excludes: Object.freeze([...SESSION_RETENTION_EXCLUDED_VALUE_CLASSES])
-        })
-    });
-    assertPublicSafeSessionRetentionPayload(manifest);
-    return manifest;
-}
-export function assertSessionDeletionOrder(proof) {
-    const manifest = normalizeManifestProof(proof.manifest);
-    const purge = normalizePurgeProof(proof.purge);
-    const purgeStarted = purge.status === "running" || purge.status === "completed" || purge.status === "failed";
-    if (purgeStarted && manifest.status !== "written") {
-        throw new SessionRetentionValidationError("session deletion cannot purge assets before the deletion manifest is written");
-    }
-    if (purgeStarted && manifest.mode !== "final") {
-        throw new SessionRetentionValidationError("session deletion cannot purge assets from a dry-run deletion manifest");
-    }
-}
-export function buildSessionDeletionJob(input) {
-    assertSessionDeletionOrder(input.order);
-    const job = Object.freeze({
-        schemaVersion: SESSION_RETENTION_SCHEMA_VERSION,
-        kind: SESSION_DELETION_JOB_KIND,
-        jobId: assertSafeIdentifier(input.jobId, "job.jobId"),
-        sessionId: assertSafeIdentifier(input.sessionId, "job.sessionId"),
-        workspaceId: assertSafeIdentifier(input.workspaceId, "job.workspaceId"),
-        reason: input.reason,
-        mode: input.mode,
-        status: input.status,
-        createdAt: assertTimestamp(input.createdAt, "job.createdAt"),
-        ...(input.updatedAt ? { updatedAt: assertTimestamp(input.updatedAt, "job.updatedAt") } : {}),
-        order: normalizeOrderProof(input.order),
-        ...(input.candidate ? { candidate: normalizeCandidate(input.candidate) } : {}),
-        ...(input.summary ? { summary: normalizeSummary(input.summary) } : {})
-    });
-    assertPublicSafeSessionRetentionPayload(job);
-    return job;
-}
-export function scanSessionRetentionPayloadForSensitiveValues(input) {
-    return scanPublicSafePayload(input, {
-        patterns: retentionStringPatterns,
-        isForbiddenFieldName: isForbiddenRetentionFieldName
-    });
-}
-export function assertPublicSafeSessionRetentionPayload(input) {
-    const findings = scanSessionRetentionPayloadForSensitiveValues(input);
-    if (findings.length > 0) {
-        throw new SessionRetentionRedactionError(findings);
-    }
-}
-function normalizePolicy(input) {
-    if (!input) {
-        return buildSessionRetentionPolicy();
-    }
-    if ("mode" in input) {
-        if (input.mode === "delete_after_days") {
-            if (input.retentionDays === undefined) {
-                throw new SessionRetentionValidationError("delete_after_days retention policy requires an explicit retentionDays value");
-            }
-            return buildSessionRetentionPolicy({
-                automaticDeletion: true,
-                retentionDays: input.retentionDays
-            });
-        }
-        if (input.retentionDays !== undefined) {
-            throw new SessionRetentionValidationError("retain_indefinitely retention policy cannot include retentionDays");
-        }
-        return buildSessionRetentionPolicy();
-    }
-    return buildSessionRetentionPolicy(input);
-}
-function normalizeCandidateSession(input) {
-    return Object.freeze({
-        sessionId: assertSafeIdentifier(input.sessionId, "session.sessionId"),
-        workspaceId: assertSafeIdentifier(input.workspaceId, "session.workspaceId"),
-        status: assertSafeMetadataString(input.status, "session.status"),
-        ...(input.createdAt ? { createdAt: assertTimestamp(input.createdAt, "session.createdAt") } : {}),
-        ...(input.terminalAt ? { terminalAt: assertTimestamp(input.terminalAt, "session.terminalAt") } : {}),
-        ...(input.held !== undefined ? { held: input.held } : {}),
-        ...(input.retentionExempt !== undefined ? { retentionExempt: input.retentionExempt } : {}),
-        ...(input.unresolvedCleanup !== undefined ? { unresolvedCleanup: input.unresolvedCleanup } : {}),
-        ...(input.unresolvedCustody !== undefined ? { unresolvedCustody: input.unresolvedCustody } : {})
-    });
-}
-function normalizeManifestSession(input, eligibleAt) {
-    const session = normalizeCandidateSession(input);
-    return Object.freeze({
-        sessionId: session.sessionId,
-        workspaceId: session.workspaceId,
-        status: session.status,
-        ...(session.createdAt ? { createdAt: session.createdAt } : {}),
-        ...(session.terminalAt ? { terminalAt: session.terminalAt } : {}),
-        ...(eligibleAt ? { eligibleAt: assertTimestamp(eligibleAt, "session.eligibleAt") } : {})
-    });
-}
-function normalizeRequest(input) {
-    return Object.freeze({
-        reason: input.reason,
-        actorClass: input.actorClass
-    });
-}
-function normalizeCandidate(input) {
-    return Object.freeze({
-        status: input.status,
-        reason: input.reason,
-        evaluatedAt: assertTimestamp(input.evaluatedAt, "candidate.evaluatedAt"),
-        ...(input.eligibleAt ? { eligibleAt: assertTimestamp(input.eligibleAt, "candidate.eligibleAt") } : {}),
-        blockers: Object.freeze(input.blockers.map(normalizeBlocker))
-    });
-}
-function normalizeBlocker(input) {
-    return Object.freeze({
-        code: input.code,
-        observedAt: assertTimestamp(input.observedAt, "candidate.blocker.observedAt")
-    });
-}
-function normalizeCount(input) {
-    return Object.freeze({
-        class: assertSafeMetadataString(input.class, "summary.count.class"),
-        count: nonNegativeInteger(input.count, "summary.count.count"),
-        status: input.status,
-        ...(input.countedAt ? { countedAt: assertTimestamp(input.countedAt, "summary.count.countedAt") } : {}),
-        ...(input.errorClass ? { errorClass: assertSafeMetadataString(input.errorClass, "summary.count.errorClass") } : {})
-    });
-}
-function buildSessionDeletionSummary(input, candidate) {
-    const counts = Object.freeze(input.map(normalizeCount));
-    return Object.freeze({
-        totalCount: counts.reduce((sum, item) => sum + item.count, 0),
-        failedCountClasses: counts.filter((item) => item.status === "failed").length,
-        partialCountClasses: counts.filter((item) => item.status === "partial").length,
-        blockerCount: candidate.blockers.length,
-        counts
-    });
-}
-function normalizeSummary(input) {
-    return Object.freeze({
-        totalCount: nonNegativeInteger(input.totalCount, "summary.totalCount"),
-        failedCountClasses: nonNegativeInteger(input.failedCountClasses, "summary.failedCountClasses"),
-        partialCountClasses: nonNegativeInteger(input.partialCountClasses, "summary.partialCountClasses"),
-        blockerCount: nonNegativeInteger(input.blockerCount, "summary.blockerCount"),
-        counts: Object.freeze(input.counts.map(normalizeCount))
-    });
-}
-function normalizeOrderProof(input) {
-    return Object.freeze({
-        manifest: normalizeManifestProof(input.manifest),
-        purge: normalizePurgeProof(input.purge)
-    });
-}
-function normalizeManifestProof(input) {
-    return Object.freeze({
-        status: input.status,
-        ...(input.mode ? { mode: input.mode } : {}),
-        ...(input.writtenAt ? { writtenAt: assertTimestamp(input.writtenAt, "proof.manifest.writtenAt") } : {})
-    });
-}
-function normalizePurgeProof(input) {
-    return Object.freeze({
-        status: input.status,
-        ...(input.startedAt ? { startedAt: assertTimestamp(input.startedAt, "proof.purge.startedAt") } : {}),
-        ...(input.completedAt ? { completedAt: assertTimestamp(input.completedAt, "proof.purge.completedAt") } : {}),
-        ...(input.deletedObjectCount !== undefined
-            ? { deletedObjectCount: nonNegativeInteger(input.deletedObjectCount, "proof.purge.deletedObjectCount") }
-            : {})
-    });
-}
-function addSessionBlockers(blockers, session, observedAt) {
-    if (!isTerminalStatusLike(session.status)) {
-        blockers.push(blocker("non_terminal", observedAt));
-    }
-    if (session.held) {
-        blockers.push(blocker("held", observedAt));
-    }
-    if (session.retentionExempt) {
-        blockers.push(blocker("retention_exempt", observedAt));
-    }
-    if (session.unresolvedCleanup) {
-        blockers.push(blocker("unresolved_cleanup", observedAt));
-    }
-    if (session.unresolvedCustody) {
-        blockers.push(blocker("unresolved_custody", observedAt));
-    }
-}
-function blocker(code, observedAt) {
-    return Object.freeze({ code, observedAt });
-}
-function isTerminalStatusLike(status) {
-    return isTerminalSessionWorkflowStatus(status);
-}
-function addDaysIso(timestamp, days) {
-    const start = Date.parse(assertTimestamp(timestamp, "candidate.session.terminalAt"));
-    const end = start + positiveInteger(days, "policy.retentionDays") * 24 * 60 * 60 * 1000;
-    return new Date(end).toISOString();
-}
-const retentionStringPatterns = Object.freeze([
-    ...PUBLIC_SAFE_SECRET_PATTERNS,
-    privateResourceHandlePattern(["machine", "resource", "handle", "provider", "asset"]),
-    Object.freeze({
-        reason: "hash_like_value",
-        regex: /\b(?:sha256|hash)[:_-][A-Fa-f0-9]{16,}\b/
-    })
-]);
-const isForbiddenRetentionFieldName = createForbiddenFieldNamePredicate([
-    "path",
-    "paths",
-    "objectKey",
-    "objectKeys",
-    "objectStoreKey",
-    "objectStoreKeys",
-    "fileName",
-    "filename",
-    "filenames",
-    "size",
-    "sizes",
-    "bytes",
-    "byteCount",
-    "hash",
-    "hashes",
-    "providerId",
-    "providerIds",
-    "vaultId",
-    "vaultIds",
-    "resourceId",
-    "resourceIds",
-    "handle",
-    "handles",
-    "signedUrl",
-    "signedUrls",
-    "url",
-    "urls"
-]);
-function assertSafeIdentifier(value, field) {
-    assertNonEmptyString(value, field);
-    if (!/^[A-Za-z0-9._:-]+$/.test(value)) {
-        throw new SessionRetentionValidationError(`session retention ${field} must be an opaque identifier without path separators`);
-    }
-    assertPublicSafeSessionRetentionPayload(value);
-    return value;
-}
-function assertSafeMetadataString(value, field) {
-    assertNonEmptyString(value, field);
-    assertPublicSafeSessionRetentionPayload(value);
-    return value;
-}
-function assertNonEmptyString(value, field) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new SessionRetentionValidationError(`session retention ${field} must be a non-empty string`);
-    }
-}
-function assertTimestamp(value, field) {
-    assertSafeMetadataString(value, field);
-    const ms = Date.parse(value);
-    if (!Number.isFinite(ms)) {
-        throw new SessionRetentionValidationError(`session retention ${field} must be an ISO timestamp string`);
-    }
-    return value;
-}
-function nonNegativeInteger(value, field) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new SessionRetentionValidationError(`session retention ${field} must be a non-negative safe integer`);
-    }
-    return value;
-}
-function positiveInteger(value, field) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new SessionRetentionValidationError(`session retention ${field} must be a positive safe integer`);
-    }
-    return value;
-}
-function formatFindingPaths(findings) {
-    return findings.map((finding) => `${finding.path} (${finding.reason})`).join(", ");
-}

package/dist/_contracts/side-effect-audit.d.ts

@@ -1,126 +0,0 @@
-import type { ProviderName } from "./submission.js";
-export declare const SIDE_EFFECT_AUDIT_SCHEMA_VERSION = 1;
-export declare const SIDE_EFFECT_AUDIT_REDACTION_SCANNER_VERSION = 1;
-export declare const SIDE_EFFECT_AUDIT_KIND = "aex.side_effect_audit.v1";
-export declare const SIDE_EFFECT_AUDIT_ACTIONS: readonly ["session.submit.accepted", "session.submit.rejected", "session.cancel.requested", "session.delete.requested", "session.delete.completed", "session.delete.failed", "session.download.requested", "session.file.downloaded", "session.log.downloaded", "session.event.downloaded", "workspace.asset.uploaded", "workspace.asset.deleted", "proxy.endpoint.called", "mcp.credential.accessed", "mcp.proxy.called", "provider.proxy.called", "custody.manifest.written", "custody.transition.recorded", "runtime.cleanup.completed", "runtime.cleanup.failed", "terminal_redrive.attempted", "terminal_redrive.completed", "api_key.created", "api_key.deleted", "api_key.used"];
-export type SideEffectAuditAction = (typeof SIDE_EFFECT_AUDIT_ACTIONS)[number];
-export declare const SIDE_EFFECT_AUDIT_ACTOR_PRINCIPAL_TYPES: readonly ["user", "api_key", "system", "runtime"];
-export type SideEffectAuditActorPrincipalType = (typeof SIDE_EFFECT_AUDIT_ACTOR_PRINCIPAL_TYPES)[number];
-export declare const SIDE_EFFECT_AUDIT_SOURCE_PLANES: readonly ["dashboard", "api", "runtime", "system"];
-export type SideEffectAuditSourcePlane = (typeof SIDE_EFFECT_AUDIT_SOURCE_PLANES)[number];
-export declare const SIDE_EFFECT_AUDIT_AUTHENTICATION_KINDS: readonly ["dashboard_auth", "api_key", "runner_token", "system"];
-export type SideEffectAuditAuthenticationKind = (typeof SIDE_EFFECT_AUDIT_AUTHENTICATION_KINDS)[number];
-export declare const SIDE_EFFECT_AUDIT_TARGET_TYPES: readonly ["workspace", "session", "proxy_endpoint", "mcp_credential", "mcp_proxy", "provider_proxy", "file_archive", "session_file", "session_log", "session_event_stream", "workspace_asset", "custody_manifest", "custody_transition", "cleanup", "deletion", "terminal_redrive", "api_key"];
-export type SideEffectAuditTargetType = (typeof SIDE_EFFECT_AUDIT_TARGET_TYPES)[number];
-export declare const SIDE_EFFECT_AUDIT_OUTCOMES: readonly ["accepted", "rejected", "succeeded", "failed", "denied", "canceled", "pending"];
-export type SideEffectAuditOutcome = (typeof SIDE_EFFECT_AUDIT_OUTCOMES)[number];
-export declare const SIDE_EFFECT_AUDIT_COUNT_NAMES: readonly ["requestBytes", "responseBytes", "durationMs", "attemptCount", "retryCount", "fileCount", "logCount", "eventCount", "assetCount", "proxyCallCount", "mcpCallCount", "providerProxyCallCount", "secretClassCount", "resourceClassCount", "deletedObjectCount", "retainedObjectCount", "failedObjectCount", "quotaRequestedUnits", "quotaRemainingUnits", "reservationCount"];
-export type SideEffectAuditCountName = (typeof SIDE_EFFECT_AUDIT_COUNT_NAMES)[number];
-export declare const SIDE_EFFECT_AUDIT_TIMESTAMP_NAMES: readonly ["startedAt", "finishedAt", "observedAt", "decidedAt", "deletedAt", "terminalAt", "expiresAt"];
-export type SideEffectAuditTimestampName = (typeof SIDE_EFFECT_AUDIT_TIMESTAMP_NAMES)[number];
-export declare const SIDE_EFFECT_AUDIT_METADATA_EXCLUDED_VALUE_CLASSES: readonly ["headers", "bodies", "raw_urls", "raw_paths", "query_strings", "provider_response_bodies", "signed_urls", "object_store_keys", "vault_ids", "resource_handles", "bearer_hashes", "secret_values", "customer_or_agent_identity", "private_pricing_or_provider_deployment"];
-export type SideEffectAuditMetadataExcludedValueClass = (typeof SIDE_EFFECT_AUDIT_METADATA_EXCLUDED_VALUE_CLASSES)[number];
-export interface SideEffectAuditPrincipalV1 {
-    readonly type: SideEffectAuditActorPrincipalType;
-    /**
-     * Existing platform principal reference such as app-user id or API-token id.
-     * This is not an agent id, customer end-user id, provider session id, or
-     * stateful identity primitive.
-     */
-    readonly ref?: string;
-}
-export interface SideEffectAuditActorV1 {
-    readonly principal: SideEffectAuditPrincipalV1;
-    readonly sourcePlane: SideEffectAuditSourcePlane;
-    readonly authenticatedBy?: SideEffectAuditAuthenticationKind;
-}
-export interface SideEffectAuditTargetV1 {
-    readonly type: SideEffectAuditTargetType;
-    readonly id?: string;
-    readonly name?: string;
-}
-export interface SideEffectAuditCorrelationV1 {
-    readonly requestId?: string;
-    readonly operationId?: string;
-    readonly eventId?: string;
-    readonly parentAuditId?: string;
-    readonly sourceAuditId?: string;
-    readonly idempotencyKeyRef?: string;
-}
-export interface SideEffectAuditStatusMetadataV1 {
-    readonly status?: string;
-    readonly statusCode?: number;
-    readonly errorClass?: string;
-    readonly denialReason?: string;
-    readonly followUpRequired?: boolean;
-}
-export interface SideEffectAuditDimensionsMetadataV1 {
-    readonly provider?: ProviderName | string;
-    readonly namespace?: "metadata" | "events" | "logs" | "files" | "archive";
-    readonly method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-    readonly surface?: string;
-}
-export interface SideEffectAuditRedactionMetadataV1 {
-    readonly policy: "metadata_only";
-    readonly scannerVersion: typeof SIDE_EFFECT_AUDIT_REDACTION_SCANNER_VERSION;
-    readonly excludes: readonly SideEffectAuditMetadataExcludedValueClass[];
-}
-export interface SideEffectAuditMetadataV1 {
-    readonly status?: SideEffectAuditStatusMetadataV1;
-    readonly counts?: Readonly<Partial<Record<SideEffectAuditCountName, number>>>;
-    readonly timestamps?: Readonly<Partial<Record<SideEffectAuditTimestampName, string>>>;
-    readonly dimensions?: SideEffectAuditDimensionsMetadataV1;
-    readonly redaction: SideEffectAuditRedactionMetadataV1;
-}
-export interface SideEffectAuditEventV1 {
-    readonly schemaVersion: typeof SIDE_EFFECT_AUDIT_SCHEMA_VERSION;
-    readonly kind: typeof SIDE_EFFECT_AUDIT_KIND;
-    readonly auditId?: string;
-    readonly workspaceId: string;
-    readonly sessionId?: string;
-    readonly action: SideEffectAuditAction;
-    readonly outcome: SideEffectAuditOutcome;
-    readonly observedAt: string;
-    readonly actor: SideEffectAuditActorV1;
-    readonly target: SideEffectAuditTargetV1;
-    readonly correlation?: SideEffectAuditCorrelationV1;
-    readonly metadata: SideEffectAuditMetadataV1;
-}
-export type SideEffectAuditPrincipalInput = SideEffectAuditPrincipalV1;
-export type SideEffectAuditActorInput = SideEffectAuditActorV1;
-export type SideEffectAuditTargetInput = SideEffectAuditTargetV1;
-export type SideEffectAuditCorrelationInput = SideEffectAuditCorrelationV1;
-export type SideEffectAuditMetadataInput = Omit<SideEffectAuditMetadataV1, "redaction"> & {
-    readonly redaction?: never;
-};
-export type SideEffectAuditEventInput = Omit<SideEffectAuditEventV1, "schemaVersion" | "kind" | "metadata"> & {
-    readonly metadata?: SideEffectAuditMetadataInput;
-};
-export interface SideEffectAuditSessionScopedInput {
-    readonly workspaceId: string;
-    readonly sessionId: string;
-    readonly observedAt: string;
-    readonly actor: SideEffectAuditActorInput;
-    readonly correlation?: SideEffectAuditCorrelationInput;
-    readonly metadata?: SideEffectAuditMetadataInput;
-}
-export type SideEffectAuditRedactionReason = "forbidden_field_name" | "uninspectable_value" | "bearer_token" | "provider_key" | "signed_url" | "object_store_key" | "vault_id" | "private_resource_handle" | "raw_url" | "raw_path" | "high_entropy_token";
-export interface SideEffectAuditRedactionFinding {
-    readonly path: string;
-    readonly reason: SideEffectAuditRedactionReason;
-    readonly valueLength?: number;
-}
-export declare class SideEffectAuditRedactionError extends Error {
-    readonly code = "side_effect_audit_not_public_safe";
-    readonly findings: readonly SideEffectAuditRedactionFinding[];
-    constructor(findings: readonly SideEffectAuditRedactionFinding[]);
-}
-export declare function buildSideEffectAuditEvent(input: SideEffectAuditEventInput): SideEffectAuditEventV1;
-export declare function buildSessionDeletionRequestedAuditEvent(input: SideEffectAuditSessionScopedInput): SideEffectAuditEventV1;
-export declare function buildSessionDeletionCompletedAuditEvent(input: SideEffectAuditSessionScopedInput): SideEffectAuditEventV1;
-export declare function buildSessionDeletionFailedAuditEvent(input: SideEffectAuditSessionScopedInput): SideEffectAuditEventV1;
-export declare function buildSessionDownloadRequestedAuditEvent(input: SideEffectAuditSessionScopedInput): SideEffectAuditEventV1;
-export declare function buildCustodyManifestWrittenAuditEvent(input: SideEffectAuditSessionScopedInput): SideEffectAuditEventV1;
-export declare function redactSideEffectAuditMetadata(input: SideEffectAuditMetadataInput, action?: SideEffectAuditAction): SideEffectAuditMetadataV1;
-export declare function scanSideEffectAuditPayloadForSensitiveValues(input: unknown): readonly SideEffectAuditRedactionFinding[];
-export declare function assertPublicSafeSideEffectAuditPayload(input: unknown): void;