declare enum Tag {
    False = 128,
    True = 129,
    End = 132,
    Annotation = 133,
    Embedded = 134,
    Ieee754 = 135,
    SignedInteger = 176,
    String = 177,
    ByteString = 178,
    Symbol = 179,
    Record = 180,
    Sequence = 181,
    Set = 182,
    Dictionary = 183
}

type constants_Tag = Tag;
declare const constants_Tag: typeof Tag;
declare namespace constants {
  export { constants_Tag as Tag };
}

type Writable<T extends Embeddable> = Value<T> | PreserveWritable<T> | Iterable<Value<T>> | ArrayBufferView;
interface PreserveWritable<T extends Embeddable> {
    __preserve_text_on__(writer: Writer<T>): void;
}
declare function isPreserveWritable<T extends Embeddable>(v: any): v is PreserveWritable<T>;
type EmbeddedWriter<T> = {
    write(s: WriterState, v: T): void;
} | {
    toValue(v: T): Value<GenericEmbedded>;
};
declare const genericEmbeddedTypeEncode: EmbeddedTypeEncode<GenericEmbedded> & EmbeddedWriter<GenericEmbedded>;
declare const neverEmbeddedTypeEncode: EmbeddedTypeEncode<never> & EmbeddedWriter<never>;
interface WriterStateOptions {
    includeAnnotations?: boolean;
    indent?: number;
    maxBinaryAsciiLength?: number;
    maxBinaryAsciiProportion?: number;
}
interface WriterOptions<T> extends WriterStateOptions {
    embeddedWrite?: EmbeddedWriter<T>;
}
declare class WriterState {
    pieces: string[];
    options: WriterStateOptions;
    indentDelta: string;
    indentCount: number;
    constructor(options: WriterStateOptions);
    get isIndenting(): boolean;
    get includeAnnotations(): boolean;
    writeIndent(): void;
    writeIndentSpace(): void;
    escapeStringlikeChar(c: string, k?: (c: string) => string): string;
    escapeStringlike(s: string, quoteChar: string): string;
    writeSeq<V>(opener: string, closer: string, vs: Iterable<V>, appender: (v: V) => void): void;
    writeBytes(bs: Uint8Array): void;
    writeBase64(bs: Uint8Array): void;
    writeBinaryStringlike(bs: Uint8Array): void;
    couldBeFlat<T extends Embeddable>(vs: Writable<T>[]): boolean;
}
declare class Writer<T extends Embeddable> {
    state: WriterState;
    embeddedWrite: EmbeddedWriter<T>;
    constructor(state: WriterState, embeddedWrite: EmbeddedWriter<T>);
    constructor(options?: WriterOptions<T>);
    static stringify<T extends Embeddable>(v: Writable<T>, options?: WriterOptions<T>): string;
    contents(): string;
    get includeAnnotations(): boolean;
    push(v: Writable<T>): this;
}

type FloatType = 'Double';
declare const FloatType: unique symbol;
declare abstract class Float {
    readonly value: number;
    constructor(value: number | bigint | Float);
    __preserve_text_on__(w: Writer<any>): void;
    abstract toBytes(): Bytes;
    equals(other: any): boolean;
    hashCode(): number;
    abstract get [FloatType](): FloatType;
    static isFloat: (x: any) => x is Float;
    static isDouble: (x: any) => x is DoubleFloat;
}
declare function floatValue(f: any): number;
declare function floatlikeString(f: number): string;
declare class DoubleFloat extends Float implements Preservable<any>, PreserveWritable<any> {
    __as_preserve__<T extends Embeddable = GenericEmbedded>(): Value<T>;
    static fromBytes(bs: Bytes | DataView): DoubleFloat;
    static __from_preserve__<T extends Embeddable>(v: Value<T>): undefined | DoubleFloat;
    __preserve_on__(encoder: Encoder<any>): void;
    toBytes(): Bytes;
    toString(): string;
    get [FloatType](): 'Double';
}
declare function Double(value: number | bigint | Float): DoubleFloat;
declare namespace Double {
    var __from_preserve__: typeof DoubleFloat.__from_preserve__;
}

type Canonicalizer<V> = (v: V) => string;
type Equivalence<V> = (v1: V, v2: V) => boolean;
type IdentityMap<K, V> = Map<K, V>;
declare const IdentityMap: MapConstructor;
type IdentitySet<V> = Set<V>;
declare const IdentitySet: SetConstructor;
declare const IsMap: unique symbol;
declare const IsSet: unique symbol;
declare global {
    interface Map<K, V> {
        get [IsMap](): boolean;
    }
    interface MapConstructor {
        isMap<K, V>(x: any): x is Map<K, V>;
    }
    interface Set<T> {
        get [IsSet](): boolean;
    }
    interface SetConstructor {
        isSet<T>(x: any): x is Set<T>;
    }
}
declare function _iterMap<S, T>(i: Iterator<S>, f: (s: S) => T): IterableIterator<T>;
declare class FlexMap<K, V> implements Map<K, V> {
    readonly items: Map<string, [K, V]>;
    readonly canonicalizer: Canonicalizer<K>;
    constructor(c: Canonicalizer<K>, items?: Iterable<readonly [K, V]>);
    _key(k: K): string;
    get(k: K, defaultValue?: V): V | undefined;
    getOrSet(k: K, initializer: () => V): V;
    set(k: K, v: V): this;
    forEach(f: <T extends Map<K, V>>(v: V, k: K, map: T) => void, thisArg?: any): void;
    entries(): MapIterator<[K, V]>;
    keys(): MapIterator<K>;
    values(): MapIterator<V>;
    delete(k: K): boolean;
    getAndDelete(k: K, defaultValue?: V): V | undefined;
    clear(): void;
    has(k: K): boolean;
    get size(): number;
    [Symbol.iterator](): MapIterator<[K, V]>;
    get [Symbol.toStringTag](): string;
    equals(other: any, eqv?: Equivalence<V>): boolean;
    update(key: K, f: (oldValue?: V) => V | undefined, defaultValue?: V, eqv?: Equivalence<V>): number;
    canonicalKeys(): MapIterator<string>;
    get [IsMap](): boolean;
}
declare class FlexSet<V> implements Set<V> {
    readonly items: Map<string, V>;
    readonly canonicalizer: Canonicalizer<V>;
    constructor(c: Canonicalizer<V>, items?: Iterable<V>);
    _key(v: V): string;
    has(v: V): boolean;
    get(v: V): {
        item: V;
    } | null;
    add(v: V): this;
    forEach(f: <T extends Set<V>>(v: V, v2: V, set: T) => void, thisArg?: any): void;
    entries(): SetIterator<[V, V]>;
    keys(): SetIterator<V>;
    values(): SetIterator<V>;
    delete(v: V): boolean;
    clear(): void;
    get size(): number;
    [Symbol.iterator](): SetIterator<V>;
    get [Symbol.toStringTag](): string;
    equals(other: any): boolean;
    canonicalValues(): SetIterator<string>;
    union(other: Set<V>): FlexSet<V>;
    intersect(other: Set<V>): FlexSet<V>;
    subtract(other: Set<V>): FlexSet<V>;
    get [IsSet](): boolean;
}

