import { ByteInput as ByteInput$1, blake2b256, Coder } from '@fleet-sdk/crypto';
import { Box, Amount, BoxCandidate, UnsignedTransaction, SignedTransaction } from '@fleet-sdk/common';

declare class SigmaByteReader {
    #private;
    get isEmpty(): boolean;
    get bytes(): Uint8Array;
    get cursor(): number;
    constructor(bytes: ByteInput$1);
    readArray<T>(readFn: (reader: SigmaByteReader, index: number) => T): Array<T>;
    readBool(): boolean;
    readBits(length: number): ArrayLike<boolean>;
    readByte(): number;
    readBytes(length: number): Uint8Array;
    readUInt(): number;
    readBigUInt(): bigint;
    readI8(): number;
    readI16(): number;
    readI32(): number;
    readI64(): bigint;
    readI256(): bigint;
    readRemainingBytes(): Uint8Array;
    readOption<T>(processor: (r: SigmaByteReader) => T): T | undefined;
    /**
     * Returns bytes without advancing the cursor.
     */
    peek(count: number, offset?: number): Uint8Array;
    /**
     * Checks if the current position in the byte array starts with the given bytes.
     */
    match(bytes: Uint8Array, offset?: number): boolean;
}

declare class SigmaByteWriter {
    #private;
    get length(): number;
    constructor(length: number);
    writeBool(value: boolean): SigmaByteWriter;
    writeUInt(value: number): SigmaByteWriter;
    writeBigUInt(value: bigint): SigmaByteWriter;
    writeI16(value: number): SigmaByteWriter;
    writeI32(value: number): SigmaByteWriter;
    writeI64(value: bigint): SigmaByteWriter;
    writeI256(value: bigint): SigmaByteWriter;
    write(byte: number): SigmaByteWriter;
    writeBytes(bytes: ArrayLike<number>): SigmaByteWriter;
    writeHex(bytesHex: string): SigmaByteWriter;
    writeBits(bits: ArrayLike<boolean>): SigmaByteWriter;
    writeOption<T>(value: T | undefined, processor: (w: SigmaByteWriter) => void): SigmaByteWriter;
    writeChecksum(length?: number, hashFn?: typeof blake2b256): SigmaByteWriter;
    /**
     * Writes a length-delimited array of items to the byte stream using a provided
     * serializer function.
     *
     * @typeParam T - The type of items in the array.
     * @param items - The array of items to serialize and write.
     * @param serializer - A function that serializes each item and writes it using the provided SigmaByteWriter.
     * @returns The current instance of SigmaByteWriter for method chaining.
     */
    writeArray<T>(items: T[], serializer: (writer: SigmaByteWriter, item: T) => void): SigmaByteWriter;
    encode<T>(coder: Coder<Uint8Array, T>): T;
    toBytes(): Uint8Array;
}

/**
 * Estimates the byte size of a given unsigned integer.
 * @param value: the value to be evaluated.
 * @returns the byte size of the value.
 */
declare function estimateVLQSize(value: number | bigint | string): number;

declare abstract class SType<I = unknown, O = I> {
    abstract get code(): number;
    abstract get embeddable(): boolean;
    coerce(data: I): O;
    abstract toString(): string;
}
declare abstract class SMonomorphicType<I, O = I> extends SType<I, O> {
    abstract get code(): number;
    get embeddable(): boolean;
}
declare abstract class SPrimitiveType<I, O = I> extends SMonomorphicType<I, O> {
    abstract get code(): number;
    get embeddable(): boolean;
}
declare abstract class SGenericType<T extends SType | SType[]> extends SType {
    #private;
    constructor(type: T);
    abstract get code(): number;
    get elementsType(): T;
    get embeddable(): boolean;
}

interface AvlTreeFlags {
    insertAllowed: boolean;
    updateAllowed: boolean;
    removeAllowed: boolean;
}
interface AvlTreeData extends AvlTreeFlags {
    digest: string;
    keyLength: number;
    valueLengthOpt?: number;
}

