import { AssertState } from "./assert.js";
import { DecodeBuffer, EncodeBuffer } from "./buffer.js";
import { Metadata } from "./metadata.js";
export type Input<T extends AnyCodec> = T extends Codec<infer I, unknown> ? I : never;
export type Output<T extends AnyCodec> = T extends Codec<never, infer O> ? O : never;
export declare function createCodec<I, O = I>(_codec: ThisType<Codec<I, O>> & Pick<Codec<I, O>, "_encode" | "_decode" | "_assert" | "_staticSize" | "_metadata">): Codec<I, O>;
type NoInfer<T> = T extends infer U ? U : never;
export declare function withMetadata<I, O>(metadata: Metadata<NoInfer<I>, NoInfer<O>>, codec: Codec<I, O>): Codec<I, O>;
declare const nodeCustomInspect: unique symbol;
declare const denoCustomInspect: unique symbol;
declare abstract class _Codec {
    private [nodeCustomInspect];
    private [denoCustomInspect];
    private _inspect;
}
export type AnyCodec = Codec<never, unknown>;
export type Encodec<I> = Codec<I, unknown>;
export type Decodec<O> = Codec<never, O>;
export declare abstract class Codec<in I, out O = I> extends _Codec implements AnyCodec {
    /** A static estimation of the size, which may be an under- or over-estimate */
    abstract _staticSize: number;
    /** Encodes the value into the supplied buffer, which should have at least `_staticSize` free byte. */
    abstract _encode: (buffer: EncodeBuffer, value: I) => void;
    /** Decodes the value from the supplied buffer */
    abstract _decode: (buffer: DecodeBuffer) => O;
    /** Asserts that the value is valid for this codec */
    abstract _assert: (state: AssertState) => void;
    /** An array with metadata representing the construction of this codec */
    abstract _metadata: Metadata<I, O>;
    /** Encodes the value into a new Uint8Array (throws if async) */
    encode(value: I): Uint8Array;
    /** Asynchronously encodes the value into a new Uint8Array */
    encodeAsync(value: I): Promise<Uint8Array>;
    /** Decodes a value from the supplied Uint8Array */
    decode(array: Uint8Array): O;
    /** Requires the codec to have an explicit type annotation; if it doesn't, use `$.assert` instead. */
    assert(value: unknown): asserts value is I;
}
/** Asserts that the value is valid for the specified codec */
export declare function assert<I>(codec: Codec<I, unknown>, value: unknown): asserts value is I;
export declare function is<T>(codec: Codec<T>, value: unknown): value is T;
export {};