declare class Context {
    offset: number;
}

type CodecType<T extends AbstractCodec<any>> = T extends AbstractCodec<infer S> ? S : never;
declare abstract class AbstractCodec<Value = unknown> {
    /**
     * Returns true if the provided value is able to be encoded and decoded by this codec.
     *
     * @param	{Value} value - Value of this codec's type.
     * @return	{boolean}
     *
     */
    abstract isValid(value: unknown): value is Value;
    /**
     * Returns the expected byteLength of the buffer if this value was encoded.
     *
     * @param	{Value} value - Value of this codec's type.
     * @return	{number} byteLength of buffer
     *
     */
    abstract byteLength(value: Value): number;
    /**
     * Used internally to recursively encode.
     *
     * @param	{Value} value - Value of this codec's type.
     * @param	{Uint8Array} buffer - Buffer being written into.
     * @param	{Context} c - Context for the current encode chain.
     * @return	{void}
     *
     */
    abstract _encode(value: Value, buffer: Uint8Array, c: Context): void;
    /**
     * Encodes a value of this codecs type into a buffer.
     *
     * @param	{Value} value - Value of this codec's type.
     * @param	{Uint8Array} [target] - A target buffer to write into.
     * @param	{number} [offset=0] - Offset at which to write into the target.
     * @return	{Uint8Array} Buffer encoding of value.
     *
     */
    encode(value: Value, target?: Uint8Array, offset?: number): Uint8Array;
    Encoder(): TransformStream<Value, Uint8Array>;
    /**
     * Used internally to recursively decode
     *
     * @param	{Uint8Array} buffer - The buffer to be decoded.
     * @param	{Context} c - Context for the current decode chain
     * @return	{Value} Value decoded from the buffer
     *
     */
    abstract _decode(buffer: Uint8Array, c: Context): Value;
    /**
     * Decodes a buffer to a value of this codecs type.
     *
     * @param	{Uint8Array} buffer - The buffer to be decoded.
     * @param	{number} [offset=0] - Offset at which to read at.
     * @return	{Value} Value decoded from the buffer
     *
     */
    decode(source: Uint8Array, offset?: number): Value;
    Decoder(): TransformStream<Uint8Array, Value>;
}