declare class SCollType<T extends SType = SType> extends SGenericType<T> {
    get code(): number;
    coerce<I, O>(elements: I[]): O[] | Uint8Array;
    toString(): string;
}
declare class STupleType<T extends SType[] = SType[]> extends SGenericType<T> {
    get code(): number;
    coerce<I, O>(elements: I[]): O[];
    toString(): string;
}

declare class SUnitType extends SMonomorphicType<undefined> {
    get code(): 0x62;
    toString(): string;
}
declare class SBoxType extends SMonomorphicType<SConstant<Box<bigint>>> {
    get code(): 0x63;
    toString(): string;
}
declare class SAvlTreeType extends SMonomorphicType<AvlTreeData> {
    get code(): 0x64;
    toString(): string;
}

type BigIntInput = string | bigint;
type ByteInput = Uint8Array | string;
type SConstructor<T = unknown, S extends SType = SType | SCollType<SType>> = (arg?: T) => S;
type SProxy<T extends SType, I, O = I> = {
    (value: I): SConstant<O, T>;
    (value?: I): T;
};
declare const SByte: SProxy<SByteType, number, number>;
declare const SBool: SProxy<SBoolType, boolean, boolean>;
declare const SShort: SProxy<SShortType, number, number>;
declare const SInt: SProxy<SIntType, number, number>;
declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array<ArrayBufferLike>>;
declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>>;
type SUnit = () => SConstant<undefined, SUnitType>;
declare const SUnit: SUnit;
type SBox = (value?: Box) => SConstant<Box<bigint>, SBoxType>;
declare const SBox: SBox;
type SAvlTree = (value?: AvlTreeData) => SConstant<AvlTreeData, SAvlTreeType>;
declare const SAvlTree: SAvlTree;
type SColl = {
    <D, T extends SByteType>(type: SConstructor<D, T>, elements: ByteInput | D[]): SConstant<Uint8Array, T>;
    <D, T extends SByteType>(type: SConstructor<D, T>, elements: ByteInput[]): SConstant<Uint8Array[], T>;
    <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;
    <D, T extends SType>(type: SConstructor<D, T>, elements: D[]): SConstant<D[], T>;
};
declare const SColl: SColl;
type ByteInputOr<D, T extends SType> = T extends SByteType ? ByteInput | D : D;
type SPair = {
    <L, R>(left: SConstant<L>, right: SConstant<R>): SConstant<[L, R], STupleType>;
    <LD, RD, LT extends SType, RT extends SType>(left: SConstructor<LD, LT>, right: SConstructor<RD, RT>): SConstructor<[ByteInputOr<LD, LT>, ByteInputOr<RD, RT>]>;
};
declare const SPair: SPair;

declare class SBoolType extends SPrimitiveType<boolean> {
    get code(): 0x01;
    toString(): string;
}
declare class SByteType extends SPrimitiveType<number> {
    get code(): 0x02;
    toString(): string;
}
declare class SShortType extends SPrimitiveType<number> {
    get code(): 0x03;
    toString(): string;
}
declare class SIntType extends SPrimitiveType<number> {
    get code(): 0x04;
    toString(): string;
}
declare class SLongType extends SPrimitiveType<BigIntInput, bigint> {
    get code(): 0x05;
    coerce(data: BigIntInput): bigint;
    toString(): string;
}
declare class SBigIntType extends SPrimitiveType<string | bigint, bigint> {
    get code(): number;
    coerce(data: BigIntInput): bigint;
    toString(): string;
}
declare class SGroupElementType extends SPrimitiveType<ByteInput, Uint8Array> {
    get code(): 0x07;
    coerce(data: ByteInput): Uint8Array;
    toString(): string;
}
declare class SSigmaPropType extends SPrimitiveType<SConstant<Uint8Array>> {
    get code(): 0x08;
    toString(): string;
}

declare function isColl(type: SType): type is SCollType;
declare function isTuple(type: SType): type is STupleType;