interface JsDictionary<V> {
    [key: string]: V;
}
declare namespace JsDictionary {
    function isJsDictionary<V>(x: any): x is JsDictionary<V>;
    function from<V>(entries: Iterable<[symbol, V]>): JsDictionary<V>;
    function clear<V>(j: JsDictionary<V>): void;
    function remove<V>(j: JsDictionary<V>, key: symbol): boolean;
    function forEach<V>(j: JsDictionary<V>, callbackfn: (value: V, key: symbol) => void): void;
    function get<V>(j: JsDictionary<V>, key: symbol): V | undefined;
    function has<V>(j: JsDictionary<V>, key: symbol): boolean;
    function set<V>(j: JsDictionary<V>, key: symbol, value: V): JsDictionary<V>;
    function size<V>(j: JsDictionary<V>): number;
    function entries<V>(j: JsDictionary<V>): IterableIterator<[symbol, V]>;
    function keys<V>(j: JsDictionary<V>): IterableIterator<symbol>;
    function values<V>(j: JsDictionary<V>): IterableIterator<V>;
    function clone<V>(j: JsDictionary<V>): JsDictionary<V>;
    function equals<V>(j1: JsDictionary<V>, j2: JsDictionary<V>, eqv?: Equivalence<V>): boolean;
}

type Value<T extends Embeddable = GenericEmbedded> = Atom | Compound$1<T> | T | Annotated<T>;
type Atom = boolean | DoubleFloat | number | bigint | string | Bytes | symbol;
type Compound$1<T extends Embeddable = GenericEmbedded> = (Array<Value<T>> | [Value<T>]) & {
    label: Value<T>;
} | Array<Value<T>> | Set$2<T> | JsDictionary<Value<T>> | KeyedDictionary<T>;

