import { Promiseable } from '../../libs/promises/promises.js';

type Encoder<I, O> = SyncEncoder<I, O> | AsyncEncoder<I, O>;
interface SyncEncoder<I, O> {
    stringify(input: I): O;
}
interface AsyncEncoder<I, O> {
    stringify(input: I): Promiseable<O>;
}
type Bicoder<I, O> = SyncBicoder<I, O> | AsyncBicoder<I, O>;
interface SyncBicoder<I, O> {
    stringify(input: I): O;
    parse(output: O): I;
}
interface AsyncBicoder<I, O> {
    stringify(input: I): Promiseable<O>;
    parse(output: O): Promiseable<I>;
}
declare namespace SyncIdentity {
    function stringify<T>(value: T): T;
    function parse<T>(value: T): T;
}
declare class AsyncPipeBicoder<I, X, O> implements AsyncBicoder<I, O> {
    readonly outer: AsyncBicoder<I, X>;
    readonly inner: AsyncBicoder<X, O>;
    constructor(outer: AsyncBicoder<I, X>, inner: AsyncBicoder<X, O>);
    stringify(input: I): Promise<O>;
    parse(output: O): Promise<I>;
}
declare class AsyncPipeEncoder<I, X, O> implements AsyncEncoder<I, O> {
    readonly outer: AsyncEncoder<I, X>;
    readonly inner: AsyncEncoder<X, O>;
    constructor(outer: AsyncEncoder<I, X>, inner: AsyncEncoder<X, O>);
    stringify(input: I): Promise<O>;
}
declare class SyncPipeBicoder<I, X, O> implements SyncBicoder<I, O> {
    readonly outer: SyncBicoder<I, X>;
    readonly inner: SyncBicoder<X, O>;
    constructor(outer: SyncBicoder<I, X>, inner: SyncBicoder<X, O>);
    stringify(input: I): O;
    parse(output: O): I;
}
declare class SyncPipeEncoder<I, X, O> implements SyncEncoder<I, O> {
    readonly outer: SyncEncoder<I, X>;
    readonly inner: SyncEncoder<X, O>;
    constructor(outer: SyncEncoder<I, X>, inner: SyncEncoder<X, O>);
    stringify(input: I): O;
}

export { type AsyncBicoder, type AsyncEncoder, AsyncPipeBicoder, AsyncPipeEncoder, type Bicoder, type Encoder, type SyncBicoder, type SyncEncoder, SyncIdentity, SyncPipeBicoder, SyncPipeEncoder };