declare class SConstant<D = unknown, T extends SType = SType> {
    #private;
    constructor(type: T, data: D);
    static from<D, T extends SType = SType>(bytes: ByteInput$1 | SigmaByteReader): SConstant<D, T>;
    get type(): T;
    get data(): D;
    /**
     * Returns the serialized representation of the current instance as a `Uint8Array`.
     * If the bytes have already been computed and cached, returns the cached value.
     * Otherwise, serializes the instance and returns the resulting bytes.
     */
    get bytes(): Uint8Array;
    /**
     * Serializes the current object into a `Uint8Array`.
     */
    serialize(): Uint8Array;
    /**
     * @deprecated use `serialize` instead
     */
    toBytes(): Uint8Array;
    toHex(): string;
}
/**
 * Decodes a byte input into a Sigma constant of type `SConstant<D, T>`.
 *
 * @template D - The data type of the constant.
 * @template T - The type of the constant.
 * @param value - The value to decode.
 * @returns The decoded constant or `undefined` if the value is `undefined` or decoding fails.
 */
declare function decode<D = unknown, T extends SType = SType>(value?: ByteInput$1): SConstant<D, T> | undefined;
/**
 * Returns the `SType` of the given value.
 *
 * @param value - The value to check the SType of.
 * @returns The SType of the value, or `undefined` if the value is `undefined` or
 * deserialization fails.
 */
declare function stypeof(value?: ByteInput$1): SType | undefined;
/** @deprecated use `decode` instead */
declare function parse<T>(constant: ByteInput$1): T;
/** @deprecated use `decode` instead */
declare function parse<T>(constant: ByteInput$1, mode: "strict"): T;
/** @deprecated use `decode` instead */
declare function parse<T>(constant: ByteInput$1 | undefined, mode: "safe"): T | undefined;

declare function serializeBox(box: Box<Amount> | BoxCandidate<Amount>, writer?: SigmaByteWriter, distinctTokenIds?: string[]): SigmaByteWriter;
/**
 * Estimates the byte size a box.
 * @returns byte size of the box.
 */
declare function estimateBoxSize(box: Box<Amount> | BoxCandidate<Amount>, withValue?: Amount): number;
/**
 * Deserializes a box embedded in a transaction.
 *
 * It efficiently calculates the box ID by accumulating the serialized data during
 * deserialization and applying blake2b256 hashing, avoiding redundant serialization
 * operations.
 *
 * @param reader - SigmaByteReader containing the serialized box data
 * @param distinctTokenIds - Array of TokenIDs referenced in the parent transaction
 * @param transactionId - ID of the transaction containing this box
 * @param index - Index position of the box in the transaction outputs
 * @returns A fully deserialized Box with all properties including boxId
 */
declare function deserializeEmbeddedBox(reader: SigmaByteReader, distinctTokenIds: string[], transactionId: string, index: number): Box<bigint>;
declare function deserializeBox(input: ByteInput | SigmaByteReader): BoxCandidate<bigint> | Box<bigint>;

type Transaction = UnsignedTransaction | SignedTransaction;
declare function serializeTransaction(transaction: Transaction): SigmaByteWriter;
declare function deserializeTransaction<T extends Transaction>(input: ByteInput): T;

declare const dataSerializer: {
    serialize(data: unknown, type: SType, writer: SigmaByteWriter): SigmaByteWriter;
    deserialize(type: SType, reader: SigmaByteReader): unknown;
};

declare const typeSerializer: {
    serialize(type: SType, writer: SigmaByteWriter): void;
    deserialize(r: SigmaByteReader): SType;
};

export { SAvlTree, SAvlTreeType, SBigInt, SBigIntType, SBool, SBoolType, SBox, SBoxType, SByte, SByteType, SColl, SCollType, SConstant, SGenericType, SGroupElement, SGroupElementType, SInt, SIntType, SLong, SLongType, SMonomorphicType, SPair, SPrimitiveType, SShort, SShortType, SSigmaProp, SSigmaPropType, STupleType, SType, SUnit, SUnitType, SigmaByteReader, SigmaByteWriter, dataSerializer, decode, deserializeBox, deserializeEmbeddedBox, deserializeTransaction, estimateBoxSize, estimateVLQSize, isColl, isTuple, parse, serializeBox, serializeTransaction, stypeof, typeSerializer };