import { DynamicString, StaticArray } from '../dynamic.ts';
import { Bigint2048 } from '../rsa/rsa.ts';
import { MerkleList, Option, Proof, Provable, UInt32, UInt8 } from 'o1js';
export { ProvableEmail, verifyEmailSimple, prepareProvableEmail, verifyEmail, verifyEmailHeader, hashProgram, headerAndBodyProgram, };
type ProvableEmail = {
    /**
     * The email header in canonicalized form, i.e. the form that was signed.
     */
    header: string | DynamicString;
    /**
     * The email body in canonicalized form, i.e. the form that was signed.
     */
    body: string | DynamicString;
    /**
     * RSA public key that signed the email.
     */
    publicKey: Bigint2048;
    /**
     * The RSA signature of the email.
     */
    signature: Bigint2048;
};
/**
 * Simple provable method to verify an email. Only for demonstration purposes.
 *
 * **Note**: This uses more than 150k constraints, so it doesn't work inside a Pickles proof which has size limited to 2^16 constraints.
 * `verifyEmail()` achieves the same functionality by breaking up the logic into several proofs.
 */
declare function verifyEmailSimple(email: ProvableEmail): void;
declare function prepareProvableEmail(email: string): Promise<ProvableEmail>;
declare function ProvableEmail({ maxHeaderLength, maxBodyLength, }: {
    maxHeaderLength: number;
    maxBodyLength: number;
}): {
    new (value: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }): {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    };
    Header: {
        new (array: UInt8[], length: import("o1js").Field): {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        readonly maxLength: number;
        readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        }, string>;
        from(s: string | {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        }): {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
    };
    Body: {
        new (array: UInt8[], length: import("o1js").Field): {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        readonly maxLength: number;
        readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        }, string>;
        from(s: string | {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        }): {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
    };
    _isStruct: true;
    toFields: (value: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) => import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
    toAuxiliary: (value?: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    } | undefined) => any[];
    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[], aux: any[]) => {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    };
    sizeInFields(): number;
    check: (value: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) => void;
    toValue: (x: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) => {
        header: string;
        body: string;
        publicKey: bigint;
        signature: bigint;
    };
    fromValue: ((x: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    } | {
        header: string;
        body: string;
        publicKey: bigint;
        signature: bigint;
    }) => {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) & ((value: {
        header: string | {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: string | {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: bigint | Bigint2048;
        signature: bigint | Bigint2048;
    }) => {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    });
    toCanonical?: ((x: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) => {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) | undefined;
    toInput: (x: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) => {
        fields?: import("o1js").Field[] | undefined;
        packed?: [import("o1js").Field, number][] | undefined;
    };
    toJSON: (x: {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    }) => {
        header: {
            prototype: {
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes: {};
                toString: {};
                concat: {};
                assertEquals: {};
                splitAt: {};
                slice: {};
                reverse: {};
                assertContains: {};
                growMaxLengthTo: {};
                array: {
                    add: {};
                    sub: {};
                    mul: {};
                    div: {};
                    mod: {};
                    divMod: {};
                    lessThanOrEqual: {};
                    lessThan: {};
                    assertLessThan: {};
                    assertLessThanOrEqual: {};
                    greaterThan: {};
                    greaterThanOrEqual: {};
                    assertGreaterThan: {};
                    assertGreaterThanOrEqual: {};
                    assertEquals: {};
                    toString: {};
                    toNumber: {};
                    toBigInt: {};
                    toUInt32: {};
                    toUInt64: {};
                    value: string;
                }[];
                length: string;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                forEachReverse: {};
                reduce: {};
                hash: {};
                merkelize: {};
                chunk: {};
                assertEqualsStrict: {};
                concatTransposed: {};
                concatByHashing: {};
                push: {};
                growMaxLengthBy: {};
                normalize: {};
                assertNormalized: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                __dummyMask?: boolean[] | null | undefined;
                _indexMask: {};
                _dummyMask: {};
                isDummyIndex: {};
                toValue: {};
            };
            readonly maxLength: number;
            readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
                toString(): string;
                concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
                assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | StaticArray<UInt8, {
                    value: bigint;
                }> | (UInt8 | {
                    value: bigint;
                })[] | string): void;
                splitAt(index: number): [DynamicString, DynamicString];
                slice(start: number | UInt32): DynamicString;
                reverse(): DynamicString;
                assertContains(substring: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | string, message?: string): import("o1js").Field;
                growMaxLengthTo(maxLength: number): DynamicString;
                array: UInt8[];
                length: import("o1js").Field;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32): void;
                get(i: UInt32): UInt8;
                getOption(i: UInt32): Option<UInt8>;
                getOrUnconstrained(i: import("o1js").Field): UInt8;
                set(i: UInt32, value: UInt8): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
                map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
                forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
                hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
                merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
                chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                    value: bigint;
                }>, {
                    value: bigint;
                }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>];
                assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): void;
                concatTransposed(other: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                push(value: UInt8): void;
                growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                normalize(): void;
                assertNormalized(): void;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                __dummyMask?: import("o1js").Bool[];
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
                toValue(): {
                    value: bigint;
                }[];
            }, string>;
            from: {};
        };
        body: {
            prototype: {
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes: {};
                toString: {};
                concat: {};
                assertEquals: {};
                splitAt: {};
                slice: {};
                reverse: {};
                assertContains: {};
                growMaxLengthTo: {};
                array: {
                    add: {};
                    sub: {};
                    mul: {};
                    div: {};
                    mod: {};
                    divMod: {};
                    lessThanOrEqual: {};
                    lessThan: {};
                    assertLessThan: {};
                    assertLessThanOrEqual: {};
                    greaterThan: {};
                    greaterThanOrEqual: {};
                    assertGreaterThan: {};
                    assertGreaterThanOrEqual: {};
                    assertEquals: {};
                    toString: {};
                    toNumber: {};
                    toBigInt: {};
                    toUInt32: {};
                    toUInt64: {};
                    value: string;
                }[];
                length: string;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                forEachReverse: {};
                reduce: {};
                hash: {};
                merkelize: {};
                chunk: {};
                assertEqualsStrict: {};
                concatTransposed: {};
                concatByHashing: {};
                push: {};
                growMaxLengthBy: {};
                normalize: {};
                assertNormalized: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                __dummyMask?: boolean[] | null | undefined;
                _indexMask: {};
                _dummyMask: {};
                isDummyIndex: {};
                toValue: {};
            };
            readonly maxLength: number;
            readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
                toString(): string;
                concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
                assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | StaticArray<UInt8, {
                    value: bigint;
                }> | (UInt8 | {
                    value: bigint;
                })[] | string): void;
                splitAt(index: number): [DynamicString, DynamicString];
                slice(start: number | UInt32): DynamicString;
                reverse(): DynamicString;
                assertContains(substring: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | string, message?: string): import("o1js").Field;
                growMaxLengthTo(maxLength: number): DynamicString;
                array: UInt8[];
                length: import("o1js").Field;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32): void;
                get(i: UInt32): UInt8;
                getOption(i: UInt32): Option<UInt8>;
                getOrUnconstrained(i: import("o1js").Field): UInt8;
                set(i: UInt32, value: UInt8): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
                map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
                forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
                hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
                merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
                chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                    value: bigint;
                }>, {
                    value: bigint;
                }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>];
                assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): void;
                concatTransposed(other: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                push(value: UInt8): void;
                growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                normalize(): void;
                assertNormalized(): void;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                __dummyMask?: import("o1js").Bool[];
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
                toValue(): {
                    value: bigint;
                }[];
            }, string>;
            from: {};
        };
        publicKey: {
            prototype: {
                fields: string[];
                value: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                modMul: {};
                modSquare: {};
                toBigint: {};
            };
            from: {};
            unsafeFromLimbs: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
        signature: {
            prototype: {
                fields: string[];
                value: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                modMul: {};
                modSquare: {};
                toBigint: {};
            };
            from: {};
            unsafeFromLimbs: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
    };
    fromJSON: (x: {
        header: {
            prototype: {
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes: {};
                toString: {};
                concat: {};
                assertEquals: {};
                splitAt: {};
                slice: {};
                reverse: {};
                assertContains: {};
                growMaxLengthTo: {};
                array: {
                    add: {};
                    sub: {};
                    mul: {};
                    div: {};
                    mod: {};
                    divMod: {};
                    lessThanOrEqual: {};
                    lessThan: {};
                    assertLessThan: {};
                    assertLessThanOrEqual: {};
                    greaterThan: {};
                    greaterThanOrEqual: {};
                    assertGreaterThan: {};
                    assertGreaterThanOrEqual: {};
                    assertEquals: {};
                    toString: {};
                    toNumber: {};
                    toBigInt: {};
                    toUInt32: {};
                    toUInt64: {};
                    value: string;
                }[];
                length: string;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                forEachReverse: {};
                reduce: {};
                hash: {};
                merkelize: {};
                chunk: {};
                assertEqualsStrict: {};
                concatTransposed: {};
                concatByHashing: {};
                push: {};
                growMaxLengthBy: {};
                normalize: {};
                assertNormalized: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                __dummyMask?: boolean[] | null | undefined;
                _indexMask: {};
                _dummyMask: {};
                isDummyIndex: {};
                toValue: {};
            };
            readonly maxLength: number;
            readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
                toString(): string;
                concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
                assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | StaticArray<UInt8, {
                    value: bigint;
                }> | (UInt8 | {
                    value: bigint;
                })[] | string): void;
                splitAt(index: number): [DynamicString, DynamicString];
                slice(start: number | UInt32): DynamicString;
                reverse(): DynamicString;
                assertContains(substring: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | string, message?: string): import("o1js").Field;
                growMaxLengthTo(maxLength: number): DynamicString;
                array: UInt8[];
                length: import("o1js").Field;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32): void;
                get(i: UInt32): UInt8;
                getOption(i: UInt32): Option<UInt8>;
                getOrUnconstrained(i: import("o1js").Field): UInt8;
                set(i: UInt32, value: UInt8): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
                map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
                forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
                hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
                merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
                chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                    value: bigint;
                }>, {
                    value: bigint;
                }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>];
                assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): void;
                concatTransposed(other: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                push(value: UInt8): void;
                growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                normalize(): void;
                assertNormalized(): void;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                __dummyMask?: import("o1js").Bool[];
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
                toValue(): {
                    value: bigint;
                }[];
            }, string>;
            from: {};
        };
        body: {
            prototype: {
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes: {};
                toString: {};
                concat: {};
                assertEquals: {};
                splitAt: {};
                slice: {};
                reverse: {};
                assertContains: {};
                growMaxLengthTo: {};
                array: {
                    add: {};
                    sub: {};
                    mul: {};
                    div: {};
                    mod: {};
                    divMod: {};
                    lessThanOrEqual: {};
                    lessThan: {};
                    assertLessThan: {};
                    assertLessThanOrEqual: {};
                    greaterThan: {};
                    greaterThanOrEqual: {};
                    assertGreaterThan: {};
                    assertGreaterThanOrEqual: {};
                    assertEquals: {};
                    toString: {};
                    toNumber: {};
                    toBigInt: {};
                    toUInt32: {};
                    toUInt64: {};
                    value: string;
                }[];
                length: string;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                forEachReverse: {};
                reduce: {};
                hash: {};
                merkelize: {};
                chunk: {};
                assertEqualsStrict: {};
                concatTransposed: {};
                concatByHashing: {};
                push: {};
                growMaxLengthBy: {};
                normalize: {};
                assertNormalized: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                __dummyMask?: boolean[] | null | undefined;
                _indexMask: {};
                _dummyMask: {};
                isDummyIndex: {};
                toValue: {};
            };
            readonly maxLength: number;
            readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{
                readonly innerType: import("o1js").ProvableHashable<UInt8, {
                    value: bigint;
                }>;
                hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
                toString(): string;
                concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
                assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | StaticArray<UInt8, {
                    value: bigint;
                }> | (UInt8 | {
                    value: bigint;
                })[] | string): void;
                splitAt(index: number): [DynamicString, DynamicString];
                slice(start: number | UInt32): DynamicString;
                reverse(): DynamicString;
                assertContains(substring: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }> | string, message?: string): import("o1js").Field;
                growMaxLengthTo(maxLength: number): DynamicString;
                array: UInt8[];
                length: import("o1js").Field;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32): void;
                get(i: UInt32): UInt8;
                getOption(i: UInt32): Option<UInt8>;
                getOrUnconstrained(i: import("o1js").Field): UInt8;
                set(i: UInt32, value: UInt8): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
                map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
                forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
                reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
                hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
                merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
                chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                    value: bigint;
                }>, {
                    value: bigint;
                }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>];
                assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): void;
                concatTransposed(other: StaticArray<UInt8, {
                    value: bigint;
                }> | import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                push(value: UInt8): void;
                growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                    value: bigint;
                }>;
                normalize(): void;
                assertNormalized(): void;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                __dummyMask?: import("o1js").Bool[];
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
                toValue(): {
                    value: bigint;
                }[];
            }, string>;
            from: {};
        };
        publicKey: {
            prototype: {
                fields: string[];
                value: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                modMul: {};
                modSquare: {};
                toBigint: {};
            };
            from: {};
            unsafeFromLimbs: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
        signature: {
            prototype: {
                fields: string[];
                value: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                modMul: {};
                modSquare: {};
                toBigint: {};
            };
            from: {};
            unsafeFromLimbs: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
    }) => {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    };
    empty: () => {
        header: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        body: {
            readonly innerType: import("o1js").ProvableHashable<UInt8, {
                value: bigint;
            }>;
            hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
            toString(): string;
            concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString;
            assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | StaticArray<UInt8, {
                value: bigint;
            }> | (UInt8 | {
                value: bigint;
            })[] | string): void;
            splitAt(index: number): [DynamicString, DynamicString];
            slice(start: number | UInt32): DynamicString;
            reverse(): DynamicString;
            assertContains(substring: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }> | string, message?: string): import("o1js").Field;
            growMaxLengthTo(maxLength: number): DynamicString;
            array: UInt8[];
            length: import("o1js").Field;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32): void;
            get(i: UInt32): UInt8;
            getOption(i: UInt32): Option<UInt8>;
            getOrUnconstrained(i: import("o1js").Field): UInt8;
            set(i: UInt32, value: UInt8): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt8): void;
            map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>;
            forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void;
            reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S;
            hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>;
            chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, {
                value: bigint;
            }>, {
                value: bigint;
            }[]>, import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>];
            assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): void;
            concatTransposed(other: StaticArray<UInt8, {
                value: bigint;
            }> | import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            push(value: UInt8): void;
            growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, {
                value: bigint;
            }>;
            normalize(): void;
            assertNormalized(): void;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            __dummyMask?: import("o1js").Bool[];
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined;
            toValue(): {
                value: bigint;
            }[];
        };
        publicKey: Bigint2048;
        signature: Bigint2048;
    };
};
/**
 * A generic ZkProgram that hashes an arbitrary number of SHA256 blocks.
 */
