import { ActiveSession, type CommitPayload, type CommitReceipt, type MeteredEnvelope, type MeteringDirective } from './Session.js';
/**
 * Commit transport used by `SessionConsumer`.
 */
export interface CommitTransport {
    commit(parameters: CommitTransport.CommitParameters): Promise<CommitReceipt>;
}
export declare namespace CommitTransport {
    interface CommitParameters {
        /** Directive issued when the delivery was reserved. */
        readonly directive: MeteringDirective;
        /** Signed commit body to send. */
        readonly payload: CommitPayload;
    }
}
/**
 * Client-side Kafka-style consumer for metered session deliveries.
 */
export declare class SessionConsumer<Transport extends CommitTransport = CommitTransport> {
    #private;
    constructor(parameters: SessionConsumer.Parameters<Transport>);
    /** Active session used to sign commit vouchers. */
    get session(): ActiveSession;
    /** Transport used to send commit payloads. */
    get transport(): Transport;
    /**
     * Accepts a metered envelope and returns a delivery handle.
     */
    accept<Payload>(envelope: MeteredEnvelope<Payload>): MeteredDelivery<Payload, Transport>;
    /**
     * Commits a directive directly, signing and sending the voucher under the hood.
     */
    commitDirective(directive: MeteringDirective): Promise<CommitReceipt>;
    private validateDirective;
}
export declare namespace SessionConsumer {
    interface Parameters<Transport extends CommitTransport = CommitTransport> {
        /** Session that signs commit vouchers. */
        readonly session: ActiveSession;
        /** Transport that delivers commit payloads to the server. */
        readonly transport: Transport;
    }
}
/**
 * Delivered payload plus its metering directive.
 */
export declare class MeteredDelivery<Payload, Transport extends CommitTransport = CommitTransport> {
    #private;
    readonly metering: MeteringDirective;
    readonly payload: Payload;
    constructor(parameters: MeteredDelivery.Parameters<Payload, Transport>);
    /**
     * Acknowledges successful processing and commits the voucher.
     */
    ack(): Promise<CommitReceipt>;
    /**
     * Alias for `ack()`, matching log/queue commit terminology.
     */
    commit(): Promise<CommitReceipt>;
    /**
     * Takes ownership of the payload and directive without committing.
     */
    intoParts(): MeteredEnvelope<Payload>;
}
export declare namespace MeteredDelivery {
    interface Parameters<Payload, Transport extends CommitTransport = CommitTransport> {
        /** Consumer that commits the delivery on `ack()`. */
        readonly consumer: SessionConsumer<Transport>;
        /** Directive to commit once the payload is processed. */
        readonly metering: MeteringDirective;
        /** The delivered application payload. */
        readonly payload: Payload;
    }
}
/**
 * Fetch-backed transport for HTTP commit endpoints.
 */
export declare class HttpCommitTransport implements CommitTransport {
    #private;
    constructor(parameters?: HttpCommitTransport.Parameters);
    commit({ directive, payload }: CommitTransport.CommitParameters): Promise<CommitReceipt>;
}
export declare namespace HttpCommitTransport {
    interface Parameters {
        /** `Authorization` header value sent with each commit. */
        readonly authorization?: string | undefined;
        /** Fallback commit endpoint when a directive carries no `commitUrl`. */
        readonly commitUrl?: string | undefined;
        /** Underlying fetch. Defaults to `globalThis.fetch`. */
        readonly fetch?: typeof globalThis.fetch | undefined;
        /** Extra headers merged into each commit request. */
        readonly headers?: HeadersInit | undefined;
    }
}
//# sourceMappingURL=SessionConsumer.d.ts.map