declare const IsPreservesBytes: unique symbol;
type BytesLike = Bytes | Uint8Array;
declare function hexDigit(n: number): string;
declare function unhexDigit(asciiCode: number, errorClass?: {
    new (msg: string): Error;
}): number;
declare function underlying(b: Bytes | Uint8Array): Uint8Array;
declare function dataview(b: Bytes | DataView): DataView;
declare class Bytes implements Preservable<any>, PreserveWritable<any> {
    readonly _view: Uint8Array;
    constructor(maybeByteIterable?: any);
    dataview(): DataView;
    get length(): number;
    static from(x: any): Bytes;
    static of(...bytes: number[]): Bytes;
    static fromLatin1(s: string): Bytes;
    static fromBase64(s: string): Bytes;
    static fromHex(s: string): Bytes;
    static _raw_fromHexInto(s: string, target: Uint8Array): void;
    static fromIO(io: string | BytesLike): string | Bytes;
    static toIO(b: string | BytesLike): string | Uint8Array;
    static concat: (bss: BytesLike[]) => Bytes;
    get(index: number): number;
    equals(other: any): boolean;
    hashCode(): number;
    static compare(a: Bytes, b: Bytes): number;
    static decodeUtf8(bs: Bytes | Uint8Array): string;
    fromUtf8(): string;
    __as_preserve__<T extends Embeddable = GenericEmbedded>(): Value<T>;
    static __from_preserve__<T extends Embeddable>(v: Value<T>): undefined | Bytes;
    toLatin1(): string;
    toBase64(): string;
    toHex(digit?: typeof hexDigit): string;
    valueOf(): string;
    __preserve_on__(encoder: Encoder<any>): void;
    __preserve_text_on__(w: Writer<any>): void;
    toString(): string;
    get [IsPreservesBytes](): boolean;
    static isBytes(x: any): x is Bytes;
}
interface Bytes {
    entries(): IterableIterator<[number, number]>;
    every(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean;
    find(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number;
    findIndex(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number;
    forEach(callbackfn: (value: number, index: number, array: Uint8Array) => void, thisArg?: any): void;
    includes(searchElement: number, fromIndex?: number): boolean;
    indexOf(searchElement: number, fromIndex?: number): number;
    join(separator?: string): string;
    keys(): IterableIterator<number>;
    lastIndexOf(searchElement: number, fromIndex?: number): number;
    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
    some(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean;
    toLocaleString(): string;
    values(): IterableIterator<number>;
    filter(predicate: (value: number, index: number, array: Uint8Array) => any, thisArg?: any): Bytes;
    map(callbackfn: (value: number, index: number, array: Uint8Array) => number, thisArg?: any): Bytes;
    slice(start?: number, end?: number): Bytes;
    subarray(begin?: number, end?: number): Bytes;
    reverse(): Bytes;
    sort(compareFn?: (a: number, b: number) => number): Bytes;
    [Symbol.iterator](): IterableIterator<number>;
}

type Encodable<T extends Embeddable> = Value<T> | Preservable<T> | Iterable<Value<T>> | ArrayBufferView;
interface Preservable<T extends Embeddable> {
    __preserve_on__(encoder: Encoder<T>): void;
}
declare function isPreservable<T extends Embeddable>(v: any): v is Preservable<T>;
interface EncoderOptions {
    canonical?: boolean;
    includeAnnotations?: boolean;
}
interface EncoderEmbeddedOptions<T extends Embeddable> extends EncoderOptions {
    embeddedEncode?: EmbeddedTypeEncode<T>;
}
declare class IdentityEmbeddedTypeEncode implements EmbeddedTypeEncode<any> {
    _nextId: number;
    readonly _registry: WeakMap<object, number>;
    embeddedId(v: any): number;
    encode(s: EncoderState, v: any): void;
}
declare class EncoderState {
    chunks: Array<Uint8Array>;
    view: DataView;
    index: number;
    options: EncoderOptions;
    constructor(options: EncoderOptions);
    get canonical(): boolean;
    get includeAnnotations(): boolean;
    contents(): Bytes;
    contentsString(): string;
    rotatebuffer(size: number): void;
    makeroom(amount: number): void;
    emitbyte(b: number): void;
    emitbytes(bs: Uint8Array): void;
    claimbytes(count: number): Uint8Array<ArrayBufferLike>;
    varint(v: number): void;
    encodeint(v: number | bigint): void;
    encodebigint(v: bigint): void;
    encodebytes(tag: Tag, bs: Uint8Array): void;
}
declare class Encoder<T extends Embeddable> {
    state: EncoderState;
    embeddedEncode: EmbeddedTypeEncode<T>;
    constructor(options: EncoderEmbeddedOptions<T>);
    constructor(state: EncoderState, embeddedEncode?: EmbeddedTypeEncode<T>);
    withEmbeddedEncode<S extends Embeddable>(embeddedEncode: EmbeddedTypeEncode<S>, body: (e: Encoder<S>) => void): this;
    get canonical(): boolean;
    get includeAnnotations(): boolean;
    contents(): Bytes;
    contentsString(): string;
    grouped(tag: Tag, f: () => void): void;
    push(v: Encodable<T>): this;
}
declare function encode<T extends Embeddable>(v: Encodable<T>, options?: EncoderEmbeddedOptions<T>): Bytes;
declare function canonicalEncode(v: Encodable<never>, options?: EncoderEmbeddedOptions<never>): Bytes;
declare function canonicalEncode(v: Encodable<any>, options?: EncoderEmbeddedOptions<any>): Bytes;
declare function canonicalString(v: Encodable<any>, options?: EncoderEmbeddedOptions<any>): string;
declare function encodeWithAnnotations<T extends Embeddable>(v: Encodable<T>, options?: EncoderEmbeddedOptions<T>): Bytes;

interface FromJSOptions<T extends Embeddable = GenericEmbedded> {
    onNonInteger?(n: number): Value<T> | undefined;
}
declare function fromJS<T extends Embeddable = GenericEmbedded>(x: any): Value<T>;
declare function fromJS_options<T extends Embeddable = GenericEmbedded>(x: any, options?: FromJSOptions<T>): Value<T>;

type DictionaryType = 'Dictionary' | 'Set';
declare const DictionaryType: unique symbol;
type CompoundKey<T extends Embeddable> = Value<T> | (Preservable<T> & PreserveWritable<T>);
declare class EncodableDictionary<T extends Embeddable, K, V> extends FlexMap<K, V> implements Preservable<T>, PreserveWritable<T> {
    readonly encodeK: (k: K) => CompoundKey<T>;
    readonly encodeV: (v: V) => CompoundKey<T>;
    constructor(encodeK: (k: K) => CompoundKey<T>, encodeV: (v: V) => CompoundKey<T>, items?: readonly [K, V][] | Iterable<readonly [K, V]>);
    __preserve_on__(encoder: Encoder<T>): void;
    __preserve_text_on__(w: Writer<T>): void;
    toString(): string;
}
declare class KeyedDictionary<T extends Embeddable = GenericEmbedded, K extends CompoundKey<T> = Value<T>, V = Value<T>> extends EncodableDictionary<T, K, V> {
    get [DictionaryType](): DictionaryType;
    static isKeyedDictionary<T extends Embeddable = GenericEmbedded, K extends CompoundKey<T> = Value<T>, V = Value<T>>(x: any): x is KeyedDictionary<T, K, V>;
    static fromJS<T extends Embeddable = GenericEmbedded>(x: object, options?: FromJSOptions<T>): KeyedDictionary<T, string, Value<T>>;
    constructor(items?: readonly [K, V][] | Iterable<readonly [K, V]>);
    clone(): KeyedDictionary<T, K, V>;
    get [Symbol.toStringTag](): string;
    equals(otherAny: any, eqv?: Equivalence<V>): boolean;
}
declare class DictionaryMap<T extends Embeddable = GenericEmbedded, V = Value<T>> implements Map<Value<T>, V> {
    get [IsMap](): boolean;
    j: JsDictionary<V> | undefined;
    k: KeyedDictionary<T, Value<T>, V> | undefined;
    constructor(input?: Dictionary<T, V>);
    static from<T extends Embeddable = GenericEmbedded, V = Value<T>>(entries: [Value<T>, V][] | Iterable<[Value<T>, V]>): DictionaryMap<T, V>;
    clear(): void;
    delete(key: Value<T>): boolean;
    forEach(callbackfn: (value: V, key: Value<T>, map: Map<Value<T>, V>) => void, thisArg?: any): void;
    get(key: Value<T>): V | undefined;
    has(key: Value<T>): boolean;
    set(key: Value<T>, value: V): this;
    get size(): number;
    entries(): MapIterator<[Value<T>, V]>;
    keys(): MapIterator<Value<T>>;
    values(): MapIterator<V>;
    [Symbol.iterator](): MapIterator<[Value<T>, V]>;
    get [Symbol.toStringTag](): string;
    clone(): DictionaryMap<T, V>;
    get value(): Dictionary<T, V>;
    simplify(): void;
    simplifiedValue(): Dictionary<T, V>;
    asJsDictionary(): JsDictionary<V>;
    asKeyedDictionary(): KeyedDictionary<T, Value<T>, V>;
}
type Dictionary<T extends Embeddable = GenericEmbedded, V = Value<T>> = JsDictionary<V> | KeyedDictionary<T, Value<T>, V>;
declare namespace Dictionary {
    function isDictionary<T extends Embeddable = GenericEmbedded, V = Value<T>>(x: any): x is Dictionary<T, V>;
    function asMap<T extends Embeddable = GenericEmbedded, V = Value<T>>(x: Dictionary<T, V>): DictionaryMap<T, V>;
    function asMap<T extends Embeddable = GenericEmbedded, V = Value<T>>(x: any): DictionaryMap<T, V> | undefined;
    function from<T extends Embeddable = GenericEmbedded, V = Value<T>>(entries: [Value<T>, V][] | Iterable<[Value<T>, V]>): Dictionary<T, V>;
    function __from_preserve__<T extends Embeddable>(v: Value<T>): undefined | Dictionary<T>;
}
declare function encodeDictionaryOn<T extends Embeddable, K, V>(dict: Map<K, V>, encoder: Encoder<T>, encodeK: (k: K, encoder: Encoder<T>) => void, encodeV: (v: V, encoder: Encoder<T>) => void): void;
declare function writeDictionaryOn<T extends Embeddable, K, V>(dict: Map<K, V>, w: Writer<T>, writeK: (k: K, w: Writer<T>) => void, writeV: (v: V, w: Writer<T>) => void): void;
declare class EncodableSet<T extends Embeddable, V> extends FlexSet<V> implements Preservable<T>, PreserveWritable<T> {
    readonly encodeV: (v: V) => CompoundKey<T>;
    constructor(encodeV: (v: V) => CompoundKey<T>, items?: Iterable<V>);
    __preserve_on__(encoder: Encoder<T>): void;
    __preserve_text_on__(w: Writer<T>): void;
    toString(): string;
}
declare class KeyedSet<T extends Embeddable = GenericEmbedded, K extends CompoundKey<T> = Value<T>> extends EncodableSet<T, K> {
    get [DictionaryType](): DictionaryType;
    static isKeyedSet<T extends Embeddable = GenericEmbedded, K extends CompoundKey<T> = Value<T>>(x: any): x is KeyedSet<T, K>;
    constructor(items?: Iterable<K>);
    map<R extends Embeddable = GenericEmbedded, S extends Value<R> = Value<R>>(f: (value: K) => S): KeyedSet<R, S>;
    filter(f: (value: K) => boolean): KeyedSet<T, K>;
    clone(): KeyedSet<T, K>;
    get [Symbol.toStringTag](): string;
}
declare class Set$2<T extends Embeddable = GenericEmbedded> extends KeyedSet<T> {
    static isSet<T extends Embeddable = GenericEmbedded>(x: any): x is Set$2<T>;
    static __from_preserve__<T extends Embeddable>(v: Value<T>): undefined | Set$2<T>;
}
declare function encodeSetOn<T extends Embeddable, V>(s: IdentitySet<V>, encoder: Encoder<T>, encodeV: (v: V, encoder: Encoder<T>) => void): void;
declare function writeSetOn<T extends Embeddable, V>(s: IdentitySet<V>, w: Writer<T>, writeV: (v: V, w: Writer<T>) => void): void;

interface DecoderOptions {
    includeAnnotations?: boolean;
}
interface DecoderEmbeddedOptions<T extends Embeddable> extends DecoderOptions {
    embeddedDecode?: EmbeddedTypeDecode<T>;
}
interface TypedDecoder<T extends Embeddable> {
    atEnd(): boolean;
    mark(): any;
    restoreMark(m: any): undefined;
    skip(): void;
    next(): Value<T>;
    withEmbeddedDecode<S extends Embeddable, R>(embeddedDecode: EmbeddedTypeDecode<S>, body: (d: TypedDecoder<S>) => R): R;
    nextBoolean(): boolean | undefined;
    nextDouble(): DoubleFloat | undefined;
    nextEmbedded(): T | undefined;
    nextSignedInteger(): number | bigint | undefined;
    nextString(): string | undefined;
    nextByteString(): Bytes | undefined;
    nextSymbol(): symbol | undefined;
    openRecord(): boolean;
    openSequence(): boolean;
    openSet(): boolean;
    openDictionary(): boolean;
    closeCompound(): boolean;
}
declare function asLiteral<T extends Embeddable, E extends Exclude<Value<T>, Annotated<T>>>(actual: Value<T>, expected: E): E | undefined;
declare class DecoderState {
    packet: Uint8Array;
    index: number;
    options: DecoderOptions;
    constructor(packet: BytesLike, options: DecoderOptions);
    get includeAnnotations(): boolean;
    write(data: BytesLike): void;
    atEnd(): boolean;
    mark(): number;
    restoreMark(m: number): undefined;
    shortGuard<R>(body: () => R, short: () => R): R;
    nextbyte(): number;
    nextbytes(n: number): DataView;
    varint(): number;
    peekend(): boolean;
    nextint(n: number): number | bigint;
    nextbigint(n: number): bigint;
    wrap<T extends Embeddable>(v: Value<T>): Value<T>;
    unshiftAnnotation<T extends Embeddable>(a: Value<T>, v: Annotated<T>): Annotated<T>;
}
declare class Decoder<T extends Embeddable = never> implements TypedDecoder<T> {
    state: DecoderState;
    embeddedDecode: EmbeddedTypeDecode<T>;
    constructor(state: DecoderState, embeddedDecode?: EmbeddedTypeDecode<T>);
    constructor(packet?: BytesLike, options?: DecoderEmbeddedOptions<T>);
    write(data: BytesLike): void;
    nextvalues(): Value<T>[];
    static dictionaryFromArray<T extends Embeddable>(vs: Value<T>[]): Dictionary<T>;
    next(): Value<T>;
    try_next(): Value<T> | undefined;
    atEnd(): boolean;
    mark(): any;
    restoreMark(m: any): undefined;
    skip(): void;
    withEmbeddedDecode<S extends Embeddable, R>(embeddedDecode: EmbeddedTypeDecode<S>, body: (d: TypedDecoder<S>) => R): R;
    skipAnnotations<R>(f: (reset: () => undefined) => R): R;
    nextBoolean(): boolean | undefined;
    nextDouble(): DoubleFloat | undefined;
    nextEmbedded(): T | undefined;
    nextSignedInteger(): number | bigint | undefined;
    nextString(): string | undefined;
    nextByteString(): Bytes | undefined;
    nextSymbol(): symbol | undefined;
    openRecord(): boolean;
    openSequence(): boolean;
    openSet(): boolean;
    openDictionary(): boolean;
    closeCompound(): boolean;
}
declare function decode<T extends Embeddable>(bs: BytesLike, options?: DecoderEmbeddedOptions<T>): Value<T>;
declare function decodeWithAnnotations<T extends Embeddable>(bs: BytesLike, options?: DecoderEmbeddedOptions<T>): Annotated<T>;

interface ReaderStateOptions {
    includeAnnotations?: boolean;
    name?: string | Position;
}
interface ReaderOptions<T> extends ReaderStateOptions {
    embeddedDecode?: EmbeddedTypeDecode<T>;
}
declare const NUMBER_RE: RegExp;
declare class ReaderState {
    buffer: string;
    pos: Position;
    index: number;
    discarded: number;
    options: ReaderStateOptions;
    constructor(buffer: string, options: ReaderStateOptions);
    error(message: string, pos: Position): never;
    get includeAnnotations(): boolean;
    copyPos(): Position;
    write(data: string): void;
    atEnd(): boolean;
    peek(): string;
    advance(): number;
    nextchar(): string;
    nextcharcode(): number;
    skipws(skipCommas?: boolean): void;
    readHex2(): number;
    readHex4(): number;
    readHexBinary(): Bytes;
    readHexFloat(): DoubleFloat;
    readBase64Binary(): Bytes;
    requireDelimiter(prefix: string): void;
    static readonly DELIMITERS = "(){}[]<>\"';,@#:";
    delimiterFollows(): boolean;
    readRawSymbolOrNumber(acc: string): number | bigint | symbol | DoubleFloat;
    readStringlike<E, R>(xform: (ch: string) => E, finish: (acc: E[]) => R, terminator: string, hexescape: string, hex: () => E): R;
    readString(terminator: string): string;
    readLiteralBinary(): Bytes;
    readCommentLine(): string;
}
declare const genericEmbeddedTypeDecode: EmbeddedTypeDecode<GenericEmbedded>;
declare const neverEmbeddedTypeDecode: EmbeddedTypeDecode<never>;
declare class ReaderBase<T extends Embeddable> {
    state: ReaderState;
    embeddedType: EmbeddedTypeDecode<T>;
    constructor(state: ReaderState, embeddedType: EmbeddedTypeDecode<T>);
    constructor(buffer: string, options?: ReaderOptions<T>);
    write(data: string): void;
}
declare class Reader$1<T extends Embeddable> extends ReaderBase<T> {
    readCommentLine(): Value<T>;
    wrap(v: Value<T>, pos: Position): Value<T>;
    annotateNextWith(v: Value<T>): Value<T>;
    readToEnd(): Array<Value<T>>;
    next(): Value<T>;
    seq<S>(skipCommas: boolean, acc: S, update: (v: Value<T>, acc: S) => void, ch: string): S;
    readSequence(ch: string, skipCommas: boolean): Array<Value<T>>;
    readDictionary(): Dictionary<T>;
    readSet(): Set$2<T>;
}

declare const IsEmbedded: unique symbol;
interface Embeddable {
    readonly [IsEmbedded]: true;
}
declare function isEmbedded<T extends Embeddable>(v: any): v is T;
type EmbeddedTypeEncode<T extends Embeddable> = {
    encode(s: EncoderState, v: T): void;
};
type EmbeddedTypeDecode<T> = {
    decode(s: DecoderState): T;
    fromValue(v: Value<GenericEmbedded>, options: ReaderStateOptions): T;
};
type EmbeddedType<T extends Embeddable> = EmbeddedTypeEncode<T> & EmbeddedTypeDecode<T>;
declare class Embedded$1<T> {
    readonly value: T;
    get [IsEmbedded](): true;
    constructor(value: T);
    equals(other: any): boolean;
}
declare class GenericEmbedded {
    readonly generic: Value;
    get [IsEmbedded](): true;
    constructor(generic: Value);
    equals(other: any, is: (a: any, b: any) => boolean): boolean;
    toString(): string;
}

declare const IsPreservesAnnotated: unique symbol;
declare function isAnnotated<T extends Embeddable = GenericEmbedded>(x: any): x is Annotated<T>;
declare function is(a: any, b: any): boolean;

interface Position {
    line?: number;
    column?: number;
    pos: number;
    name?: string;
}
declare function newPosition(name?: string): Position;
declare function updatePosition(p: Position, ch: string): boolean;
declare function formatPosition(p: Position | null | string): string;
declare class Annotated<T extends Embeddable = GenericEmbedded> implements Preservable<T>, PreserveWritable<T> {
    readonly annotations: Array<Value<T>>;
    readonly pos: Position | null;
    readonly item: Value<T>;
    constructor(item: Value<T>, pos?: Position);
    __as_preserve__(): Value<T>;
    static __from_preserve__<T extends Embeddable>(v: Value<T>): undefined | Annotated<T>;
    __preserve_on__(encoder: Encoder<T>): void;
    __preserve_text_on__(w: Writer<T>): void;
    toString(): string;
    equals(other: any): boolean;
    get [IsPreservesAnnotated](): boolean;
    static isAnnotated<T extends Embeddable = GenericEmbedded>(x: any): x is Annotated<T>;
}
declare function annotate<T extends Embeddable = GenericEmbedded>(v0: Value<T>, ...anns: Value<T>[]): Annotated<T>;
declare function annotations<T extends Embeddable = GenericEmbedded>(v: Value<T>): Array<Value<T>>;
declare function position<T extends Embeddable = GenericEmbedded>(v: Value<T>): Position | null;

declare function decodeBase64(s: string): Uint8Array;
declare function encodeBase64(bs: Uint8Array): string;

type ErrorType = 'DecodeError' | 'EncodeError' | 'ShortPacket';
declare const ErrorType: unique symbol;
declare abstract class PreservesCodecError {
    abstract get [ErrorType](): ErrorType;
    static isCodecError(e: any, t: ErrorType): e is PreservesCodecError;
}
declare class DecodeError extends Error {
    readonly pos: Position | undefined;
    get [ErrorType](): ErrorType;
    constructor(message: string, pos?: Position);
    static isDecodeError(e: any): e is DecodeError;
}
declare class EncodeError extends Error {
    get [ErrorType](): ErrorType;
    static isEncodeError(e: any): e is EncodeError;
    readonly irritant: any;
    constructor(message: string, irritant: any);
}
declare class ShortPacket extends DecodeError {
    get [ErrorType](): ErrorType;
    static isShortPacket(e: any): e is ShortPacket;
}

declare function isCompound<T extends Embeddable = GenericEmbedded>(x: Value<T>): x is Compound$1<T>;
declare function isSequence<T extends Embeddable = GenericEmbedded>(x: Value<T>): x is Array<Value<T>>;

declare const genericEmbeddedType: EmbeddedType<GenericEmbedded>;
declare const neverEmbeddedType: EmbeddedType<never>;

type Tuple<T> = Array<T> | [T];
type RecordGetters<Fs, R> = {
    [K in string & keyof Fs]: (r: R) => Fs[K];
};
type CtorTypes<Fs, Names extends Tuple<keyof Fs>> = {
    [K in keyof Names]: Fs[keyof Fs & Names[K]];
} & any[];
interface RecordConstructor<L extends Value<T>, Fs, Names extends Tuple<keyof Fs>, T extends Embeddable = GenericEmbedded> {
    (...fields: CtorTypes<Fs, Names>): Record$1<L, CtorTypes<Fs, Names>, T>;
    constructorInfo: RecordConstructorInfo<L, T>;
    isClassOf(v: any): v is Record$1<L, CtorTypes<Fs, Names>, T>;
    _: RecordGetters<Fs, Record$1<L, CtorTypes<Fs, Names>, T>>;
    fieldNumbers: {
        [K in string & keyof Fs]: number;
    };
}
interface RecordConstructorInfo<L extends Value<T>, T extends Embeddable = GenericEmbedded> {
    label: L;
    arity: number;
}
type InferredRecordType<L, FieldsType extends Tuple<any>> = L extends symbol ? (FieldsType extends Tuple<Value<infer T>> ? (Exclude<T, never> extends symbol ? Record$1<L, FieldsType, never> : Record$1<L, FieldsType, T>) : (FieldsType extends Tuple<Value<never>> ? Record$1<L, FieldsType, never> : "TYPE_ERROR_cannotInferFieldsType" & [never])) : L extends Value<infer T> ? (FieldsType extends Tuple<Value<T>> ? Record$1<L, FieldsType, T> : "TYPE_ERROR_cannotMatchFieldsTypeToLabelType" & [never]) : "TYPE_ERROR_cannotInferEmbeddedType" & [never];
type Record$1<LabelType extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends Embeddable = GenericEmbedded> = FieldsType & {
    label: LabelType;
};
declare function Record$1<L, FieldsType extends Tuple<any>>(label: L, fields: FieldsType): InferredRecordType<L, FieldsType>;
declare namespace Record$1 {
    function isRecord<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends Embeddable = GenericEmbedded>(x: any): x is Record$1<L, FieldsType, T>;
    function constructorInfo<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends Embeddable = GenericEmbedded>(r: Record$1<L, FieldsType, T>): RecordConstructorInfo<L, T>;
    function isClassOf<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends Embeddable = GenericEmbedded>(ci: RecordConstructorInfo<L, T>, v: any): v is Record$1<L, FieldsType, T>;
    function makeConstructor<Fs, T extends Embeddable = GenericEmbedded>(): (<L extends Value<T>, Names extends Tuple<keyof Fs>>(label: L, fieldNames: Names) => RecordConstructor<L, Fs, Names, T>);
}

declare enum ValueClass {
    Boolean = 0,
    Double = 1,
    SignedInteger = 2,
    String = 3,
    ByteString = 4,
    Symbol = 5,
    Record = 6,
    Sequence = 7,
    Set = 8,
    Dictionary = 9,
    Embedded = 10,
    Annotated = 11
}
type Fold<T extends Embeddable, R = Value<T>> = (v: Value<T>) => R;
interface FoldMethods<T extends Embeddable, R> {
    boolean(b: boolean): R;
    double(f: number): R;
    integer(i: number | bigint): R;
    string(s: string): R;
    bytes(b: Bytes): R;
    symbol(s: symbol): R;
    record(r: Record$1<Value<T>, Tuple<Value<T>>, T>, k: Fold<T, R>): R;
    array(a: Array<Value<T>>, k: Fold<T, R>): R;
    set(s: Set$2<T>, k: Fold<T, R>): R;
    dictionary(d: DictionaryMap<T>, k: Fold<T, R>): R;
    annotated(a: Annotated<T>, k: Fold<T, R>): R;
    embedded(t: T, k: Fold<T, R>): R;
}
declare class VoidFold<T extends Embeddable> implements FoldMethods<T, void> {
    boolean(_b: boolean): void;
    double(_f: number): void;
    integer(_i: number | bigint): void;
    string(_s: string): void;
    bytes(_b: Bytes): void;
    symbol(_s: symbol): void;
    record(r: Record$1<Value<T>, Tuple<Value<T>>, T>, k: Fold<T, void>): void;
    array(a: Value<T>[], k: Fold<T, void>): void;
    set(s: Set$2<T>, k: Fold<T, void>): void;
    dictionary(d: DictionaryMap<T>, k: Fold<T, void>): void;
    annotated(a: Annotated<T>, k: Fold<T, void>): void;
    embedded(_t: T, _k: Fold<T, void>): void;
}
declare class ForEachEmbedded<T extends Embeddable> extends VoidFold<T> {
    readonly f: (t: T, k: Fold<T, void>) => void;
    constructor(f: (t: T, k: Fold<T, void>) => void);
    embedded(t: T, k: Fold<T, void>): void;
}
declare abstract class ValueFold<T extends Embeddable, R extends Embeddable = T> implements FoldMethods<T, Value<R>> {
    boolean(b: boolean): Value<R>;
    double(f: number): Value<R>;
    integer(i: number | bigint): Value<R>;
    string(s: string): Value<R>;
    bytes(b: Bytes): Value<R>;
    symbol(s: symbol): Value<R>;
    record(r: Record$1<Value<T>, Tuple<Value<T>>, T>, k: Fold<T, Value<R>>): Value<R>;
    array(a: Value<T>[], k: Fold<T, Value<R>>): Value<R>;
    set(s: Set$2<T>, k: Fold<T, Value<R>>): Value<R>;
    dictionary(d: DictionaryMap<T>, k: Fold<T, Value<R>>): Value<R>;
    annotated(a: Annotated<T>, k: Fold<T, Value<R>>): Value<R>;
    abstract embedded(t: T, k: Fold<T, Value<R>>): Value<R>;
}
declare class IdentityFold<T extends Embeddable> extends ValueFold<T, T> {
    embedded(t: T, _k: Fold<T, Value<T>>): Value<T>;
}
declare class MapFold<T extends Embeddable, R extends Embeddable> extends ValueFold<T, R> {
    readonly f: (t: T) => Value<R>;
    constructor(f: (t: T) => Value<R>);
    embedded(t: T, _k: Fold<T, Value<R>>): Value<R>;
}
declare function valueClass<T extends Embeddable>(v: Value<T>): ValueClass;
declare const IDENTITY_FOLD: IdentityFold<any>;
declare function fold<T extends Embeddable, R>(v: Value<T>, o: FoldMethods<T, R>): R;
declare function mapEmbeddeds<T extends Embeddable, R extends Embeddable>(v: Value<T>, f: (t: T) => Value<R>): Value<R>;
declare function forEachEmbedded<T extends Embeddable>(v: Value<T>, f: (t: T, k: Fold<T, void>) => void): void;

declare function merge<T extends Embeddable>(mergeEmbeddeds: (a: T, b: T) => T | undefined, item0: Value<T>, ...items: Array<Value<T>>): Value<T>;

declare function typeCode<T extends Embeddable>(v: Value<T>): number;
declare function compare<T extends Embeddable>(a: Value<T>, b: Value<T>, compare_embedded?: (a: T, b: T) => number): number;

declare function unannotate<T extends Embeddable = GenericEmbedded>(v: Value<T>): Value<T>;
declare function peel<T extends Embeddable = GenericEmbedded>(v: Value<T>): Value<T>;
declare function strip<T extends Embeddable = GenericEmbedded>(v: Value<T>, depth?: number): Value<T>;

declare function parse<T extends Embeddable = GenericEmbedded>(buffer: string, options?: ReaderOptions<T>): Value<T>;
declare function parseAll<T extends Embeddable = GenericEmbedded>(buffer: string, options?: ReaderOptions<T>): Value<T>[];
declare const stringifyEmbeddedWrite: {
    write(s: WriterState, v: any): void;
};
declare function stringify<T extends Embeddable = GenericEmbedded>(x: any, options?: WriterOptions<T>): string;
declare function preserves(pieces: TemplateStringsArray, ...values: any[]): string;

type Expr = SimpleExpr | Punct;
type SimpleExpr = Atom | Compound | Embedded;
type Positioned<I> = {
    position: Position;
    item: I;
    annotations?: Annotations;
};
declare class Punct {
    text: string;
    constructor(text: string);
    __as_preserve__(): Value;
    isComma(): boolean;
    static isComma(v: Expr): boolean;
    isColon(n?: number): boolean;
    static isColon(v: Expr, n?: number): boolean;
}
declare class Embedded {
    expr: SimpleExpr;
    annotations?: Annotations | undefined;
    constructor(expr: SimpleExpr, annotations?: Annotations | undefined);
    __as_preserve__(): Value;
}
declare class BaseCompound<I> {
    positions: Position[];
    exprs: I[];
    annotations?: Annotations[];
    get(i: number): Positioned<I> | undefined;
    push(p: Positioned<I>): true;
    push(expr: I, position: Position, annotations?: Annotations): true;
    _ensureAnnotations(): Annotations[];
    _annotationsAt(index: number): Annotations;
    preservesValues(): Value[];
    __as_preserve__(): Value;
    map<R>(f: (item: Positioned<I>, index: number) => R, offset?: number): R[];
    [Symbol.iterator](): IterableIterator<Positioned<I>>;
}
declare class Document extends BaseCompound<Expr> {
}
declare class Annotations extends BaseCompound<SimpleExpr> {
    wrap(v: Value): Value;
}
type CompoundVariant = 'sequence' | 'record' | 'block' | 'group' | 'set';
declare abstract class Compound extends BaseCompound<Expr> {
    abstract get variant(): CompoundVariant;
    __as_preserve__(): Value;
}
declare class Sequence extends Compound {
    get variant(): CompoundVariant;
}
declare class Record extends Compound {
    get variant(): CompoundVariant;
}
declare class Block extends Compound {
    get variant(): CompoundVariant;
}
declare class Group extends Compound {
    get variant(): CompoundVariant;
}
declare class Set$1 extends Compound {
    get variant(): CompoundVariant;
}
declare class Reader extends ReaderBase<never> {
    nextDocument(howMany?: 'all' | 'one'): Document;
    readCompound(c: Compound, terminator: string): Compound;
    readSimpleExpr(c: BaseCompound<SimpleExpr>): boolean;
    readExpr(c: BaseCompound<Expr>, terminator?: string | null): boolean;
    _checkTerminator(actual: string, expected: string | null, startPos: Position): false;
    _readInto(c: BaseCompound<SimpleExpr>, acceptPunct: boolean, terminator?: string | null): boolean;
}
interface AsPreservesOptions<T extends Embeddable> {
    onGroup?: (g: Positioned<Group>) => Value<T>;
    onEmbedded?: (e: Positioned<Expr>, walk: (p: Positioned<Expr>) => Value<T>) => Value<T>;
    error?: (tag: string, position: Position) => Value<T>;
}
declare function asPreserves<T extends Embeddable>(p: Positioned<Expr>, options?: AsPreservesOptions<T>): Value<T>;

type pexpr_Annotations = Annotations;
declare const pexpr_Annotations: typeof Annotations;
type pexpr_AsPreservesOptions<T extends Embeddable> = AsPreservesOptions<T>;
type pexpr_BaseCompound<I> = BaseCompound<I>;
declare const pexpr_BaseCompound: typeof BaseCompound;
type pexpr_Block = Block;
declare const pexpr_Block: typeof Block;
type pexpr_Compound = Compound;
declare const pexpr_Compound: typeof Compound;
type pexpr_CompoundVariant = CompoundVariant;
type pexpr_Document = Document;
declare const pexpr_Document: typeof Document;
type pexpr_Embedded = Embedded;
declare const pexpr_Embedded: typeof Embedded;
type pexpr_Expr = Expr;
type pexpr_Group = Group;
declare const pexpr_Group: typeof Group;
type pexpr_Positioned<I> = Positioned<I>;
type pexpr_Punct = Punct;
declare const pexpr_Punct: typeof Punct;
type pexpr_Reader = Reader;
declare const pexpr_Reader: typeof Reader;
type pexpr_Record = Record;
declare const pexpr_Record: typeof Record;
type pexpr_Sequence = Sequence;
declare const pexpr_Sequence: typeof Sequence;
type pexpr_SimpleExpr = SimpleExpr;
declare const pexpr_asPreserves: typeof asPreserves;
declare namespace pexpr {
  export { pexpr_Annotations as Annotations, type pexpr_AsPreservesOptions as AsPreservesOptions, pexpr_BaseCompound as BaseCompound, pexpr_Block as Block, pexpr_Compound as Compound, type pexpr_CompoundVariant as CompoundVariant, pexpr_Document as Document, pexpr_Embedded as Embedded, type pexpr_Expr as Expr, pexpr_Group as Group, type pexpr_Positioned as Positioned, pexpr_Punct as Punct, pexpr_Reader as Reader, pexpr_Record as Record, pexpr_Sequence as Sequence, Set$1 as Set, type pexpr_SimpleExpr as SimpleExpr, pexpr_asPreserves as asPreserves };
}

declare function preserves_spec_version(): string;

declare global {
    interface ArrayConstructor {
        __from_preserve__<T extends Embeddable>(v: Value<T>): undefined | Array<Value<T>>;
    }
}
declare const _Array: ArrayConstructor;
type _Array<T> = Array<T>;

declare const _Symbol: SymbolConstructor;
type _Symbol = Symbol;

export { Annotated, _Array as Array, type Atom, Bytes, type BytesLike, type Canonicalizer, type Compound$1 as Compound, type CompoundKey, constants as Constants, type CtorTypes, DecodeError, Decoder, type DecoderEmbeddedOptions, type DecoderOptions, DecoderState, Dictionary, DictionaryMap, DictionaryType, Double, DoubleFloat, type Embeddable, Embedded$1 as Embedded, type EmbeddedType, type EmbeddedTypeDecode, type EmbeddedTypeEncode, type EmbeddedWriter, type Encodable, EncodableDictionary, EncodableSet, EncodeError, Encoder, type EncoderEmbeddedOptions, type EncoderOptions, EncoderState, type Equivalence, ErrorType, FlexMap, FlexSet, Float, FloatType, type Fold, type FoldMethods, ForEachEmbedded, type FromJSOptions, GenericEmbedded, IDENTITY_FOLD, IdentityEmbeddedTypeEncode, IdentityFold, IdentityMap, IdentitySet, type InferredRecordType, IsEmbedded, IsMap, IsPreservesAnnotated, IsPreservesBytes, IsSet, JsDictionary, KeyedDictionary, KeyedSet, MapFold, NUMBER_RE, pexpr as Pexpr, type Position, type Preservable, type PreserveWritable, PreservesCodecError, Reader$1 as Reader, ReaderBase, type ReaderOptions, ReaderState, type ReaderStateOptions, Record$1 as Record, type RecordConstructor, type RecordConstructorInfo, type RecordGetters, Set$2 as Set, ShortPacket, _Symbol as Symbol, type Tuple, type TypedDecoder, type Value, ValueClass, ValueFold, VoidFold, type Writable, Writer, type WriterOptions, WriterState, type WriterStateOptions, _iterMap, annotate, annotations, asLiteral, canonicalEncode, canonicalString, compare, dataview, decode, decodeBase64, decodeWithAnnotations, encode, encodeBase64, encodeDictionaryOn, encodeSetOn, encodeWithAnnotations, floatValue, floatlikeString, fold, forEachEmbedded, formatPosition, fromJS, fromJS_options, genericEmbeddedType, genericEmbeddedTypeDecode, genericEmbeddedTypeEncode, hexDigit, is, isAnnotated, isCompound, isEmbedded, isPreservable, isPreserveWritable, isSequence, mapEmbeddeds, merge, neverEmbeddedType, neverEmbeddedTypeDecode, neverEmbeddedTypeEncode, newPosition, parse, parseAll, peel, position, preserves, preserves_spec_version, stringify, stringifyEmbeddedWrite, strip, typeCode, unannotate, underlying, unhexDigit, updatePosition, valueClass, writeDictionaryOn, writeSetOn };