handoff-relay 0.1.0

package/dist/relay-service-BjF5HNvN.d.ts

@@ -0,0 +1,712 @@
+import { z } from 'zod';
+import Database from 'better-sqlite3';
+
+type AuditAction = 'accept' | 'approve' | 'archive' | 'clarify' | 'close' | 'configure_project_alias' | 'decline' | 'deliver' | 'draft' | 'edit' | 'hydrate' | 'invite' | 'reply' | 'rotate_approval_secret' | 'revoke' | 'rotate_token' | 'search' | 'send' | 'supersede' | 'view';
+interface AuditReceipt {
+    receipt_id: string;
+    action: AuditAction;
+    actor_member_id: string;
+    packet_id?: string;
+    workspace_id: string;
+    created_at: string;
+    metadata: Record<string, unknown>;
+    receipt_hash: string;
+}
+interface CreateReceiptInput {
+    action: AuditAction;
+    actorMemberId: string;
+    packetId?: string;
+    workspaceId: string;
+    metadata?: Record<string, unknown>;
+}
+declare function createAuditReceipt(input: CreateReceiptInput): AuditReceipt;
+
+declare const packetStatuses: readonly ["draft", "pending_sender_approval", "sent", "delivered", "viewed", "accepted", "clarification_requested", "response_drafting", "pending_recipient_approval", "replied", "hydrated", "archived", "declined", "expired", "superseded", "closed_resolved", "closed_unresolved"];
+declare const packetTypes: readonly ["ask", "share", "reply", "clarification"];
+declare const confidenceLevels: readonly ["low", "medium", "high"];
+declare const auditReceiptSchema: z.ZodObject<{
+    receipt_id: z.ZodString;
+    action: z.ZodString;
+    actor_member_id: z.ZodString;
+    packet_id: z.ZodOptional<z.ZodString>;
+    workspace_id: z.ZodString;
+    created_at: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    receipt_hash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const projectIdentitySchema: z.ZodObject<{
+    repo_name: z.ZodString;
+    git_remote_fingerprint: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    commit_hash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const claimSchema: z.ZodObject<{
+    claim_id: z.ZodString;
+    text: z.ZodString;
+    confidence: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    status: z.ZodEnum<{
+        superseded: "superseded";
+        observed: "observed";
+        inferred: "inferred";
+        suspected: "suspected";
+        disproven: "disproven";
+    }>;
+    evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    needs_recheck: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const evidenceSchema: z.ZodObject<{
+    evidence_id: z.ZodString;
+    kind: z.ZodEnum<{
+        file_excerpt: "file_excerpt";
+        command_output: "command_output";
+        test_failure: "test_failure";
+        error_message: "error_message";
+        log_excerpt: "log_excerpt";
+        diff_summary: "diff_summary";
+        ticket_link: "ticket_link";
+        pr_link: "pr_link";
+        human_note: "human_note";
+    }>;
+    label: z.ZodString;
+    source: z.ZodString;
+    excerpt: z.ZodDefault<z.ZodString>;
+    hash: z.ZodString;
+    captured_at: z.ZodString;
+    sensitivity: z.ZodDefault<z.ZodEnum<{
+        normal: "normal";
+        private: "private";
+        secret_detected: "secret_detected";
+        restricted: "restricted";
+    }>>;
+}, z.core.$strict>;
+declare const redactionFindingSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        api_key: "api_key";
+        private_key: "private_key";
+        credential_url: "credential_url";
+        env_secret: "env_secret";
+        local_path: "local_path";
+        oversized_excerpt: "oversized_excerpt";
+        user_pattern: "user_pattern";
+    }>;
+    field: z.ZodString;
+    evidence_id: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<{
+        warning: "warning";
+        block: "block";
+    }>;
+    message: z.ZodString;
+    preview: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const redactionReportSchema: z.ZodObject<{
+    blocked: z.ZodBoolean;
+    findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            api_key: "api_key";
+            private_key: "private_key";
+            credential_url: "credential_url";
+            env_secret: "env_secret";
+            local_path: "local_path";
+            oversized_excerpt: "oversized_excerpt";
+            user_pattern: "user_pattern";
+        }>;
+        field: z.ZodString;
+        evidence_id: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            block: "block";
+        }>;
+        message: z.ZodString;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            api_key: "api_key";
+            private_key: "private_key";
+            credential_url: "credential_url";
+            env_secret: "env_secret";
+            local_path: "local_path";
+            oversized_excerpt: "oversized_excerpt";
+            user_pattern: "user_pattern";
+        }>;
+        field: z.ZodString;
+        evidence_id: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            block: "block";
+        }>;
+        message: z.ZodString;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const hydrationPolicySchema: z.ZodObject<{
+    requires_recipient_approval: z.ZodDefault<z.ZodBoolean>;
+    requires_sender_approval_for_replies: z.ZodDefault<z.ZodBoolean>;
+    allow_raw_transcript: z.ZodDefault<z.ZodBoolean>;
+    max_characters: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+declare const packetSchema: z.ZodObject<{
+    packet_id: z.ZodString;
+    packet_type: z.ZodEnum<{
+        ask: "ask";
+        reply: "reply";
+        share: "share";
+        clarification: "clarification";
+    }>;
+    workspace_id: z.ZodString;
+    sender_member_id: z.ZodString;
+    recipient_member_ids: z.ZodArray<z.ZodString>;
+    parent_packet_id: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    expires_at: z.ZodOptional<z.ZodString>;
+    recheck_by: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        draft: "draft";
+        pending_sender_approval: "pending_sender_approval";
+        sent: "sent";
+        delivered: "delivered";
+        viewed: "viewed";
+        accepted: "accepted";
+        clarification_requested: "clarification_requested";
+        response_drafting: "response_drafting";
+        pending_recipient_approval: "pending_recipient_approval";
+        replied: "replied";
+        hydrated: "hydrated";
+        archived: "archived";
+        declined: "declined";
+        expired: "expired";
+        superseded: "superseded";
+        closed_resolved: "closed_resolved";
+        closed_unresolved: "closed_unresolved";
+    }>;
+    project: z.ZodObject<{
+        repo_name: z.ZodString;
+        git_remote_fingerprint: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+        commit_hash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    source_client: z.ZodEnum<{
+        generic: "generic";
+        "claude-code": "claude-code";
+        codex: "codex";
+        cursor: "cursor";
+        other: "other";
+    }>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    question: z.ZodOptional<z.ZodString>;
+    finding: z.ZodOptional<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    claims: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        claim_id: z.ZodString;
+        text: z.ZodString;
+        confidence: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        status: z.ZodEnum<{
+            superseded: "superseded";
+            observed: "observed";
+            inferred: "inferred";
+            suspected: "suspected";
+            disproven: "disproven";
+        }>;
+        evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        needs_recheck: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        evidence_id: z.ZodString;
+        kind: z.ZodEnum<{
+            file_excerpt: "file_excerpt";
+            command_output: "command_output";
+            test_failure: "test_failure";
+            error_message: "error_message";
+            log_excerpt: "log_excerpt";
+            diff_summary: "diff_summary";
+            ticket_link: "ticket_link";
+            pr_link: "pr_link";
+            human_note: "human_note";
+        }>;
+        label: z.ZodString;
+        source: z.ZodString;
+        excerpt: z.ZodDefault<z.ZodString>;
+        hash: z.ZodString;
+        captured_at: z.ZodString;
+        sensitivity: z.ZodDefault<z.ZodEnum<{
+            normal: "normal";
+            private: "private";
+            secret_detected: "secret_detected";
+            restricted: "restricted";
+        }>>;
+    }, z.core.$strict>>>;
+    files_or_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    commands_or_tests_run: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    what_was_tried: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    known_failures: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    current_hypothesis: z.ZodDefault<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    suggested_next_steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    redaction_report: z.ZodObject<{
+        blocked: z.ZodBoolean;
+        findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                api_key: "api_key";
+                private_key: "private_key";
+                credential_url: "credential_url";
+                env_secret: "env_secret";
+                local_path: "local_path";
+                oversized_excerpt: "oversized_excerpt";
+                user_pattern: "user_pattern";
+            }>;
+            field: z.ZodString;
+            evidence_id: z.ZodOptional<z.ZodString>;
+            severity: z.ZodEnum<{
+                warning: "warning";
+                block: "block";
+            }>;
+            message: z.ZodString;
+            preview: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        warnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                api_key: "api_key";
+                private_key: "private_key";
+                credential_url: "credential_url";
+                env_secret: "env_secret";
+                local_path: "local_path";
+                oversized_excerpt: "oversized_excerpt";
+                user_pattern: "user_pattern";
+            }>;
+            field: z.ZodString;
+            evidence_id: z.ZodOptional<z.ZodString>;
+            severity: z.ZodEnum<{
+                warning: "warning";
+                block: "block";
+            }>;
+            message: z.ZodString;
+            preview: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    hydration_policy: z.ZodObject<{
+        requires_recipient_approval: z.ZodDefault<z.ZodBoolean>;
+        requires_sender_approval_for_replies: z.ZodDefault<z.ZodBoolean>;
+        allow_raw_transcript: z.ZodDefault<z.ZodBoolean>;
+        max_characters: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    audit_receipt: z.ZodObject<{
+        receipt_id: z.ZodString;
+        action: z.ZodString;
+        actor_member_id: z.ZodString;
+        packet_id: z.ZodOptional<z.ZodString>;
+        workspace_id: z.ZodString;
+        created_at: z.ZodString;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        receipt_hash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+type PacketStatus = (typeof packetStatuses)[number];
+type PacketType = (typeof packetTypes)[number];
+type RelayPacket = z.infer<typeof packetSchema>;
+type RelayEvidence = z.infer<typeof evidenceSchema>;
+type RelayClaim = z.infer<typeof claimSchema>;
+type RedactionReport = z.infer<typeof redactionReportSchema>;
+type RedactionFinding = z.infer<typeof redactionFindingSchema>;
+type HydrationPolicy = z.infer<typeof hydrationPolicySchema>;
+type ProjectIdentity = z.infer<typeof projectIdentitySchema>;
+interface ContextBudgetLimits {
+    summaryCharacters: number;
+    mainTextCharacters: number;
+    maxClaims: number;
+    maxEvidence: number;
+    maxExcerptCharacters: number;
+    maxHydrationCharacters: number;
+}
+declare const defaultContextBudget: ContextBudgetLimits;
+interface BuildPacketDraftInput {
+    packet_type: PacketType;
+    workspace_id: string;
+    sender_member_id: string;
+    recipient_member_ids: string[];
+    source_client: RelayPacket['source_client'];
+    title: string;
+    summary: string;
+    question?: string;
+    finding?: string;
+    answer?: string;
+    parent_packet_id?: string;
+    project?: Partial<ProjectIdentity>;
+    claims?: Partial<RelayClaim>[];
+    evidence?: Partial<RelayEvidence>[];
+    files_or_symbols?: string[];
+    commands_or_tests_run?: string[];
+    what_was_tried?: string[];
+    known_failures?: string[];
+    current_hypothesis?: string;
+    confidence?: RelayPacket['confidence'];
+    suggested_next_steps?: string[];
+    expires_at?: string;
+    recheck_by?: string;
+    status?: PacketStatus;
+    redaction_report?: RedactionReport;
+    hydration_policy?: Partial<HydrationPolicy>;
+}
+interface ContextBudgetResult {
+    ok: boolean;
+    violations: string[];
+}
+declare function normalizeEvidence(evidence: Partial<RelayEvidence>, index: number): RelayEvidence;
+declare function normalizeClaim(claim: Partial<RelayClaim>, index: number): RelayClaim;
+declare function buildPacketDraft(input: BuildPacketDraftInput): RelayPacket;
+declare function validateContextBudget(packet: RelayPacket, limits?: Partial<ContextBudgetLimits>): ContextBudgetResult;
+declare function compressPacketToBudget(packet: RelayPacket, limits?: Partial<ContextBudgetLimits>): RelayPacket;
+
+interface HydrationInput {
+    hydratedBy: string;
+    client: string;
+    sessionId?: string;
+    maxCharacters?: number;
+}
+interface HydrationResult {
+    context: string;
+    receipt: AuditReceipt;
+}
+declare function formatHydrationContext(packet: RelayPacket, input: HydrationInput): HydrationResult;
+
+type MemberRole = 'admin' | 'member';
+type MemberStatus = 'active' | 'revoked';
+interface WorkspaceRecord {
+    id: string;
+    name: string;
+    admin_body_access: boolean;
+    created_at: string;
+}
+interface MemberRecord {
+    id: string;
+    workspace_id: string;
+    handle: string;
+    display_name: string;
+    role: MemberRole;
+    status: MemberStatus;
+    token?: string;
+    approval_secret?: string;
+    created_at: string;
+    revoked_at?: string;
+}
+interface InviteRecord {
+    id: string;
+    workspace_id: string;
+    handle: string;
+    token: string;
+    created_by_member_id: string;
+    expires_at: string;
+    accepted_at?: string;
+    created_at: string;
+}
+declare function createId(prefix: string): string;
+declare function createToken(prefix?: string): string;
+declare function hashToken(token: string): string;
+declare function normalizeHandle(handle: string): string;
+
+type RelayDatabase = Database.Database;
+declare function createRelayDatabase(path?: string): RelayDatabase;
+
+interface CreateWorkspaceInput {
+    name: string;
+    adminHandle: string;
+    adminName: string;
+    adminBodyAccess?: boolean;
+}
+type ApprovalAction = 'hydrate' | 'reply' | 'send';
+type HistoryFilter = 'all' | 'closed' | 'drafts' | 'open' | 'sent';
+interface PacketQueryFilters {
+    project?: string;
+    sender?: string;
+    recipient?: string;
+    status?: PacketStatus;
+    fileOrSymbol?: string;
+    ticketOrPr?: string;
+}
+interface ProjectAliasRecord {
+    id: string;
+    workspace_id: string;
+    canonical_project: string;
+    alias: string;
+    created_by_member_id: string;
+    created_at: string;
+}
+interface ApprovalTokenResult {
+    approval_token: string;
+    action: ApprovalAction;
+    packet_id: string;
+    expires_at: string;
+}
+interface PacketDraftOptions {
+    authToken: string;
+    workspaceId: string;
+    to: string;
+    title: string;
+    summary: string;
+    sourceClient: RelayPacket['source_client'];
+    project?: Partial<ProjectIdentity>;
+    evidence?: Partial<RelayEvidence>[];
+    claims?: BuildPacketDraftInput['claims'];
+    filesOrSymbols?: string[];
+    commandsOrTestsRun?: string[];
+    whatWasTried?: string[];
+    knownFailures?: string[];
+    currentHypothesis?: string;
+    confidence?: RelayPacket['confidence'];
+    suggestedNextSteps?: string[];
+}
+interface AskDraftInput extends PacketDraftOptions {
+    question: string;
+}
+interface ShareDraftInput extends PacketDraftOptions {
+    finding: string;
+}
+interface ReplyDraftInput {
+    authToken: string;
+    packetId: string;
+    answer: string;
+    summary: string;
+    sourceClient: RelayPacket['source_client'];
+    title?: string;
+    evidence?: Partial<RelayEvidence>[];
+    confidence?: RelayPacket['confidence'];
+}
+interface UpdateDraftInput {
+    authToken: string;
+    packetId: string;
+    title?: string;
+    summary?: string;
+    question?: string;
+    finding?: string;
+    claims?: BuildPacketDraftInput['claims'];
+    evidence?: Partial<RelayEvidence>[];
+    filesOrSymbols?: string[];
+    commandsOrTestsRun?: string[];
+    whatWasTried?: string[];
+    knownFailures?: string[];
+    currentHypothesis?: string;
+    confidence?: RelayPacket['confidence'];
+    suggestedNextSteps?: string[];
+}
+interface PacketResult {
+    id: string;
+    packet: RelayPacket;
+}
+interface PacketSearchResult {
+    packet_id: string;
+    packet_type: RelayPacket['packet_type'];
+    workspace_id: string;
+    sender_member_id: string;
+    recipient_member_ids: string[];
+    status: RelayPacket['status'];
+    title: string;
+    summary: string;
+    project: RelayPacket['project'];
+    source_client: RelayPacket['source_client'];
+    created_at: string;
+    updated_at: string;
+    expires_at?: string;
+    recheck_by?: string;
+    body_access: boolean;
+}
+declare class RelayService {
+    private readonly db;
+    constructor(db: RelayDatabase);
+    close(): void;
+    createWorkspace(input: CreateWorkspaceInput): {
+        workspace: WorkspaceRecord;
+        admin: MemberRecord & {
+            token: string;
+            approval_secret: string;
+        };
+    };
+    inviteMember(input: {
+        adminToken: string;
+        workspaceId: string;
+        handle: string;
+    }): {
+        invite: InviteRecord;
+    };
+    acceptInvite(input: {
+        inviteToken: string;
+        displayName: string;
+    }): {
+        member: MemberRecord & {
+            token: string;
+            approval_secret: string;
+        };
+        workspace: WorkspaceRecord;
+    };
+    getInvite(input: {
+        inviteToken: string;
+    }): {
+        invite: InviteRecord;
+        workspace: WorkspaceRecord;
+    };
+    listMembers(input: {
+        authToken: string;
+        workspaceId: string;
+    }): MemberRecord[];
+    configureProjectAlias(input: {
+        authToken: string;
+        workspaceId: string;
+        canonicalProject: string;
+        alias: string;
+    }): {
+        alias: ProjectAliasRecord;
+    };
+    listProjectAliases(input: {
+        authToken: string;
+        workspaceId: string;
+    }): ProjectAliasRecord[];
+    revokeMember(input: {
+        adminToken: string;
+        workspaceId: string;
+        memberId: string;
+    }): {
+        member: MemberRecord;
+    };
+    rotateMemberToken(input: {
+        authToken: string;
+    }): {
+        member: MemberRecord;
+        token: string;
+    };
+    rotateApprovalSecret(input: {
+        authToken: string;
+        approvalSecret?: string;
+    }): {
+        member: MemberRecord;
+        approval_secret: string;
+    };
+    createApprovalToken(input: {
+        authToken: string;
+        approvalSecret?: string;
+        packetId: string;
+        action: ApprovalAction;
+    }): ApprovalTokenResult;
+    createAskDraft(input: AskDraftInput): PacketResult;
+    createShareDraft(input: ShareDraftInput): PacketResult;
+    updateDraft(input: UpdateDraftInput): PacketResult;
+    approveAndSend(input: {
+        authToken: string;
+        packetId: string;
+        approvalToken?: string;
+        allowSecretOverride?: boolean;
+    }): PacketResult;
+    listInbox(input: {
+        authToken: string;
+        workspaceId: string;
+    }): RelayPacket[];
+    viewPacket(input: {
+        authToken: string;
+        packetId: string;
+    }): PacketResult;
+    getPacketForMember(input: {
+        authToken: string;
+        packetId: string;
+    }): PacketResult;
+    acceptPacket(input: {
+        authToken: string;
+        packetId: string;
+    }): PacketResult;
+    hydratePacket(input: {
+        authToken: string;
+        packetId: string;
+        client: string;
+        sessionId?: string;
+        approvalToken?: string;
+    }): ReturnType<typeof formatHydrationContext> & {
+        packet: RelayPacket;
+    };
+    createReplyDraft(input: ReplyDraftInput): PacketResult;
+    approveReply(input: {
+        authToken: string;
+        replyPacketId: string;
+        approvalToken?: string;
+    }): PacketResult;
+    declinePacket(input: {
+        authToken: string;
+        packetId: string;
+        reason?: string;
+    }): PacketResult;
+    archivePacket(input: {
+        authToken: string;
+        packetId: string;
+    }): PacketResult;
+    requestClarification(input: {
+        authToken: string;
+        packetId: string;
+        question: string;
+        requestedEvidence?: string[];
+    }): PacketResult;
+    closePacket(input: {
+        authToken: string;
+        packetId: string;
+        resolution: 'resolved' | 'unresolved';
+    }): PacketResult;
+    searchPackets(input: {
+        authToken: string;
+        workspaceId: string;
+        query?: string;
+    } & PacketQueryFilters): PacketSearchResult[];
+    listHistory(input: {
+        authToken: string;
+        workspaceId: string;
+        filter?: HistoryFilter;
+        query?: string;
+    } & PacketQueryFilters): PacketSearchResult[];
+    listAuditReceipts(input: {
+        authToken: string;
+        workspaceId: string;
+        packetId?: string;
+    }): AuditReceipt[];
+    getPacket(packetId: string): RelayPacket;
+    private createPacketDraft;
+    private preparePacket;
+    private authenticate;
+    private requireMember;
+    private requireAdmin;
+    private requireApprovalSecret;
+    private getWorkspace;
+    private getMember;
+    private findMemberByHandle;
+    private resolveRecipient;
+    private actorRole;
+    private canReadMetadata;
+    private canReadBody;
+    private requireReadable;
+    private searchHaystackFor;
+    private toSearchResult;
+    private auditFilterMetadata;
+    private matchesPacketQueryFilters;
+    private resolveCanonicalProjectName;
+    private memberSelectorMatches;
+    private matchesHistoryFilter;
+    private requireSender;
+    private requireRecipient;
+    private assertApprovalTokenAllowed;
+    private consumeApprovalToken;
+    private transitionPacket;
+    private insertPacket;
+    private updatePacket;
+    private listWorkspacePackets;
+    private createNotification;
+    private recordAudit;
+    private insertAuditReceipt;
+}
+
+export { normalizeHandle as $, type ApprovalAction as A, type BuildPacketDraftInput as B, type ContextBudgetLimits as C, auditReceiptSchema as D, buildPacketDraft as E, claimSchema as F, compressPacketToBudget as G, type HistoryFilter as H, type InviteRecord as I, confidenceLevels as J, createAuditReceipt as K, createId as L, type MemberRecord as M, createRelayDatabase as N, createToken as O, type PacketStatus as P, defaultContextBudget as Q, RelayService as R, type ShareDraftInput as S, evidenceSchema as T, type UpdateDraftInput as U, formatHydrationContext as V, type WorkspaceRecord as W, hashToken as X, hydrationPolicySchema as Y, normalizeClaim as Z, normalizeEvidence as _, type PacketType as a, packetSchema as a0, packetStatuses as a1, packetTypes as a2, projectIdentitySchema as a3, redactionFindingSchema as a4, redactionReportSchema as a5, validateContextBudget as a6, type RelayPacket as b, type RedactionReport as c, type ApprovalTokenResult as d, type AskDraftInput as e, type AuditAction as f, type AuditReceipt as g, type ContextBudgetResult as h, type CreateReceiptInput as i, type CreateWorkspaceInput as j, type HydrationInput as k, type HydrationPolicy as l, type HydrationResult as m, type MemberRole as n, type MemberStatus as o, type PacketDraftOptions as p, type PacketQueryFilters as q, type PacketResult as r, type PacketSearchResult as s, type ProjectAliasRecord as t, type ProjectIdentity as u, type RedactionFinding as v, type RelayClaim as w, type RelayDatabase as x, type RelayEvidence as y, type ReplyDraftInput as z };