import type { BoundedAsyncStream } from '../backend-contract/streams.js';
import type { CleanupRecord } from './cleanup.js';
import type { PortableBoundedAsyncStream } from '../manager/consumer-handles.js';
export type PublicStreamOverflowPolicy = 'latest' | 'drop-oldest' | 'drop-newest' | 'error';
export type PublicStreamTerminalReason = 'closed' | 'overflow' | 'source-failed' | 'owner-released' | 'connection-lost' | 'service-changed' | 'operation-aborted' | 'operation-timed-out';
export interface PublicStreamLimits {
    readonly itemCapacity: number;
    readonly byteCapacity: number;
    readonly reservedControlCapacity: number;
}
export interface PublicStreamOverflowNotice {
    readonly kind: 'overflow';
    readonly policy: PublicStreamOverflowPolicy;
    readonly droppedItems: number;
    readonly droppedBytes: number;
    readonly replacedItems: number;
}
export interface PublicStreamTerminalNotice {
    readonly kind: 'terminal';
    readonly reason: PublicStreamTerminalReason;
    readonly droppedItems: number;
    readonly droppedBytes: number;
    readonly replacedItems: number;
    readonly error?: import('./cleanup.js').NormalizedBleError | null;
}
export interface PublicStreamValue<Value> {
    readonly kind: 'value';
    readonly value: Value;
}
export type PublicStreamItem<Value> = PublicStreamValue<Value> | PublicStreamOverflowNotice | PublicStreamTerminalNotice;
export interface PublicBoundedAsyncStreamIterator<Value> extends AsyncIterator<PublicStreamItem<Value>, undefined, undefined> {
    readonly return: () => Promise<IteratorResult<PublicStreamItem<Value>, undefined>>;
    [Symbol.asyncIterator](): PublicBoundedAsyncStreamIterator<Value>;
}
export interface PublicBoundedAsyncStream<Value> extends AsyncIterable<PublicStreamItem<Value>, undefined, undefined> {
    readonly limits: PublicStreamLimits;
    readonly overflowPolicy: PublicStreamOverflowPolicy;
    [Symbol.asyncIterator](): PublicBoundedAsyncStreamIterator<Value>;
    close(): Promise<CleanupRecord>;
}
type PublicStreamSource<Value> = BoundedAsyncStream<Value> | PortableBoundedAsyncStream<Value>;
/** Projects backend stream controls and values into the host-neutral public contract. */
export declare function mapPublicBoundedAsyncStream<InternalValue, PublicValue>(source: PublicStreamSource<InternalValue>, mapValue: (value: InternalValue) => PublicValue): PublicBoundedAsyncStream<PublicValue>;
export {};
//# sourceMappingURL=streams.d.ts.map