import type { VcMeetingConsumerManagedSink, VcMeetingConsumerProfileFilter, VcMeetingListenerOutputPlacement } from '../types.js';
export declare const VC_MEETING_DELIVERY_SCHEMA_VERSION: 1;
export declare const VC_MEETING_DELIVERY_KEY_NAMESPACE = "vc_";
export declare const VC_MEETING_DELIVERY_KEY_MAX_LENGTH = 50;
export declare const VC_MEETING_DELIVERY_KINDS: readonly ["item", "final", "gap", "effect_result", "control"];
export type VcMeetingDeliveryKind = typeof VC_MEETING_DELIVERY_KINDS[number];
export declare const VC_MEETING_DELIVERY_GAP_REASONS: readonly ["retention_expired", "poll_unavailable", "recovery_ambiguous", "backpressure_skipped", "operator_skip"];
export type VcMeetingDeliveryGapReason = typeof VC_MEETING_DELIVERY_GAP_REASONS[number];
export declare const VC_MEETING_MEMBER_STATUSES: readonly ["active", "paused", "removed"];
export type VcMeetingMemberStatus = typeof VC_MEETING_MEMBER_STATUSES[number];
export declare const VC_MEETING_RESPONSE_MODES: readonly ["silent", "listener_thread"];
export type VcMeetingResponseMode = typeof VC_MEETING_RESPONSE_MODES[number];
export declare const VC_MEETING_LISTENER_OUTPUT_PLACEMENTS: readonly ["auto", "chat", "topic"];
export interface VcMeetingMemberProjectionRequest {
    schemaVersion: typeof VC_MEETING_DELIVERY_SCHEMA_VERSION;
    meeting: {
        listenerAppId: string;
        meetingId: string;
        ownerBootId: string;
        ownerEpoch: number;
    };
    member: {
        memberId: string;
        agentAppId: string;
        role: string;
        /** Trusted operator-authored profile instructions. They belong to the
         * membership projection, not to individual delivery envelopes. */
        instructions?: string;
        epoch: number;
        membershipGeneration: number;
        status: VcMeetingMemberStatus;
        joinedAtIngestSeq: number;
        responseMode: VcMeetingResponseMode;
        /** Optional only so an MA-P0 sender can be rolled forward without a flag day. */
        filter?: VcMeetingConsumerProfileFilter;
        capabilities?: string[];
        ownedSinks?: VcMeetingConsumerManagedSink[];
        sinkOwnerGeneration?: number;
    };
    outputRoute: {
        chatId: string;
        /** Omitted by pre-feature senders and normalized to `auto`. */
        placement?: VcMeetingListenerOutputPlacement;
    };
}
export type NormalizedVcMeetingMemberProjectionRequest = Omit<VcMeetingMemberProjectionRequest, 'member' | 'outputRoute'> & {
    member: VcMeetingMemberProjectionRequest['member'] & {
        capabilities: string[];
        ownedSinks: VcMeetingConsumerManagedSink[];
        sinkOwnerGeneration: number;
    };
    outputRoute: {
        chatId: string;
        placement: VcMeetingListenerOutputPlacement;
    };
};
export type VcMeetingMemberProjectionValidationResult = {
    ok: true;
    request: NormalizedVcMeetingMemberProjectionRequest;
} | {
    ok: false;
    errorCode: 'bad_request';
    error: string;
    path?: string;
};
export interface VcMeetingDeliveryGap {
    occurredFromMs?: number;
    occurredToMs?: number;
    missingItemVersionKey?: string;
    originalContentHash?: string;
    reason: VcMeetingDeliveryGapReason;
}
export interface VcMeetingDeliveryEntry {
    deliverySeq: number;
    ingestSeq?: number;
    itemVersionKey?: string;
    contentHash?: string;
    kind: VcMeetingDeliveryKind;
    controlKey?: string;
    gap?: VcMeetingDeliveryGap;
    rawText: string;
}
export interface VcMeetingDeliveryRequest {
    schemaVersion: typeof VC_MEETING_DELIVERY_SCHEMA_VERSION;
    meeting: {
        listenerAppId: string;
        meetingId: string;
        ownerBootId: string;
        ownerEpoch: number;
    };
    member: {
        memberId: string;
        agentAppId: string;
        role: string;
        epoch: number;
        membershipGeneration: number;
    };
    stream: {
        fromSeq: number;
        toSeq: number;
        /** Observability-only identifier. It is frozen with an accepted envelope. */
        batchId: string;
        inputHash: string;
        final: boolean;
    };
    entries: VcMeetingDeliveryEntry[];
    target: {
        sessionId: string;
        chatId: string;
    };
    instructionVersion: string;
    /** Transport metadata is deliberately outside the canonical input. */
    sentAt?: string;
    traceId?: string;
}
export type CanonicalVcMeetingDeliveryInput = Omit<VcMeetingDeliveryRequest, 'stream' | 'sentAt' | 'traceId'> & {
    stream: Omit<VcMeetingDeliveryRequest['stream'], 'inputHash'>;
};
export interface VcMeetingDeliveryIdentity {
    inputHash: string;
    deliveryKey: string;
}
export type VcMeetingDeliveryValidationErrorCode = 'bad_request' | 'entries_not_contiguous' | 'final_mismatch' | 'input_hash_mismatch';
export type VcMeetingDeliveryValidationResult = {
    ok: true;
    request: VcMeetingDeliveryRequest;
    identity: VcMeetingDeliveryIdentity;
} | {
    ok: false;
    errorCode: VcMeetingDeliveryValidationErrorCode;
    error: string;
    path?: string;
    expectedInputHash?: string;
};
export interface VcMeetingDeliveryKeyInput {
    meetingId: string;
    memberId: string;
    epoch: number;
    fromSeq: number;
    toSeq: number;
    inputHash: string;
}
/** Validate the fenced hub -> receiver membership projection. The receiver
 *  chooses receiverSessionId after this step; the hub cannot inject one. */
export declare function validateVcMeetingMemberProjectionRequest(raw: unknown): VcMeetingMemberProjectionValidationResult;
/**
 * Return the full semantic delivery envelope used for input immutability.
 * Transport timestamps/trace ids and the claimed inputHash are excluded.
 *
 * This function intentionally copies the v1 schema field-by-field. Callers
 * must bump schemaVersion and this projection together when adding a semantic
 * field, so an unrecognised transport property cannot silently change runtime
 * behaviour without entering the hash.
 */
export declare function canonicalVcMeetingDeliveryInput(request: VcMeetingDeliveryRequest): CanonicalVcMeetingDeliveryInput;
export declare function computeVcMeetingDeliveryInputHash(request: VcMeetingDeliveryRequest): string;
/**
 * Derive a provider-safe, bounded key from the ordered stream identity and
 * canonical input hash. The canonical tuple avoids delimiter-boundary
 * collisions; the `vc_` prefix leaves 188 bits of truncated SHA-256 entropy.
 */
export declare function deriveVcMeetingDeliveryKey(input: VcMeetingDeliveryKeyInput): string;
export declare function deriveVcMeetingDeliveryIdentity(request: VcMeetingDeliveryRequest): VcMeetingDeliveryIdentity;
/** Validate and seal the v1 delivery envelope before any durable claim. */
export declare function validateVcMeetingDeliveryRequest(raw: unknown): VcMeetingDeliveryValidationResult;
//# sourceMappingURL=vc-meeting-delivery-protocol.d.ts.map