@splitin/verification-engine 0.1.0-beta.0

package/dist/index.d.cts

@@ -0,0 +1,737 @@
+import { VerificationProviderCode, VerificationProviderEnvironment, VerificationAdapterV1, VerificationPackageCode, VerificationCanonicalStatus, ActorContext, ProtectedActionDenial, ProviderOrganizationInput, ProviderRelationshipInput, ProviderLaunchEnvelope } from '@splitin/verification-adapter-sdk';
+export { ActorContext, ProtectedActionDenial, VerificationCanonicalStatus, VerificationPackageCode, VerificationProviderCode, VerificationProviderEnvironment } from '@splitin/verification-adapter-sdk';
+
+type EngineErrorCode = 'AUTHORIZATION_DENIED' | 'CLIENT_ROUTE_INJECTION' | 'NO_ELIGIBLE_ROUTE' | 'ATTEMPT_NOT_FOUND' | 'ATTEMPT_PINNED' | 'ATTEMPT_TERMINAL' | 'OPERATION_PENDING' | 'PRODUCTION_NOT_ACTIVATED' | 'WEBHOOK_SECURITY_INCIDENT' | 'WEBHOOK_UNAUTHENTICATED' | 'CONTINUATION_DENIED' | 'GOVERNANCE_TWO_ACTOR' | 'INVALID_TRANSITION' | 'INVALID_COMMAND' | 'PROVIDER_UNAVAILABLE' | 'DESTINATION_NOT_ALLOWLISTED';
+declare class EngineError extends Error {
+    readonly code: EngineErrorCode;
+    readonly retryable: boolean;
+    readonly retryAfterSeconds?: number | undefined;
+    constructor(code: EngineErrorCode, message: string, retryable?: boolean, retryAfterSeconds?: number | undefined);
+}
+declare class AuthorizationError extends EngineError {
+    constructor(message?: string);
+}
+declare class ClientRouteInjectionError extends EngineError {
+    constructor(message?: string);
+}
+declare class WebhookSecurityIncidentError extends EngineError {
+    constructor(message?: string);
+}
+
+/** Canonical JSON: recursively sorted object keys, no insignificant whitespace. */
+declare function canonicalize(value: unknown): string;
+declare function digestCanonical(value: unknown): Promise<string>;
+
+declare function sha256Hex(payload: string | Uint8Array): Promise<string>;
+declare function hmacSha256Hex(secret: string, payload: string | Uint8Array): Promise<string>;
+declare function cohortBucket(tenantKey: string, subjectHash: string): Promise<number>;
+
+interface ProviderRegistry {
+    get(provider: VerificationProviderCode, environment?: VerificationProviderEnvironment): VerificationAdapterV1;
+    list(): VerificationAdapterV1[];
+    has(provider: VerificationProviderCode): boolean;
+}
+/**
+ * Explicit code imports only. Database rows cannot load packages.
+ */
+declare function createProviderRegistry(input: {
+    adapters: VerificationAdapterV1[];
+}): ProviderRegistry;
+
+declare const FORBIDDEN_CLIENT_ROUTE_KEYS: readonly ["provider", "templateId", "template_id", "workflowId", "workflow_id", "apiOrigin", "api_origin", "configurationRevision", "configuration_revision", "adapterVersion", "manifestDigest", "policyVersion", "routeId"];
+declare const LIVE_ATTEMPT_STATUSES: VerificationCanonicalStatus[];
+declare const GOVERNANCE_TRANSITIONS: readonly ["approve", "deny", "request_more_information", "revoke", "expire"];
+type GovernanceTransition = (typeof GOVERNANCE_TRANSITIONS)[number];
+type CircuitState = 'closed' | 'open' | 'half_open';
+type RouteLifecycle = 'draft' | 'approved' | 'active' | 'retired';
+type PolicyLifecycle = 'draft' | 'approved' | 'active' | 'retired';
+type IdempotencyState = 'claimed' | 'completed' | 'failed';
+type WebhookEventState = 'accepted' | 'processing' | 'completed' | 'retryable' | 'dead_letter';
+type RedactionStatus = 'scheduled' | 'processing' | 'retryable' | 'redacted' | 'not_applicable' | 'dead_letter';
+type QueueJobKind = 'webhook' | 'reconcile' | 'redact';
+type AppealStatus = 'open' | 'approved' | 'denied' | 'more_information_requested' | 'revoked' | 'expired';
+type ReviewStatus = AppealStatus | 'in_review';
+type ProposalStatus = 'proposed' | 'approved' | 'rejected';
+type DecisionStatus = 'verified' | 'declined' | 'revoked' | 'expired';
+/** Application-defined reason codes the SDK stores without interpreting housing or biometric policy. */
+declare const APPLICATION_REASON_CODES: readonly ["underage", "unsupported_capability", "biometric_alternative_requested", "manual_review_required", "document_unreadable", "more_information_requested"];
+declare function isApplicationReasonCode(value: string): value is ApplicationReasonCode;
+type ApplicationReasonCode = (typeof APPLICATION_REASON_CODES)[number];
+type EngineOperation = 'start' | 'resume' | 'status' | 'retry' | 'pause' | 'cancel' | 'redact' | 'ingest_webhook' | 'process_webhook' | 'reconcile' | 'appeal' | 'review' | 'evaluate_protected_action' | 'admin.health' | 'admin.routes' | 'admin.circuits' | 'admin.attempts' | 'admin.audit' | 'admin.propose_route' | 'admin.approve_route' | 'admin.propose_policy' | 'admin.approve_policy' | 'admin.activate_policy' | 'admin.emergency_drain';
+interface AuthorizeFn {
+    (actor: ActorContext, operation: EngineOperation, resource: {
+        type: string;
+        id?: string;
+    }): Promise<boolean> | boolean;
+}
+interface EngineRuntime {
+    now?: () => Date;
+    crypto?: Crypto;
+    productionEnabled?: boolean;
+    seedSandboxExamples?: boolean;
+    continuationTtlSeconds?: number;
+    webhookLeaseSeconds?: number;
+    maxWorkerAttempts?: number;
+    workerConcurrency?: number;
+    defaultDecisionTtlSeconds?: number;
+    rateBudgetPerProvider?: number;
+    random?: () => number;
+}
+interface StartVerificationCommand {
+    packageCode: VerificationPackageCode;
+    countryCode: string;
+    subjectReference: string;
+    idempotencyKey: string;
+    action?: string | null;
+    resourceType?: string | null;
+    resourceReference?: string | null;
+    organization?: ProviderOrganizationInput | null;
+    relationship?: ProviderRelationshipInput | null;
+    associatedPerson?: ProviderAssociatedPersonLike | null;
+    legalFirstName?: string | null;
+    legalLastName?: string | null;
+    email?: string | null;
+    requestOrigin?: string | null;
+    metadata?: Record<string, string | number | boolean | null>;
+    evidenceReferences?: string[];
+}
+interface ProviderAssociatedPersonLike {
+    subjectReference: string;
+    legalFirstName: string;
+    legalLastName: string;
+    email?: string | null;
+    relationshipKind: string;
+    claimedOwnershipPercentage?: number | null;
+}
+interface ResumeVerificationCommand {
+    attemptId: string;
+    requestOrigin?: string | null;
+}
+interface RetryVerificationCommand extends StartVerificationCommand {
+    parentAttemptId: string;
+}
+interface RedactCommand {
+    subjectReference: string;
+    attemptId?: string | null;
+    requestReference?: string | null;
+}
+interface ProtectedActionCommand {
+    action: string;
+    resourceType: string;
+    resourceReference: string;
+    subjectReference: string;
+    destinationKey?: string;
+}
+interface IngestWebhookCommand {
+    provider: VerificationProviderCode;
+    request: Request;
+    tenantKey: string;
+}
+interface AppealSubmitCommand {
+    attemptId: string;
+    reason: string;
+    expiresAt?: string | null;
+}
+interface AppealTransitionCommand {
+    appealId: string;
+    transition: GovernanceTransition;
+    reason: string;
+}
+interface ReviewProposeCommand {
+    attemptId: string;
+    proposedStatus: DecisionStatus;
+    reason: string;
+    expiresAt?: string | null;
+}
+interface ReviewDecideCommand {
+    proposalId: string;
+    transition: Extract<GovernanceTransition, 'approve' | 'deny'>;
+    reason: string;
+}
+interface ReviewCaseTransitionCommand {
+    reviewCaseId: string;
+    transition: GovernanceTransition;
+    reason: string;
+}
+interface SafeAttemptView {
+    attemptId: string;
+    packageCode: VerificationPackageCode;
+    status: VerificationCanonicalStatus;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    adapterVersion: string;
+    manifestDigest: string;
+    configurationRevision: string;
+    policyVersion: string;
+    canResume: boolean;
+    canRetry: boolean;
+    expiresAt: string | null;
+    safeErrorCode: string | null;
+    retryAfter: string | null;
+    supportPath: string | null;
+    launch: ProviderLaunchEnvelope | null;
+}
+interface ProtectedActionAllow {
+    allowed: true;
+}
+type ProtectedActionResult = ProtectedActionAllow | ProtectedActionDenial;
+interface TenantRecord {
+    tenantKey: string;
+    displayName: string;
+    continuationDestinations: string[];
+    createdAt: string;
+}
+interface ConfigurationRevisionRecord {
+    tenantKey: string;
+    id: string;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    revision: number;
+    configurationDigest: string;
+    lifecycle: 'draft' | 'approved' | 'retired';
+    proposedByActorId: string | null;
+    approvedByActorId: string | null;
+    approvedAt: string | null;
+    createdAt: string;
+}
+interface ProviderDefinitionRecord {
+    tenantKey: string;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    adapterVersion: string;
+    manifestDigest: string;
+    compiledInRegistry: boolean;
+    productionEligible: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RouteRecord {
+    tenantKey: string;
+    id: string;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    packageCode: VerificationPackageCode;
+    countryCode: string | null;
+    requiredCapability: string | null;
+    priority: number;
+    cohortMin: number;
+    cohortMax: number;
+    windowStart: string | null;
+    windowEnd: string | null;
+    allowlistRequired: boolean;
+    allowlistedSubjectHashes: string[];
+    configurationRevisionId: string;
+    policyVersionId: string;
+    lifecycle: RouteLifecycle;
+    proposedByActorId: string | null;
+    approvedByActorId: string | null;
+    approvedAt: string | null;
+    activatedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RouteChangeRequestRecord {
+    tenantKey: string;
+    id: string;
+    routeId: string | null;
+    proposedPayload: Record<string, string | number | boolean | null>;
+    status: ProposalStatus;
+    reason: string;
+    policyVersion: string;
+    proposedByActorId: string;
+    approvedByActorId: string | null;
+    approvedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+}
+interface PolicyVersionRecord {
+    tenantKey: string;
+    id: string;
+    version: string;
+    environment: VerificationProviderEnvironment;
+    lifecycle: PolicyLifecycle;
+    reason: string;
+    expiresAt: string | null;
+    proposedByActorId: string | null;
+    approvedByActorId: string | null;
+    approvedAt: string | null;
+    activatedAt: string | null;
+    createdAt: string;
+    decisionRetentionDays: number | null;
+    providerRedactionDelayDays: number | null;
+    appealHoldDays: number | null;
+    legalHold: boolean;
+}
+interface ProtectedActionRequirementRecord {
+    tenantKey: string;
+    id: string;
+    action: string;
+    packageCode: VerificationPackageCode;
+    policyVersionId: string;
+    createdAt: string;
+}
+interface AttemptRecord {
+    tenantKey: string;
+    id: string;
+    subjectHash: string;
+    packageCode: VerificationPackageCode;
+    countryCode: string;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    adapterVersion: string;
+    manifestDigest: string;
+    configurationRevision: string;
+    policyVersion: string;
+    providerResourceId: string | null;
+    providerStatus: string | null;
+    canonicalStatus: VerificationCanonicalStatus;
+    statusVersion: number;
+    idempotencyKey: string;
+    parentAttemptId: string | null;
+    purposeAction: string | null;
+    purposeResourceHash: string | null;
+    routeId: string;
+    selectionReason: string;
+    normalizedReasonCodes: string[];
+    expiresAt: string | null;
+    createClaimId: string | null;
+    createClaimExpiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ProviderResourceLineageRecord {
+    tenantKey: string;
+    id: string;
+    attemptId: string;
+    resourceType: string;
+    providerResourceId: string;
+    relationshipCode: string;
+    providerStatus: string;
+    occurredAt: string;
+}
+interface DecisionRecord {
+    tenantKey: string;
+    id: string;
+    subjectHash: string;
+    packageCode: VerificationPackageCode;
+    attemptId: string | null;
+    status: DecisionStatus;
+    source: 'provider' | 'manual';
+    policyVersion: string;
+    reasonCodes: string[];
+    effectiveAt: string;
+    expiresAt: string | null;
+    revokedAt: string | null;
+    proposerActorId: string | null;
+    approverActorId: string | null;
+    createdAt: string;
+}
+interface IdempotencyClaimRecord {
+    tenantKey: string;
+    claimKey: string;
+    operation: string;
+    attemptId: string | null;
+    state: IdempotencyState;
+    resultRef: string | null;
+    errorCode: string | null;
+    createdAt: string;
+    completedAt: string | null;
+}
+interface WebhookEventRecord {
+    tenantKey: string;
+    id: string;
+    provider: VerificationProviderCode;
+    providerEventKey: string;
+    providerResourceId: string;
+    eventType: string;
+    occurredAt: string;
+    bodySha256: string;
+    safeMetadata: Record<string, string | boolean | number | null>;
+    state: WebhookEventState;
+    receivedAt: string;
+}
+interface WebhookLeaseRecord {
+    tenantKey: string;
+    eventId: string;
+    leaseId: string | null;
+    workerId: string | null;
+    expiresAt: string | null;
+    attemptCount: number;
+    nextAttemptAt: string;
+    lastErrorCode: string | null;
+}
+interface JobRecord {
+    tenantKey: string;
+    id: string;
+    kind: QueueJobKind;
+    attemptId: string | null;
+    eventId: string | null;
+    subjectHash: string | null;
+    providerResourceId: string | null;
+    state: 'scheduled' | 'processing' | 'retryable' | 'completed' | 'dead_letter' | RedactionStatus;
+    leaseId: string | null;
+    leaseExpiresAt: string | null;
+    attemptCount: number;
+    nextAttemptAt: string;
+    lastErrorCode: string | null;
+    createdAt: string;
+}
+interface HealthObservationRecord {
+    tenantKey: string;
+    id: string;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    operation: string;
+    outcome: 'success' | 'retryable_failure' | 'terminal_failure' | 'unknown_status';
+    safeCode: string;
+    observedAt: string;
+    latencyMs: number | null;
+}
+interface CircuitRecord {
+    tenantKey: string;
+    provider: VerificationProviderCode;
+    environment: VerificationProviderEnvironment;
+    state: CircuitState;
+    reasonCode: string | null;
+    openUntil: string | null;
+    consecutiveFailures: number;
+    drainedByActorId: string | null;
+    updatedAt: string;
+}
+interface AppealRecord {
+    tenantKey: string;
+    id: string;
+    attemptId: string;
+    subjectHash: string;
+    status: AppealStatus;
+    reason: string;
+    policyVersion: string;
+    proposedByActorId: string;
+    decidedByActorId: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ReviewCaseRecord {
+    tenantKey: string;
+    id: string;
+    attemptId: string;
+    subjectHash: string;
+    status: ReviewStatus;
+    reason: string;
+    policyVersion: string;
+    assignedActorId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ManualDecisionProposalRecord {
+    tenantKey: string;
+    id: string;
+    reviewCaseId: string | null;
+    attemptId: string;
+    proposedStatus: DecisionStatus;
+    reason: string;
+    policyVersion: string;
+    expiresAt: string | null;
+    proposedByActorId: string;
+    approvedByActorId: string | null;
+    status: ProposalStatus;
+    createdAt: string;
+}
+interface ContinuationRecord {
+    tenantKey: string;
+    key: string;
+    tokenHash: string;
+    action: string;
+    resourceHash: string;
+    subjectHash: string;
+    destinationKey: string;
+    expiresAt: string;
+    consumedAt: string | null;
+}
+interface AuditEventRecord {
+    tenantKey: string;
+    id: string;
+    actorId: string;
+    actorType: ActorContext['actorType'];
+    operation: string;
+    resourceType: string;
+    resourceId: string | null;
+    reasonCode: string | null;
+    safeMetadata: Record<string, string | number | boolean | null>;
+    occurredAt: string;
+}
+interface WebhookClaimResult {
+    disposition: 'claimed' | 'duplicate' | 'mismatch' | 'in_progress' | 'dead_letter';
+    event: WebhookEventRecord;
+}
+interface IngestWebhookResult {
+    accepted: true;
+    duplicate: boolean;
+    eventId: string;
+}
+type RateAcquireResult = {
+    allowed: boolean;
+    retryAfterSeconds?: number;
+};
+
+interface PolicyStore {
+    getActivePolicy(tenantKey: string, environment: VerificationProviderEnvironment): Promise<PolicyVersionRecord | null>;
+    getPolicyVersion(tenantKey: string, id: string): Promise<PolicyVersionRecord | null>;
+    listPolicyVersions(tenantKey: string): Promise<PolicyVersionRecord[]>;
+    savePolicyVersion(policy: PolicyVersionRecord): Promise<void>;
+    listProtectedActionRequirements(tenantKey: string, action: string, policyVersionId: string): Promise<ProtectedActionRequirementRecord[]>;
+    saveProtectedActionRequirement(requirement: ProtectedActionRequirementRecord): Promise<void>;
+    getContinuationDestinations(tenantKey: string): Promise<string[]>;
+}
+interface VerificationStore extends PolicyStore {
+    now(): Date;
+    hashSubject(tenantKey: string, subjectReference: string): Promise<string>;
+    hashResource(tenantKey: string, resourceType: string, resourceReference: string): Promise<string>;
+    transact<T>(fn: (store: VerificationStore) => Promise<T>): Promise<T>;
+    getTenant(tenantKey: string): Promise<TenantRecord | null>;
+    ensureTenant(tenantKey: string, displayName?: string): Promise<TenantRecord>;
+    getConfigurationRevision(tenantKey: string, id: string): Promise<ConfigurationRevisionRecord | null>;
+    listConfigurationRevisions(tenantKey: string): Promise<ConfigurationRevisionRecord[]>;
+    saveConfigurationRevision(revision: ConfigurationRevisionRecord): Promise<void>;
+    upsertProviderDefinition(definition: ProviderDefinitionRecord): Promise<void>;
+    getProviderDefinition(tenantKey: string, provider: VerificationProviderCode, environment: VerificationProviderEnvironment): Promise<ProviderDefinitionRecord | null>;
+    listProviderDefinitions(tenantKey: string): Promise<ProviderDefinitionRecord[]>;
+    getRoute(tenantKey: string, routeId: string): Promise<RouteRecord | null>;
+    listRoutes(tenantKey: string): Promise<RouteRecord[]>;
+    listActiveRoutes(tenantKey: string, environment: VerificationProviderEnvironment): Promise<RouteRecord[]>;
+    saveRoute(route: RouteRecord): Promise<void>;
+    saveRouteChangeRequest(request: RouteChangeRequestRecord): Promise<void>;
+    getRouteChangeRequest(tenantKey: string, id: string): Promise<RouteChangeRequestRecord | null>;
+    listRouteChangeRequests(tenantKey: string): Promise<RouteChangeRequestRecord[]>;
+    getAttempt(tenantKey: string, attemptId: string): Promise<AttemptRecord | null>;
+    getAttemptByIdempotencyKey(tenantKey: string, key: string): Promise<AttemptRecord | null>;
+    findAttemptByProviderResource(tenantKey: string, provider: VerificationProviderCode, providerResourceId: string): Promise<AttemptRecord | null>;
+    listAttempts(tenantKey: string): Promise<AttemptRecord[]>;
+    listLiveAttempts(tenantKey: string, subjectHash: string, packageCode: VerificationPackageCode): Promise<AttemptRecord[]>;
+    insertAttempt(attempt: AttemptRecord): Promise<AttemptRecord>;
+    updateAttempt(attempt: AttemptRecord): Promise<void>;
+    insertLineage(row: ProviderResourceLineageRecord): Promise<void>;
+    listLineage(tenantKey: string, attemptId: string): Promise<ProviderResourceLineageRecord[]>;
+    getValidDecision(tenantKey: string, subjectHash: string, packageCode: VerificationPackageCode, at: Date): Promise<DecisionRecord | null>;
+    insertDecision(decision: DecisionRecord): Promise<void>;
+    listDecisions(tenantKey: string, subjectHash?: string): Promise<DecisionRecord[]>;
+    revokeDecision(tenantKey: string, decisionId: string, at: string): Promise<void>;
+    claimIdempotency(claim: IdempotencyClaimRecord): Promise<{
+        disposition: 'claimed' | 'existing';
+        claim: IdempotencyClaimRecord;
+    }>;
+    completeIdempotency(tenantKey: string, key: string, resultRef: string): Promise<void>;
+    failIdempotency(tenantKey: string, key: string, errorCode: string): Promise<void>;
+    getIdempotencyClaim(tenantKey: string, key: string): Promise<IdempotencyClaimRecord | null>;
+    claimWebhookEvent(input: {
+        tenantKey: string;
+        provider: VerificationProviderCode;
+        providerEventKey: string;
+        providerResourceId: string;
+        eventType: string;
+        occurredAt: string;
+        bodySha256: string;
+        safeMetadata: Record<string, string | boolean | number | null>;
+    }): Promise<WebhookClaimResult>;
+    getWebhookEvent(tenantKey: string, provider: VerificationProviderCode, eventKey: string): Promise<WebhookEventRecord | null>;
+    getWebhookEventById(tenantKey: string, eventId: string): Promise<WebhookEventRecord | null>;
+    settleWebhookEvent(tenantKey: string, eventId: string, outcome: 'completed' | 'retryable' | 'dead_letter', errorCode?: string): Promise<void>;
+    recordHealth(observation: HealthObservationRecord): Promise<void>;
+    listHealth(tenantKey: string, provider?: VerificationProviderCode): Promise<HealthObservationRecord[]>;
+    getCircuit(tenantKey: string, provider: VerificationProviderCode, environment: VerificationProviderEnvironment): Promise<CircuitRecord>;
+    saveCircuit(circuit: CircuitRecord): Promise<void>;
+    listCircuits(tenantKey: string): Promise<CircuitRecord[]>;
+    saveAppeal(appeal: AppealRecord): Promise<void>;
+    getAppeal(tenantKey: string, id: string): Promise<AppealRecord | null>;
+    listAppeals(tenantKey: string): Promise<AppealRecord[]>;
+    saveReviewCase(reviewCase: ReviewCaseRecord): Promise<void>;
+    getReviewCase(tenantKey: string, id: string): Promise<ReviewCaseRecord | null>;
+    listReviewCases(tenantKey: string): Promise<ReviewCaseRecord[]>;
+    saveManualDecisionProposal(proposal: ManualDecisionProposalRecord): Promise<void>;
+    getManualDecisionProposal(tenantKey: string, id: string): Promise<ManualDecisionProposalRecord | null>;
+    listManualDecisionProposals(tenantKey: string): Promise<ManualDecisionProposalRecord[]>;
+    saveContinuation(continuation: ContinuationRecord): Promise<void>;
+    getContinuation(tenantKey: string, key: string): Promise<ContinuationRecord | null>;
+    appendAudit(event: AuditEventRecord): Promise<void>;
+    listAudit(tenantKey: string): Promise<AuditEventRecord[]>;
+    saveJob(job: JobRecord): Promise<void>;
+    getJob(tenantKey: string, id: string): Promise<JobRecord | null>;
+    listJobs(tenantKey: string, kind?: QueueJobKind): Promise<JobRecord[]>;
+    claimJobs(input: {
+        tenantKey: string;
+        kinds: QueueJobKind[];
+        workerId: string;
+        leaseSeconds: number;
+        limit: number;
+        now: Date;
+    }): Promise<JobRecord[]>;
+    updateJob(job: JobRecord): Promise<void>;
+    updateRedactionStatus(tenantKey: string, jobId: string, status: RedactionStatus): Promise<void>;
+}
+
+interface MemoryStoreOptions {
+    hashSecret?: string;
+    now?: () => Date;
+    seedTenantKey?: string;
+}
+declare function createMemoryStore(options?: MemoryStoreOptions): VerificationStore & PolicyStore;
+
+interface VerificationQueue {
+    enqueue(job: JobRecord): Promise<void>;
+    claim(input: {
+        tenantKey: string;
+        kinds: QueueJobKind[];
+        workerId: string;
+        leaseSeconds: number;
+        limit: number;
+        now: Date;
+    }): Promise<JobRecord[]>;
+    complete(tenantKey: string, jobId: string, leaseId: string): Promise<void>;
+    retry(tenantKey: string, jobId: string, leaseId: string, options: {
+        errorCode: string;
+        retryAfterSeconds: number;
+        deadLetter?: boolean;
+    }): Promise<void>;
+}
+declare function backoffSeconds(attemptCount: number, retryAfterSeconds?: number, random?: () => number): number;
+
+declare function createMemoryQueue(store: VerificationStore, options?: {
+    random?: () => number;
+}): VerificationQueue;
+
+interface CreateVerificationPlatformInput {
+    registry: ProviderRegistry;
+    store: VerificationStore;
+    queue: VerificationQueue;
+    policyStore?: PolicyStore;
+    authorize: AuthorizeFn;
+    runtime?: EngineRuntime;
+}
+interface VerificationPlatform {
+    start(actor: ActorContext, command: StartVerificationCommand): Promise<SafeAttemptView>;
+    resume(actor: ActorContext, command: ResumeVerificationCommand): Promise<SafeAttemptView>;
+    status(actor: ActorContext, attemptId: string): Promise<SafeAttemptView>;
+    retry(actor: ActorContext, command: RetryVerificationCommand): Promise<SafeAttemptView>;
+    pause(actor: ActorContext, attemptId: string): Promise<SafeAttemptView>;
+    cancel(actor: ActorContext, attemptId: string): Promise<SafeAttemptView>;
+    redact(actor: ActorContext, command: RedactCommand): Promise<{
+        jobId: string;
+        status: string;
+    }>;
+    ingestWebhook(command: IngestWebhookCommand): Promise<IngestWebhookResult>;
+    processWebhookJob(tenantKey: string, job: JobRecord): Promise<void>;
+    reconcile(actor: ActorContext, attemptId?: string): Promise<{
+        reconciled: number;
+    }>;
+    appeal: {
+        submit(actor: ActorContext, command: AppealSubmitCommand): Promise<{
+            appealId: string;
+        }>;
+        transition(actor: ActorContext, command: AppealTransitionCommand): Promise<{
+            status: string;
+        }>;
+    };
+    review: {
+        propose(actor: ActorContext, command: ReviewProposeCommand): Promise<{
+            proposalId: string;
+            reviewCaseId: string;
+        }>;
+        decide(actor: ActorContext, command: ReviewDecideCommand): Promise<{
+            status: string;
+        }>;
+        transitionCase(actor: ActorContext, command: ReviewCaseTransitionCommand): Promise<{
+            status: string;
+        }>;
+    };
+    admin: {
+        health(actor: ActorContext): Promise<unknown>;
+        routes(actor: ActorContext): Promise<unknown>;
+        circuits(actor: ActorContext): Promise<unknown>;
+        attempts(actor: ActorContext): Promise<unknown>;
+        audit(actor: ActorContext): Promise<unknown>;
+        proposeRoute(actor: ActorContext, input: {
+            route: Omit<RouteRecord, 'lifecycle' | 'approvedByActorId' | 'approvedAt' | 'activatedAt'>;
+            reason: string;
+        }): Promise<{
+            requestId: string;
+        }>;
+        approveRoute(actor: ActorContext, requestId: string, reason: string): Promise<{
+            routeId: string;
+        }>;
+        proposePolicy(actor: ActorContext, input: {
+            version: string;
+            environment: 'sandbox' | 'production';
+            reason: string;
+            expiresAt?: string | null;
+            decisionRetentionDays?: number | null;
+            providerRedactionDelayDays?: number | null;
+            appealHoldDays?: number | null;
+            legalHold?: boolean;
+        }): Promise<{
+            policyId: string;
+        }>;
+        approvePolicy(actor: ActorContext, policyId: string, reason: string): Promise<{
+            policyId: string;
+        }>;
+        activatePolicy(actor: ActorContext, policyId: string): Promise<{
+            policyId: string;
+        }>;
+        emergencyDrain(actor: ActorContext, provider: string, environment: 'sandbox' | 'production', reason: string): Promise<{
+            state: string;
+        }>;
+    };
+    evaluateProtectedAction(actor: ActorContext, command: ProtectedActionCommand): Promise<ProtectedActionResult>;
+    workers: {
+        claim(actor: ActorContext, input?: {
+            workerId?: string;
+            kinds?: JobRecord['kind'][];
+            limit?: number;
+        }): Promise<JobRecord[]>;
+        process(actor: ActorContext, job: JobRecord | {
+            id: string;
+        }): Promise<{
+            processed: boolean;
+            disposition: string;
+        }>;
+        scheduleReconciliation(actor: ActorContext): Promise<{
+            enqueued: number;
+        }>;
+    };
+}
+declare function createVerificationPlatform(input: CreateVerificationPlatformInput): VerificationPlatform;
+
+interface RateBudget {
+    consume(provider: string, at?: Date): {
+        allowed: boolean;
+        retryAfterSeconds?: number;
+    };
+}
+declare function createRateBudget(limitPerSecond: number): RateBudget;
+
+declare function seedSandboxExamples(store: VerificationStore, registry: ProviderRegistry, runtime: EngineRuntime, tenantKey?: string): Promise<void>;
+
+interface RouteSelection {
+    route: RouteRecord;
+    adapter: VerificationAdapterV1;
+    reason: string;
+    usedFailover: boolean;
+}
+declare function selectRoute(input: {
+    store: VerificationStore;
+    adapters: VerificationAdapterV1[];
+    tenantKey: string;
+    packageCode: VerificationPackageCode;
+    countryCode: string;
+    subjectHash: string;
+    environment: VerificationProviderEnvironment;
+    runtime: EngineRuntime;
+    requiredCapability?: 'canResume' | 'canRetry' | 'canCancel' | 'canRedact' | null;
+}): Promise<RouteSelection>;
+
+declare function canTransitionStatus(current: VerificationCanonicalStatus, next: VerificationCanonicalStatus): boolean;
+declare function applyMonotonicStatus(current: VerificationCanonicalStatus, next: VerificationCanonicalStatus): VerificationCanonicalStatus;
+
+declare function assertNoClientRouting(command: object): void;
+
+export { APPLICATION_REASON_CODES, type AppealRecord, type AppealStatus, type AppealSubmitCommand, type AppealTransitionCommand, type ApplicationReasonCode, type AttemptRecord, type AuditEventRecord, AuthorizationError, type AuthorizeFn, type CircuitRecord, type CircuitState, ClientRouteInjectionError, type ConfigurationRevisionRecord, type ContinuationRecord, type CreateVerificationPlatformInput, type DecisionRecord, type DecisionStatus, EngineError, type EngineErrorCode, type EngineOperation, type EngineRuntime, FORBIDDEN_CLIENT_ROUTE_KEYS, GOVERNANCE_TRANSITIONS, type GovernanceTransition, type HealthObservationRecord, type IdempotencyClaimRecord, type IdempotencyState, type IngestWebhookCommand, type IngestWebhookResult, type JobRecord, LIVE_ATTEMPT_STATUSES, type ManualDecisionProposalRecord, type PolicyLifecycle, type PolicyStore, type PolicyVersionRecord, type ProposalStatus, type ProtectedActionAllow, type ProtectedActionCommand, type ProtectedActionRequirementRecord, type ProtectedActionResult, type ProviderDefinitionRecord, type ProviderRegistry, type ProviderResourceLineageRecord, type QueueJobKind, type RateAcquireResult, type RateBudget, type RedactCommand, type RedactionStatus, type ResumeVerificationCommand, type RetryVerificationCommand, type ReviewCaseRecord, type ReviewCaseTransitionCommand, type ReviewDecideCommand, type ReviewProposeCommand, type ReviewStatus, type RouteChangeRequestRecord, type RouteLifecycle, type RouteRecord, type SafeAttemptView, type StartVerificationCommand, type TenantRecord, type VerificationPlatform, type VerificationQueue, type VerificationStore, type WebhookClaimResult, type WebhookEventRecord, type WebhookEventState, type WebhookLeaseRecord, WebhookSecurityIncidentError, applyMonotonicStatus, assertNoClientRouting, backoffSeconds, canTransitionStatus, canonicalize, cohortBucket, createMemoryQueue, createMemoryStore, createProviderRegistry, createRateBudget, createVerificationPlatform, digestCanonical, hmacSha256Hex, isApplicationReasonCode, seedSandboxExamples, selectRoute, sha256Hex };