interface AnyCodecOptions<Value = any> {
    encode?: (value: Value) => Uint8Array;
    decode?: (buffer: Uint8Array) => Value;
    lengthCodec?: AbstractCodec<number>;
}
declare class AnyCodec<Value = any> extends AbstractCodec<Value> {
    private readonly _encodeValue;
    private readonly _decodeValue;
    readonly lengthCodec: AbstractCodec<number>;
    private readonly _bytesCodec;
    constructor(options?: AnyCodecOptions<Value>);
    isValid(_value: unknown): _value is any;
    byteLength(value: Value): number;
    _encode(value: Value, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Value;
}

declare class ArrayFixedCodec<Item> extends AbstractCodec<Array<Item>> {
    readonly length: number;
    readonly itemCodec: AbstractCodec<Item>;
    constructor(length: number, itemCodec: AbstractCodec<Item>);
    isValid(value: unknown): value is Array<Item>;
    byteLength(value: Array<Item>): number;
    _encode(value: Array<Item>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Array<Item>;
}

declare class ArrayVariableCodec<Item> extends AbstractCodec<Array<Item>> {
    readonly itemCodec: AbstractCodec<Item>;
    readonly lengthCodec: AbstractCodec<number>;
    constructor(itemCodec: AbstractCodec<Item>, lengthCodec?: AbstractCodec<number>);
    isValid(value: unknown): value is Array<Item>;
    byteLength(value: Array<Item>): number;
    _encode(value: Array<Item>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Array<Item>;
}

type ArrayCodec<Item> = ArrayFixedCodec<Item> | ArrayVariableCodec<Item>;
/**
 * Creates a codec for a variable length array.
 *
 * Serializes to ```[LENGTH?][...ITEMS]```
 *
 * Length is present only for variable length arrays.
 *
 * @param	{AbstractCodec} itemCodec - The codec for each item in the array.
 * @param	{AbstractCodec<number>} [lengthCodec="VarInt50()"] - Codec to specify how the length is encoded.
 * @return	{ArrayCodec} ArrayCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Array/index.ts|Source}
 */
declare function createArrayCodec<Item>(itemCodec: AbstractCodec<Item>, lengthCodec?: AbstractCodec<number>): ArrayVariableCodec<Item>;
/**
 * Creates a codec for a fixed length array.
 *
 * Serializes to ```[LENGTH?][...ITEMS]```
 *
 * Length is present only for variable length arrays.
 *
 * @param	{AbstractCodec} itemCodec - The codec for each item in the array.
 * @param	{number} [length] - Sets a fixed length.
 * @return	{ArrayCodec} ArrayCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Array/index.ts|Source}
 */
declare function createArrayCodec<Item>(itemCodec: AbstractCodec<Item>, length?: number): ArrayFixedCodec<Item>;

declare class BitFieldCodec<Key extends string> extends AbstractCodec<Record<Key, boolean>> {
    readonly keys: Array<Key>;
    constructor(keys: Array<Key>);
    isValid(value: unknown): value is Record<Key, boolean>;
    byteLength(_value: Record<Key, boolean>): number;
    _encode(value: Record<Key, boolean>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Record<Key, boolean>;
}

declare class BooleanCodec extends AbstractCodec<boolean> {
    isValid(value: unknown): value is boolean;
    byteLength(_value: boolean): number;
    _encode(value: boolean, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): boolean;
}

declare class BytesFixedCodec extends AbstractCodec<Uint8Array> {
    private _byteLength;
    constructor(byteLength: number);
    isValid(value: unknown): value is Uint8Array;
    byteLength(_: Uint8Array): number;
    _encode(value: Uint8Array, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Uint8Array;
}

declare class BytesVariableCodec extends AbstractCodec<Uint8Array> {
    readonly lengthCodec: AbstractCodec<number>;
    constructor(lengthCodec?: AbstractCodec<number>);
    isValid(value: unknown): value is Uint8Array;
    byteLength(value: Uint8Array): number;
    _encode(value: Uint8Array, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Uint8Array;
}

type BytesCodec = BytesFixedCodec | BytesVariableCodec;
/**
 * Creates a codec for a variable length buffer.
 *
 * Serializes to ```[LENGTH?][BUFFER]```
 *
 * Length is present only for variable length buffers.
 *
 * @param	{AbstractCodec<number>} [lengthCodec="VarInt50()"] - Codec to specify how the length is encoded.
 * @return	{BytesCodec} BytesCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Bytes/index.ts|Source}
 */
declare function createBytesCodec(lengthCodec?: AbstractCodec<number>): BytesVariableCodec;
/**
 * Creates a codec for a fixed length buffer.
 *
 * Serializes to ```[LENGTH?][BUFFER]```
 *
 * Length is present only for variable length buffers.
 *
 * @param	{number} length - Sets a fixed length.
 * @return	{BytesCodec} BytesCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Bytes/index.ts|Source}
 */
declare function createBytesCodec(length: number): BytesFixedCodec;

declare class ConstantCodec<const Value> extends AbstractCodec<Value> {
    readonly value: Value;
    constructor(value: Value);
    isValid(value: unknown): value is Value;
    byteLength(_value: Value): number;
    _encode(_value: Value, _buffer: Uint8Array, _c: Context): void;
    _decode(_buffer: Uint8Array, _c: Context): Value;
}

declare const endiannessValues: readonly ["BE", "LE"];
type Endianness = (typeof endiannessValues)[number];
declare const uIntBitValues: readonly [8, 16, 24, 32, 40, 48];
type UIntBits = (typeof uIntBitValues)[number];
type UIntCodec = UInt8Codec | UInt16BECodec | UInt16LECodec | UInt24BECodec | UInt24LECodec | UInt32BECodec | UInt32LECodec | UInt40BECodec | UInt40LECodec | UInt48BECodec | UInt48LECodec;
declare class UInt8Codec extends AbstractCodec<number> {
    _bufferMap: Record<number, Buffer>;
    constructor();
    isValid(value: unknown): value is number;
    byteLength(_: number): 1;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt16BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 2;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt16LECodec extends UInt16BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt24BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 3;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt24LECodec extends UInt24BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt32BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 4;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt32LECodec extends UInt32BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt40BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 5;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt40LECodec extends UInt40BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt48BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 6;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class UInt48LECodec extends UInt48BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}

declare const floatBitValues: readonly [32, 64];
type FloatBits = (typeof floatBitValues)[number];
type FloatCodec = Float32BECodec | Float32LECodec | Float64BECodec | Float64LECodec;
declare class Float32BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 4;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Float32LECodec extends Float32BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Float64BECodec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(_: number): 8;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Float64LECodec extends Float64BECodec {
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}

type IntCodec = Int8Codec | Int16BECodec | Int16LECodec | Int24BECodec | Int24LECodec | Int32BECodec | Int32LECodec | Int40BECodec | Int40LECodec | Int48BECodec | Int48LECodec;
declare class Int8Codec extends UInt8Codec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int16BECodec extends UInt16BECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int16LECodec extends UInt16LECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int24BECodec extends UInt24BECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int24LECodec extends UInt24LECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int32BECodec extends UInt32BECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int32LECodec extends UInt32LECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int40BECodec extends UInt40BECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int40LECodec extends UInt40LECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int48BECodec extends UInt48BECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}
declare class Int48LECodec extends UInt48LECodec {
    isValid(value: any): value is number;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}

declare class UnionCodec<const Codecs extends Array<AbstractCodec<any>>> extends AbstractCodec<CodecType<Codecs[number]>> {
    readonly indexCodec: AbstractCodec<number>;
    codecs: Codecs;
    constructor(codecs: Codecs, indexCodec?: AbstractCodec<number>);
    isValid(value: unknown): value is CodecType<Codecs[number]>;
    byteLength(value: CodecType<Codecs[number]>): number;
    _encode(value: CodecType<Codecs[number]>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): CodecType<Codecs[number]>;
}

/**
 * Creates a codec for a fixed object.
 *
 * Serializes to ```[...[PROPERTY_VALUES]]```
 *
 * Encodes each property value with the codec associated with that key.
 *
 * @param	{Record<string, AbstractCodec>} properties - Properties of the object.
 * @return	{ObjectCodec} ObjectCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Object/index.ts|Source}
 */
declare function createObjectCodec<Properties extends Record<string, AbstractCodec>>(properties: Properties): ObjectCodec<Properties>;
type RequiredKeys<T extends Record<string | number, AbstractCodec<any>>> = {
    [K in keyof T]: T[K] extends UnionCodec<[AbstractCodec, ConstantCodec<undefined>]> ? undefined : K;
}[keyof T];
type OptionalKeys<T extends Record<string | number, AbstractCodec<any>>> = {
    [K in keyof T]: T[K] extends UnionCodec<[AbstractCodec, ConstantCodec<undefined>]> ? K : undefined;
}[keyof T];
type _OutputObject<T extends Record<string | number, AbstractCodec<any>>> = {
    [K in Exclude<RequiredKeys<T>, undefined>]: CodecType<T[K]>;
} & {
    [K in Exclude<OptionalKeys<T>, undefined>]?: CodecType<T[K]>;
};
type OutputObject<T extends Record<string | number, AbstractCodec<any>>> = {
    [K in keyof _OutputObject<T>]: _OutputObject<T>[K];
};
declare class ObjectCodec<Properties extends Record<string, AbstractCodec>> extends AbstractCodec<OutputObject<Properties>> {
    readonly properties: Properties;
    entries: Array<[keyof Properties, AbstractCodec]>;
    constructor(properties: Properties);
    isValid(value: unknown): value is OutputObject<Properties>;
    byteLength(value: OutputObject<Properties>): number;
    _encode(value: OutputObject<Properties>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): OutputObject<Properties>;
}

declare class RecordFixedCodec<Key extends string, Value extends any> extends AbstractCodec<Record<Key, Value>> {
    readonly length: number;
    readonly keyCodec: AbstractCodec<Key>;
    readonly valueCodec: AbstractCodec<Value>;
    constructor(length: number, keyCodec: AbstractCodec<Key>, valueCodec: AbstractCodec<Value>);
    isValid(value: unknown): value is Record<Key, Value>;
    byteLength(value: Record<Key, Value>): number;
    _encode(value: Record<Key, Value>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Record<Key, Value>;
}

declare class RecordVariableCodec<Key extends string, Value extends any> extends AbstractCodec<Record<Key, Value>> {
    readonly keyCodec: AbstractCodec<Key>;
    readonly valueCodec: AbstractCodec<Value>;
    readonly lengthCodec: AbstractCodec<number>;
    constructor(keyCodec: AbstractCodec<Key>, valueCodec: AbstractCodec<Value>, lengthCodec?: AbstractCodec<number>);
    isValid(value: unknown): value is Record<Key, Value>;
    byteLength(value: Record<Key, Value>): number;
    _encode(value: Record<Key, Value>, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Record<Key, Value>;
}

type RecordCodec<Key extends string, Value> = RecordFixedCodec<Key, Value> | RecordVariableCodec<Key, Value>;
/**
 * Creates a codec for a variable size record or map of keys and values.
 *
 * Serializes to ```[LENGTH][...[[KEY][VALUE]]]```
 *
 * Length is present only for variable length records.
 *
 * @param	{AbstractCodec<string>} keyCodec - Codec for keys.
 * @param	{AbstractCodec} valueCodec - Codec for values.
 * @param	{AbstractCodec<number>} [options.lengthCodec="VarUInt()"] - Codec to specify how the length is encoded.
 * @return	{RecordCodec} RecordCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Record/index.ts|Source}
 */
declare function createRecordCodec<Key extends string, Value>(keyCodec: AbstractCodec<Key>, valueCodec: AbstractCodec<Value>, lengthCodec?: AbstractCodec<number>): RecordVariableCodec<Key, Value>;
/**
 * Creates a codec for a fixed size record or map of keys and values.
 *
 * Serializes to ```[...[[KEY][VALUE]]]```
 *
 * Length is present only for variable length records.
 *
 * @param	{AbstractCodec<string>} keyCodec - Codec for keys.
 * @param	{AbstractCodec} valueCodec - Codec for values.
 * @param	{number} length - Sets a fixed length.
 * @return	{RecordCodec} RecordCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/Record/index.ts|Source}
 */
declare function createRecordCodec<Key extends string, Value>(keyCodec: AbstractCodec<Key>, valueCodec: AbstractCodec<Value>, length: number): RecordFixedCodec<Key, Value>;

declare class StringFixedCodec extends AbstractCodec<string> {
    readonly encoding: StringEncoding;
    private _byteLength;
    private _bufferCodec;
    constructor(byteLength: number, encoding?: StringEncoding);
    isValid(value: unknown): value is string;
    byteLength(_value: string): number;
    _encode(value: string, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): string;
}

declare class StringVariableCodec extends AbstractCodec<string> {
    readonly encoding: StringEncoding;
    readonly lengthCodec: AbstractCodec<number>;
    private _bufferCodec;
    constructor(encoding?: StringEncoding, lengthCodec?: AbstractCodec<number>);
    isValid(value: unknown): value is string;
    byteLength(value: string): number;
    _encode(value: string, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): string;
}

type StringEncoding = "hex" | "base32" | "base58" | "base64" | "base64url" | "utf8";
type StringCodec = StringFixedCodec | StringVariableCodec;
/**
 * Creates a codec for a variable length string.
 *
 * Serializes to ```[LENGTH][STRING]```
 *
 * Length is present only for variable length strings.
 *
 * @param	{StringEncoding} [encoding="utf8"] - The strings encoding.
 * @param	{AbstractCodec<number>} [lengthCodec="VarUInt()"] - Codec to specify how the length is encoded.
 * @return	{StringCodec} StringCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/String/index.ts|Source}
 */
declare function createStringCodec(encoding?: StringEncoding, lengthCodec?: AbstractCodec<number>): StringVariableCodec;
/**
 * Creates a codec for a fixed length string.
 *
 * Serializes to ```[STRING]```
 *
 * Length is present only for variable length strings.
 *
 * @param	{StringEncoding} [encoding="utf8"] - The strings encoding.
 * @param	{number} [byteLength] - Sets a fixed byte length.
 * @return	{StringCodec} StringCodec
 *
 * {@link https://github.com/visionsofparadise/bufferfy/blob/main/src/Codecs/String/index.ts|Source}
 */
declare function createStringCodec(encoding?: StringEncoding, byteLength?: number): StringFixedCodec;

interface TransformCodecOptions<Source, Target> {
    isValid?: (source: unknown) => boolean;
    encode: (source: Source) => Target;
    decode: (target: Target, buffer: Uint8Array) => Source;
}
declare class TransformCodec<Source, Target> extends AbstractCodec<Source> {
    readonly targetCodec: AbstractCodec<Target>;
    private readonly _isSourceValid;
    private readonly _encodeSource;
    private readonly _decodeTarget;
    constructor(targetCodec: AbstractCodec<Target>, options: TransformCodecOptions<Source, Target>);
    isValid(value: unknown): value is Source;
    byteLength(value: Source): number;
    _encode(value: Source, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Source;
}

declare class TupleCodec<Tuple extends [...any[]]> extends AbstractCodec<Tuple> {
    readonly codecs: [
        ...{
            [Index in keyof Tuple]: AbstractCodec<Tuple[Index]>;
        }
    ];
    constructor(codecs: [
        ...{
            [Index in keyof Tuple]: AbstractCodec<Tuple[Index]>;
        }
    ]);
    isValid(value: unknown): value is Tuple;
    byteLength(value: Tuple): number;
    _encode(value: Tuple, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): Tuple;
}

declare class VarInt15Codec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(value: number): 1 | 2;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}

declare class VarInt30Codec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(value: number): 1 | 2 | 3 | 4;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}

declare class VarInt60Codec extends AbstractCodec<number> {
    isValid(value: unknown): value is number;
    byteLength(value: number): 1 | 2 | 3 | 4 | 5 | 6 | 7;
    _encode(value: number, buffer: Uint8Array, c: Context): void;
    _decode(buffer: Uint8Array, c: Context): number;
}

declare const varIntBitValues: readonly [15, 30, 60];
type VarIntBits = (typeof varIntBitValues)[number];
type VarIntCodec = VarInt15Codec | VarInt30Codec | VarInt60Codec;

type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection & Union : never;

declare namespace Codec {
    type Type<Codec extends AbstractCodec<any>> = CodecType<Codec>;
}
declare const Codec: {
    Any: <Value = any>(options?: AnyCodecOptions<Value>) => AnyCodec<Value>;
    Array: typeof createArrayCodec;
    BitField: <Key extends string>(keys: Array<Key>) => BitFieldCodec<Key>;
    Boolean: BooleanCodec;
    Bytes: typeof createBytesCodec;
    Constant: <const Value>(value: Value) => ConstantCodec<Value>;
    Enum: <const Value>(enumValues: Array<Value>, indexCodec: AbstractCodec<number>) => UnionCodec<ConstantCodec<Value>[]>;
    False: ConstantCodec<false>;
    Float: (bits?: FloatBits, endianness?: Endianness) => Float32BECodec | Float64BECodec;
    Int: (bits?: UIntBits, endianness?: Endianness) => Int8Codec | Int16BECodec | Int16LECodec | Int24BECodec | Int24LECodec | Int32BECodec | Int32LECodec | Int40BECodec | Int40LECodec | Int48BECodec | Int48LECodec;
    Merge: <const ObjectCodecs extends Array<ObjectCodec<any>>>(objectCodecs: ObjectCodecs) => ObjectCodec<UnionToIntersection<ObjectCodecs[number]["properties"]>>;
    Null: ConstantCodec<null>;
    Nullable: <Value>(codec: AbstractCodec<Value>) => UnionCodec<[AbstractCodec<Value>, ConstantCodec<null>]>;
    Object: typeof createObjectCodec;
    Omit: <Properties extends Record<string, AbstractCodec>, Key extends keyof Properties>(objectCodec: ObjectCodec<Properties>, keys: Array<Key>) => ObjectCodec<Omit<Properties, Key>>;
    Optional: <Value>(codec: AbstractCodec<Value>) => UnionCodec<[AbstractCodec<Value>, ConstantCodec<undefined>]>;
    Pick: <Properties extends Record<string, AbstractCodec>, Key extends keyof Properties>(objectCodec: ObjectCodec<Properties>, keys: Array<Key>) => ObjectCodec<Pick<Properties, Key>>;
    Record: typeof createRecordCodec;
    String: typeof createStringCodec;
    Transform: <Source, Target>(targetCodec: AbstractCodec<Target>, options: TransformCodecOptions<Source, Target>) => TransformCodec<Source, Target>;
    True: ConstantCodec<true>;
    Tuple: <Tuple extends [...any[]]>(codecs: [...{ [Index in keyof Tuple]: AbstractCodec<Tuple[Index]>; }]) => TupleCodec<Tuple>;
    UInt: (bits?: UIntBits, endianness?: Endianness) => UInt8Codec | UInt16BECodec | UInt24BECodec | UInt32BECodec | UInt40BECodec | UInt48BECodec;
    Undefined: ConstantCodec<undefined>;
    Union: <const Codecs extends Array<AbstractCodec<any>>>(codecs: Codecs, indexCodec?: AbstractCodec<number>) => UnionCodec<Codecs>;
    VarInt: (bits?: VarIntBits) => VarInt60Codec | VarInt15Codec | VarInt30Codec;
};

export { AbstractCodec, AnyCodec, ArrayCodec, ArrayFixedCodec, ArrayVariableCodec, BitFieldCodec, BooleanCodec, BytesCodec, BytesFixedCodec, BytesVariableCodec, Codec, ConstantCodec, Float32BECodec, Float32LECodec, Float64BECodec, Float64LECodec, FloatCodec, Int16BECodec, Int16LECodec, Int24BECodec, Int24LECodec, Int32BECodec, Int32LECodec, Int40BECodec, Int40LECodec, Int48BECodec, Int48LECodec, Int8Codec, IntCodec, ObjectCodec, RecordCodec, RecordFixedCodec, RecordVariableCodec, StringCodec, StringFixedCodec, StringVariableCodec, TransformCodec, TupleCodec, UInt16BECodec, UInt16LECodec, UInt24BECodec, UInt24LECodec, UInt32BECodec, UInt32LECodec, UInt40BECodec, UInt40LECodec, UInt48BECodec, UInt48LECodec, UInt8Codec, UIntCodec, UnionCodec, VarInt15Codec, VarInt30Codec, VarInt60Codec, VarIntCodec };