declare let hashProgram: {
    name: string;
    maxProofsVerified(): Promise<0 | 1 | 2>;
    compile: (options?: {
        cache?: import("o1js").Cache;
        forceRecompile?: boolean;
        proofsEnabled?: boolean;
    }) => Promise<{
        verificationKey: {
            data: string;
            hash: import("o1js").Field;
        };
    }>;
    verify: (proof: Proof<MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>, {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>) => Promise<boolean>;
    digest: () => Promise<string>;
    analyzeMethods: () => Promise<{
        hashBase: {
            proofs: import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofClass[];
            rows: number;
            digest: string;
            gates: import("node_modules/o1js/dist/node/snarky.js").Gate[];
            publicInputSize: number;
            print(): void;
            summary(): Partial<Record<import("node_modules/o1js/dist/node/snarky.js").GateType | "Total rows", number>>;
        };
        hashRecursive: {
            proofs: import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofClass[];
            rows: number;
            digest: string;
            gates: import("node_modules/o1js/dist/node/snarky.js").Gate[];
            publicInputSize: number;
            print(): void;
            summary(): Partial<Record<import("node_modules/o1js/dist/node/snarky.js").GateType | "Total rows", number>>;
        };
    }>;
    publicInputType: import("o1js").ProvableHashable<MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>>;
    publicOutputType: Omit<import("o1js").ProvableHashable<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[]>, "fromValue"> & {
        fromValue: (value: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        } | (number | bigint | UInt32)[]) => {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    } & Omit<import("o1js").ProvablePure<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[]>, "fromValue">;
    privateInputTypes: {
        hashBase: [];
        hashRecursive: [];
    };
    auxiliaryOutputTypes: {
        hashBase: undefined;
        hashRecursive: undefined;
    };
    rawMethods: {
        hashBase: (publicInput: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>) => Promise<{
            publicOutput: {
                array: UInt32[];
                readonly innerType: Provable<UInt32, bigint>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): UInt32;
                getOption(i: UInt32 | number): Option<UInt32>;
                getOrUnconstrained(i: import("o1js").Field): UInt32;
                set(i: UInt32 | number, value: UInt32): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: UInt32, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): {
                                                        array: /*elided*/ any[];
                                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                        readonly length: number;
                                                        readonly maxLength: number;
                                                        assertIndexInRange(i: UInt32 | number): void;
                                                        get(i: UInt32 | number): /*elided*/ any;
                                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                        chunk(chunkSize: number): /*elided*/ any;
                                                        toReversed(): /*elided*/ any;
                                                        slice(start: number, end: number): /*elided*/ any;
                                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                        _indicesInRange: Set<import("o1js").Field>;
                                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                        toValue(): bigint[][][][][][][][][][][];
                                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                    };
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[];
                [Symbol.iterator](): Generator<UInt32, void, unknown>;
            };
        }>;
        hashRecursive: (publicInput: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>) => Promise<{
            publicOutput: {
                array: UInt32[];
                readonly innerType: Provable<UInt32, bigint>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): UInt32;
                getOption(i: UInt32 | number): Option<UInt32>;
                getOrUnconstrained(i: import("o1js").Field): UInt32;
                set(i: UInt32 | number, value: UInt32): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: UInt32, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): {
                                                        array: /*elided*/ any[];
                                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                        readonly length: number;
                                                        readonly maxLength: number;
                                                        assertIndexInRange(i: UInt32 | number): void;
                                                        get(i: UInt32 | number): /*elided*/ any;
                                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                        chunk(chunkSize: number): /*elided*/ any;
                                                        toReversed(): /*elided*/ any;
                                                        slice(start: number, end: number): /*elided*/ any;
                                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                        _indicesInRange: Set<import("o1js").Field>;
                                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                        toValue(): bigint[][][][][][][][][][][];
                                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                    };
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[];
                [Symbol.iterator](): Generator<UInt32, void, unknown>;
            };
        }>;
    };
    Proof: {
        new ({ proof, publicInput, publicOutput, maxProofsVerified, }: {
            proof: import("node_modules/o1js/dist/node/snarky.js").Pickles.Proof;
            publicInput: MerkleList<{
                array: UInt32[];
                readonly innerType: Provable<UInt32, bigint>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): UInt32;
                getOption(i: UInt32 | number): Option<UInt32>;
                getOrUnconstrained(i: import("o1js").Field): UInt32;
                set(i: UInt32 | number, value: UInt32): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: UInt32, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): {
                                                        array: /*elided*/ any[];
                                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                        readonly length: number;
                                                        readonly maxLength: number;
                                                        assertIndexInRange(i: UInt32 | number): void;
                                                        get(i: UInt32 | number): /*elided*/ any;
                                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                        chunk(chunkSize: number): /*elided*/ any;
                                                        toReversed(): /*elided*/ any;
                                                        slice(start: number, end: number): /*elided*/ any;
                                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                        _indicesInRange: Set<import("o1js").Field>;
                                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                        toValue(): bigint[][][][][][][][][][][];
                                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                    };
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[];
                [Symbol.iterator](): Generator<UInt32, void, unknown>;
            }>;
            publicOutput: {
                array: UInt32[];
                readonly innerType: Provable<UInt32, bigint>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): UInt32;
                getOption(i: UInt32 | number): Option<UInt32>;
                getOrUnconstrained(i: import("o1js").Field): UInt32;
                set(i: UInt32 | number, value: UInt32): void;
                setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: UInt32, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): {
                                                        array: /*elided*/ any[];
                                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                        readonly length: number;
                                                        readonly maxLength: number;
                                                        assertIndexInRange(i: UInt32 | number): void;
                                                        get(i: UInt32 | number): /*elided*/ any;
                                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                        chunk(chunkSize: number): /*elided*/ any;
                                                        toReversed(): /*elided*/ any;
                                                        slice(start: number, end: number): /*elided*/ any;
                                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                        _indicesInRange: Set<import("o1js").Field>;
                                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                        toValue(): bigint[][][][][][][][][][][];
                                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                    };
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[];
                [Symbol.iterator](): Generator<UInt32, void, unknown>;
            };
            maxProofsVerified: 0 | 1 | 2;
        }): Proof<MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>, {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        fromJSON<S extends import("node_modules/o1js/dist/node/lib/util/types.js").Subclass<typeof Proof>>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, publicOutput: publicOutputJson, }: import("o1js").JsonProof): Promise<Proof<import("o1js").InferProvable<S["publicInputType"]>, import("o1js").InferProvable<S["publicOutputType"]>>>;
        dummy<Input, OutPut>(publicInput: Input, publicOutput: OutPut, maxProofsVerified: 0 | 1 | 2, domainLog2?: number): Promise<Proof<Input, OutPut>>;
        readonly provable: {
            toFields: (value: Proof<any, any>) => import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
            toAuxiliary: (value?: Proof<any, any> | undefined) => any[];
            fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[], aux: any[]) => Proof<any, any>;
            sizeInFields(): number;
            check: (value: Proof<any, any>) => void;
            toValue: (x: Proof<any, any>) => import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofValue<any, any>;
            fromValue: (x: import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofValue<any, any> | Proof<any, any>) => Proof<any, any>;
            toCanonical?: ((x: Proof<any, any>) => Proof<any, any>) | undefined;
        };
        publicInputType: import("o1js").FlexibleProvable<any>;
        publicOutputType: import("o1js").FlexibleProvable<any>;
        tag: () => {
            name: string;
        };
        publicFields(value: import("o1js").ProofBase): {
            input: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
            output: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
        };
        _proofFromBase64(proofString: import("node_modules/o1js/dist/node/snarky.js").Base64ProofString, maxProofsVerified: 0 | 1 | 2): unknown;
        _proofToBase64(proof: import("node_modules/o1js/dist/node/snarky.js").Pickles.Proof, maxProofsVerified: 0 | 1 | 2): string;
    };
    proofsEnabled: boolean;
    setProofsEnabled(proofsEnabled: boolean): void;
} & {
    hashBase: (publicInput: any) => Promise<{
        proof: Proof<MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>, {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        auxiliaryOutput: undefined;
    }>;
    hashRecursive: (publicInput: any) => Promise<{
        proof: Proof<MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>, {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        auxiliaryOutput: undefined;
    }>;
};
declare const HeaderAndBodyBlocks_base: (new (value: {
    headerBlocks: MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>;
    bodyBlocks: MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>;
}) => {
    headerBlocks: MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>;
    bodyBlocks: MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>;
}) & {
    _isStruct: true;
} & Provable<{
    headerBlocks: MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>;
    bodyBlocks: MerkleList<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }>;
}, {
    headerBlocks: any;
    bodyBlocks: any;
}> & {
    fromValue: (value: {
        headerBlocks: any;
        bodyBlocks: any;
    }) => {
        headerBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        bodyBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
    };
    toInput: (x: {
        headerBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        bodyBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
    }) => {
        fields?: import("o1js").Field[] | undefined;
        packed?: [import("o1js").Field, number][] | undefined;
    };
    toJSON: (x: {
        headerBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        bodyBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
    }) => {
        headerBlocks: {
            prototype: {
                hash: string;
                data: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                isEmpty: {};
                push: {};
                pushIf: {};
                popExn: {};
                pop: {};
                popOption: {};
                popIf: {};
                popIfUnsafe: {};
                clone: {};
                forEach: {};
                startIterating: {};
                startIteratingFromLast: {};
                toArrayUnconstrained: {};
                lengthUnconstrained: {};
                readonly Constructor: typeof MerkleList;
                nextHash: {};
                readonly innerProvable: import("o1js").ProvableHashable<T>;
            };
            popTail: {};
            create: {};
            _nextHash: {} | null;
            _emptyHash: string | null;
            _provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            _innerProvable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            readonly emptyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            empty: {};
            from: {};
            fromReverse: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
        bodyBlocks: {
            prototype: {
                hash: string;
                data: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                isEmpty: {};
                push: {};
                pushIf: {};
                popExn: {};
                pop: {};
                popOption: {};
                popIf: {};
                popIfUnsafe: {};
                clone: {};
                forEach: {};
                startIterating: {};
                startIteratingFromLast: {};
                toArrayUnconstrained: {};
                lengthUnconstrained: {};
                readonly Constructor: typeof MerkleList;
                nextHash: {};
                readonly innerProvable: import("o1js").ProvableHashable<T>;
            };
            popTail: {};
            create: {};
            _nextHash: {} | null;
            _emptyHash: string | null;
            _provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            _innerProvable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            readonly emptyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            empty: {};
            from: {};
            fromReverse: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
    };
    fromJSON: (x: {
        headerBlocks: {
            prototype: {
                hash: string;
                data: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                isEmpty: {};
                push: {};
                pushIf: {};
                popExn: {};
                pop: {};
                popOption: {};
                popIf: {};
                popIfUnsafe: {};
                clone: {};
                forEach: {};
                startIterating: {};
                startIteratingFromLast: {};
                toArrayUnconstrained: {};
                lengthUnconstrained: {};
                readonly Constructor: typeof MerkleList;
                nextHash: {};
                readonly innerProvable: import("o1js").ProvableHashable<T>;
            };
            popTail: {};
            create: {};
            _nextHash: {} | null;
            _emptyHash: string | null;
            _provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            _innerProvable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            readonly emptyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            empty: {};
            from: {};
            fromReverse: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
        bodyBlocks: {
            prototype: {
                hash: string;
                data: {
                    get: {};
                    set: {};
                    setTo: {};
                    updateAsProver: {};
                };
                isEmpty: {};
                push: {};
                pushIf: {};
                popExn: {};
                pop: {};
                popOption: {};
                popIf: {};
                popIfUnsafe: {};
                clone: {};
                forEach: {};
                startIterating: {};
                startIteratingFromLast: {};
                toArrayUnconstrained: {};
                lengthUnconstrained: {};
                readonly Constructor: typeof MerkleList;
                nextHash: {};
                readonly innerProvable: import("o1js").ProvableHashable<T>;
            };
            popTail: {};
            create: {};
            _nextHash: {} | null;
            _emptyHash: string | null;
            _provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            _innerProvable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            } | null;
            readonly emptyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
            empty: {};
            from: {};
            fromReverse: {};
            provable: {
                toFields: {};
                toAuxiliary: {};
                fromFields: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                fromValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
            };
        };
    }) => {
        headerBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        bodyBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
    };
    empty: () => {
        headerBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
        bodyBlocks: MerkleList<{
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        }>;
    };
};
declare class HeaderAndBodyBlocks extends HeaderAndBodyBlocks_base {
}
declare const HeaderAndBodyState_base: (new (value: {
    headerState: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    bodyState: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
}) => {
    headerState: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    bodyState: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
}) & {
    _isStruct: true;
} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
    headerState: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    bodyState: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): Option<UInt32>;
        getOrUnconstrained(i: import("o1js").Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): Option</*elided*/ any>;
            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
        _indicesInRange: Set<import("o1js").Field>;
        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
}, {
    headerState: bigint[];
    bodyState: bigint[];
}>, "fromFields"> & {
    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    };
} & {
    fromValue: (value: {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        } | (number | bigint | UInt32)[];
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        } | (number | bigint | UInt32)[];
    }) => {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    };
    toInput: (x: {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    }) => {
        fields?: import("o1js").Field[] | undefined;
        packed?: [import("o1js").Field, number][] | undefined;
    };
    toJSON: (x: {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    }) => {
        headerState: {
            prototype: {
                array: any[];
                readonly innerType: Provable<T, V>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                reduce: {};
                chunk: {};
                toReversed: {};
                slice: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indexMask: {};
                toValue: {};
                [Symbol.iterator]: {};
            };
            readonly length: number;
            from: {};
            provable: {
                fromFields: {};
                toFields: {};
                toAuxiliary: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
                fromValue: {};
            };
        };
        bodyState: {
            prototype: {
                array: any[];
                readonly innerType: Provable<T, V>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                reduce: {};
                chunk: {};
                toReversed: {};
                slice: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indexMask: {};
                toValue: {};
                [Symbol.iterator]: {};
            };
            readonly length: number;
            from: {};
            provable: {
                fromFields: {};
                toFields: {};
                toAuxiliary: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
                fromValue: {};
            };
        };
    };
    fromJSON: (x: {
        headerState: {
            prototype: {
                array: any[];
                readonly innerType: Provable<T, V>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                reduce: {};
                chunk: {};
                toReversed: {};
                slice: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indexMask: {};
                toValue: {};
                [Symbol.iterator]: {};
            };
            readonly length: number;
            from: {};
            provable: {
                fromFields: {};
                toFields: {};
                toAuxiliary: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
                fromValue: {};
            };
        };
        bodyState: {
            prototype: {
                array: any[];
                readonly innerType: Provable<T, V>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange: {};
                get: {};
                getOption: {};
                getOrUnconstrained: {};
                set: {};
                setOrDoNothing: {};
                map: {};
                forEach: {};
                reduce: {};
                chunk: {};
                toReversed: {};
                slice: {};
                _indexMasks: {
                    clear: {};
                    delete: {};
                    forEach: {};
                    get: {};
                    has: {};
                    set: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indicesInRange: {
                    add: {};
                    clear: {};
                    delete: {};
                    forEach: {};
                    has: {};
                    readonly size: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                    entries: {};
                    keys: {};
                    values: {};
                    union: {};
                    intersection: {};
                    difference: {};
                    symmetricDifference: {};
                    isSubsetOf: {};
                    isSupersetOf: {};
                    isDisjointFrom: {};
                    [Symbol.iterator]: {};
                    readonly [Symbol.toStringTag]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                        [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null)[] | {
                        [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
                    } | null;
                };
                _indexMask: {};
                toValue: {};
                [Symbol.iterator]: {};
            };
            readonly length: number;
            from: {};
            provable: {
                fromFields: {};
                toFields: {};
                toAuxiliary: {};
                sizeInFields: {};
                check: {};
                toValue: {};
                toCanonical?: {} | null | undefined;
                toInput: {};
                empty: {};
                fromValue: {};
            };
        };
    }) => {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    };
    empty: () => {
        headerState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
        bodyState: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): Option<UInt32>;
            getOrUnconstrained(i: import("o1js").Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: import("o1js").Field, value: UInt32): void;
            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): Option</*elided*/ any>;
                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): Option</*elided*/ any>;
                                        getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                        map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): Option</*elided*/ any>;
                                            getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                            map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): Option</*elided*/ any>;
                                                    getOrUnconstrained(i: import("o1js").Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: import("o1js").Field, value: /*elided*/ any): void;
                                                    map<S>(type: import("../o1js-missing.ts").ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<import("o1js").Field>;
                                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<import("o1js").Field>;
                                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<import("o1js").Field>;
                                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<import("o1js").Field>;
                                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<import("o1js").Field>;
                                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<import("o1js").Field>;
                                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<import("o1js").Field>;
                            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<import("o1js").Field>;
                        _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<import("o1js").Field>;
                    _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
                _indicesInRange: Set<import("o1js").Field>;
                _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>;
            _indicesInRange: Set<import("o1js").Field>;
            _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    };
};
declare class HeaderAndBodyState extends HeaderAndBodyState_base {
}
declare let headerAndBodyProgram: {
    name: string;
    maxProofsVerified(): Promise<0 | 1 | 2>;
    compile: (options?: {
        cache?: import("o1js").Cache;
        forceRecompile?: boolean;
        proofsEnabled?: boolean;
    }) => Promise<{
        verificationKey: {
            data: string;
            hash: import("o1js").Field;
        };
    }>;
    verify: (proof: Proof<HeaderAndBodyBlocks, HeaderAndBodyState>) => Promise<boolean>;
    digest: () => Promise<string>;
    analyzeMethods: () => Promise<{
        run: {
            proofs: import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofClass[];
            rows: number;
            digest: string;
            gates: import("node_modules/o1js/dist/node/snarky.js").Gate[];
            publicInputSize: number;
            print(): void;
            summary(): Partial<Record<import("node_modules/o1js/dist/node/snarky.js").GateType | "Total rows", number>>;
        };
    }>;
    publicInputType: typeof HeaderAndBodyBlocks;
    publicOutputType: typeof HeaderAndBodyState;
    privateInputTypes: {
        run: [];
    };
    auxiliaryOutputTypes: {
        run: undefined;
    };
    rawMethods: {
        run: (publicInput: HeaderAndBodyBlocks) => Promise<{
            publicOutput: HeaderAndBodyState;
        }>;
    };
    Proof: {
        new ({ proof, publicInput, publicOutput, maxProofsVerified, }: {
            proof: import("node_modules/o1js/dist/node/snarky.js").Pickles.Proof;
            publicInput: HeaderAndBodyBlocks;
            publicOutput: HeaderAndBodyState;
            maxProofsVerified: 0 | 1 | 2;
        }): Proof<HeaderAndBodyBlocks, HeaderAndBodyState>;
        fromJSON<S extends import("node_modules/o1js/dist/node/lib/util/types.js").Subclass<typeof Proof>>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, publicOutput: publicOutputJson, }: import("o1js").JsonProof): Promise<Proof<import("o1js").InferProvable<S["publicInputType"]>, import("o1js").InferProvable<S["publicOutputType"]>>>;
        dummy<Input, OutPut>(publicInput: Input, publicOutput: OutPut, maxProofsVerified: 0 | 1 | 2, domainLog2?: number): Promise<Proof<Input, OutPut>>;
        readonly provable: {
            toFields: (value: Proof<any, any>) => import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
            toAuxiliary: (value?: Proof<any, any> | undefined) => any[];
            fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[], aux: any[]) => Proof<any, any>;
            sizeInFields(): number;
            check: (value: Proof<any, any>) => void;
            toValue: (x: Proof<any, any>) => import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofValue<any, any>;
            fromValue: (x: import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofValue<any, any> | Proof<any, any>) => Proof<any, any>;
            toCanonical?: ((x: Proof<any, any>) => Proof<any, any>) | undefined;
        };
        publicInputType: import("o1js").FlexibleProvable<any>;
        publicOutputType: import("o1js").FlexibleProvable<any>;
        tag: () => {
            name: string;
        };
        publicFields(value: import("o1js").ProofBase): {
            input: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
            output: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
        };
        _proofFromBase64(proofString: import("node_modules/o1js/dist/node/snarky.js").Base64ProofString, maxProofsVerified: 0 | 1 | 2): unknown;
        _proofToBase64(proof: import("node_modules/o1js/dist/node/snarky.js").Pickles.Proof, maxProofsVerified: 0 | 1 | 2): string;
    };
    proofsEnabled: boolean;
    setProofsEnabled(proofsEnabled: boolean): void;
} & {
    run: (publicInput: HeaderAndBodyBlocks | {
        headerBlocks: any;
        bodyBlocks: any;
    }) => Promise<{
        proof: Proof<HeaderAndBodyBlocks, HeaderAndBodyState>;
        auxiliaryOutput: undefined;
    }>;
};
declare function verifyEmail(email: ProvableEmail, { proofsEnabled }?: {
    proofsEnabled?: boolean | undefined;
}): Promise<void>;
type ProvableEmailHeader = {
    /**
     * The email header in canonicalized form, i.e. the form that was signed.
     */
    header: string | DynamicString;
    /**
     * RSA public key that signed the email.
     */
    publicKey: Bigint2048;
    /**
     * The RSA signature of the email.
     */
    signature: Bigint2048;
};
/**
 * This is a variant of `verifyEmail()` which only verifies the header, not the body.
 */
declare function verifyEmailHeader(email: ProvableEmailHeader, { proofsEnabled }?: {
    proofsEnabled?: boolean | undefined;
}): Promise<void>;