@cmts-dev/carmentis-sdk-core 1.2.3 → 1.2.4

package/dist/records/types.d.ts

@@ -0,0 +1,615 @@
+import * as v from 'valibot';
+export type JsonData = string | number | boolean | null | JsonData[] | {
+    [key: string]: JsonData;
+};
+export declare const JsonSchema: v.GenericSchema<JsonData>;
+export type Json = v.InferOutput<typeof JsonSchema>;
+declare const PathSchema: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+export type Path = v.InferOutput<typeof PathSchema>;
+declare const MaskPartSchema: v.ObjectSchema<{
+    readonly start: v.NumberSchema<undefined>;
+    readonly end: v.NumberSchema<undefined>;
+    readonly replacement: v.StringSchema<undefined>;
+}, undefined>;
+export type MaskPart = v.InferOutput<typeof MaskPartSchema>;
+export declare enum TransformationTypeEnum {
+    None = 0,
+    Hashable = 1,
+    Maskable = 2
+}
+export declare enum TypeEnum {
+    String = 0,
+    Number = 1,
+    Boolean = 2,
+    Null = 3,
+    Array = 4,
+    Object = 5
+}
+declare let ItemSchema: v.GenericSchema<any>;
+declare const StringItemSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<TypeEnum.String, undefined>;
+    readonly value: v.StringSchema<undefined>;
+    readonly transformation: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.None, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.Hashable, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.Maskable, undefined>;
+        readonly visibleParts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly hiddenParts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>], undefined>;
+    readonly channelId: v.NumberSchema<undefined>;
+}, undefined>;
+export type StringItem = v.InferOutput<typeof StringItemSchema>;
+declare const NumberItemSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<TypeEnum.Number, undefined>;
+    readonly value: v.NumberSchema<undefined>;
+    readonly channelId: v.NumberSchema<undefined>;
+}, undefined>;
+export type NumberItem = v.InferOutput<typeof NumberItemSchema>;
+declare const BooleanItemSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<TypeEnum.Boolean, undefined>;
+    readonly value: v.BooleanSchema<undefined>;
+    readonly channelId: v.NumberSchema<undefined>;
+}, undefined>;
+export type BooleanItem = v.InferOutput<typeof BooleanItemSchema>;
+declare const NullItemSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<TypeEnum.Null, undefined>;
+    readonly value: v.NullSchema<undefined>;
+    readonly channelId: v.NumberSchema<undefined>;
+}, undefined>;
+export type NullItem = v.InferOutput<typeof NullItemSchema>;
+export type Item = v.InferOutput<typeof ItemSchema>;
+declare const PrimitiveValueSchema: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+export type PrimitiveValue = v.InferOutput<typeof PrimitiveValueSchema>;
+export type FlatItem = {
+    path: Path;
+    item: Item;
+};
+export declare const OnChainChannelSchema: v.ObjectSchema<{
+    readonly pepper: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly data: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type OnChainChannel = v.InferOutput<typeof OnChainChannelSchema>;
+export declare const OnChainItemSchema: v.ObjectSchema<{
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+    readonly transformation: v.OptionalSchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.None, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.Hashable, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.Maskable, undefined>;
+        readonly visibleParts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly hiddenParts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>;
+export type OnChainItem = v.InferOutput<typeof OnChainItemSchema>;
+export declare const OnChainItemListSchema: v.ArraySchema<v.ObjectSchema<{
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+    readonly transformation: v.OptionalSchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.None, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.Hashable, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<TransformationTypeEnum.Maskable, undefined>;
+        readonly visibleParts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly hiddenParts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>, undefined>;
+export declare enum MerkleLeafTypeEnum {
+    Public = 0,
+    Plain = 1,
+    HashableFromValue = 2,
+    Hashable = 3,
+    MaskableFromAllParts = 4,
+    MaskableFromVisibleParts = 5,
+    Maskable = 6
+}
+declare const MerkleLeafPublicSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Public, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+export type MerkleLeafPublic = v.InferOutput<typeof MerkleLeafPublicSchema>;
+declare const MerkleLeafPlainSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Plain, undefined>;
+    readonly salt: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+export type MerkleLeafPlain = v.InferOutput<typeof MerkleLeafPlainSchema>;
+declare const MerkleLeafHashableSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Hashable, undefined>;
+    readonly salt: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly hash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type MerkleLeafHashable = v.InferOutput<typeof MerkleLeafHashableSchema>;
+declare const MerkleLeafMaskablePartsSchema: v.ObjectSchema<{
+    readonly salt: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type MerkleLeafMaskableParts = v.InferOutput<typeof MerkleLeafMaskablePartsSchema>;
+declare const MerkleLeafMaskableSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Maskable, undefined>;
+    readonly visibleHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly hiddenHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type MerkleLeafMaskable = v.InferOutput<typeof MerkleLeafMaskableSchema>;
+declare const MerkleLeafDataSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Public, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Plain, undefined>;
+    readonly salt: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.HashableFromValue, undefined>;
+    readonly salt: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Hashable, undefined>;
+    readonly salt: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly hash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.MaskableFromAllParts, undefined>;
+    readonly visible: v.ObjectSchema<{
+        readonly salt: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly hidden: v.ObjectSchema<{
+        readonly salt: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.MaskableFromVisibleParts, undefined>;
+    readonly visible: v.ObjectSchema<{
+        readonly salt: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly hiddenHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<MerkleLeafTypeEnum.Maskable, undefined>;
+    readonly visibleHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly hiddenHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>], undefined>;
+export type MerkleLeafData = v.InferOutput<typeof MerkleLeafDataSchema>;
+export type MerkleLeafCommitment = MerkleLeafPublic | MerkleLeafPlain | MerkleLeafHashable | MerkleLeafMaskable;
+export declare enum ProofFieldTypeEnum {
+    Public = 0,
+    Plain = 1,
+    HashableAsPlain = 2,
+    HashableAsHash = 3,
+    MaskableAsAllParts = 4,
+    MaskableAsVisibleParts = 5
+}
+declare const ProofFieldSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly type: v.LiteralSchema<ProofFieldTypeEnum.Public, undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ProofFieldTypeEnum.Plain, undefined>;
+    readonly salt: v.StringSchema<undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly index: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsPlain, undefined>;
+    readonly salt: v.StringSchema<undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly index: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsHash, undefined>;
+    readonly salt: v.StringSchema<undefined>;
+    readonly hash: v.StringSchema<undefined>;
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly index: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsAllParts, undefined>;
+    readonly v_salt: v.StringSchema<undefined>;
+    readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly h_salt: v.StringSchema<undefined>;
+    readonly h_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly index: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsVisibleParts, undefined>;
+    readonly v_salt: v.StringSchema<undefined>;
+    readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly h_hash: v.StringSchema<undefined>;
+    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly index: v.NumberSchema<undefined>;
+}, undefined>], undefined>;
+export type ProofField = v.InferOutput<typeof ProofFieldSchema>;
+declare const ProofChannelSchema: v.ObjectSchema<{
+    readonly id: v.NumberSchema<undefined>;
+    readonly is_public: v.BooleanSchema<undefined>;
+    readonly n_leaves: v.NumberSchema<undefined>;
+    readonly fields: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly type: v.LiteralSchema<ProofFieldTypeEnum.Public, undefined>;
+        readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<ProofFieldTypeEnum.Plain, undefined>;
+        readonly salt: v.StringSchema<undefined>;
+        readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+        readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly index: v.NumberSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsPlain, undefined>;
+        readonly salt: v.StringSchema<undefined>;
+        readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+        readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly index: v.NumberSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsHash, undefined>;
+        readonly salt: v.StringSchema<undefined>;
+        readonly hash: v.StringSchema<undefined>;
+        readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly index: v.NumberSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsAllParts, undefined>;
+        readonly v_salt: v.StringSchema<undefined>;
+        readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly h_salt: v.StringSchema<undefined>;
+        readonly h_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly index: v.NumberSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsVisibleParts, undefined>;
+        readonly v_salt: v.StringSchema<undefined>;
+        readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly h_hash: v.StringSchema<undefined>;
+        readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly index: v.NumberSchema<undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly witnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type ProofChannel = v.InferOutput<typeof ProofChannelSchema>;
+declare const ProofMicroblockSchema: v.ObjectSchema<{
+    readonly height: v.NumberSchema<undefined>;
+    readonly channels: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.NumberSchema<undefined>;
+        readonly is_public: v.BooleanSchema<undefined>;
+        readonly n_leaves: v.NumberSchema<undefined>;
+        readonly fields: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly type: v.LiteralSchema<ProofFieldTypeEnum.Public, undefined>;
+            readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<ProofFieldTypeEnum.Plain, undefined>;
+            readonly salt: v.StringSchema<undefined>;
+            readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+            readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly index: v.NumberSchema<undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsPlain, undefined>;
+            readonly salt: v.StringSchema<undefined>;
+            readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+            readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly index: v.NumberSchema<undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsHash, undefined>;
+            readonly salt: v.StringSchema<undefined>;
+            readonly hash: v.StringSchema<undefined>;
+            readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly index: v.NumberSchema<undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsAllParts, undefined>;
+            readonly v_salt: v.StringSchema<undefined>;
+            readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly h_salt: v.StringSchema<undefined>;
+            readonly h_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly index: v.NumberSchema<undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsVisibleParts, undefined>;
+            readonly v_salt: v.StringSchema<undefined>;
+            readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly h_hash: v.StringSchema<undefined>;
+            readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly index: v.NumberSchema<undefined>;
+        }, undefined>], undefined>, undefined>;
+        readonly witnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type ProofMicroblock = v.InferOutput<typeof ProofMicroblockSchema>;
+declare const ProofVirtualBlockchainSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly microblocks: v.ArraySchema<v.ObjectSchema<{
+        readonly height: v.NumberSchema<undefined>;
+        readonly channels: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.NumberSchema<undefined>;
+            readonly is_public: v.BooleanSchema<undefined>;
+            readonly n_leaves: v.NumberSchema<undefined>;
+            readonly fields: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly type: v.LiteralSchema<ProofFieldTypeEnum.Public, undefined>;
+                readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<ProofFieldTypeEnum.Plain, undefined>;
+                readonly salt: v.StringSchema<undefined>;
+                readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+                readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly index: v.NumberSchema<undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsPlain, undefined>;
+                readonly salt: v.StringSchema<undefined>;
+                readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+                readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly index: v.NumberSchema<undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsHash, undefined>;
+                readonly salt: v.StringSchema<undefined>;
+                readonly hash: v.StringSchema<undefined>;
+                readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly index: v.NumberSchema<undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsAllParts, undefined>;
+                readonly v_salt: v.StringSchema<undefined>;
+                readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                readonly h_salt: v.StringSchema<undefined>;
+                readonly h_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly index: v.NumberSchema<undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsVisibleParts, undefined>;
+                readonly v_salt: v.StringSchema<undefined>;
+                readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                readonly h_hash: v.StringSchema<undefined>;
+                readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly index: v.NumberSchema<undefined>;
+            }, undefined>], undefined>, undefined>;
+            readonly witnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type ProofVirtualBlockchain = v.InferOutput<typeof ProofVirtualBlockchainSchema>;
+declare const ProofSignatureCommitmentSchema: v.ObjectSchema<{
+    readonly issued_at: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly digest_alg: v.OptionalSchema<v.PicklistSchema<["sha256"], undefined>, undefined>;
+    readonly digest_target: v.OptionalSchema<v.PicklistSchema<["cbor_proof"], undefined>, undefined>;
+    readonly digest: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type ProofSignatureCommitment = v.InferOutput<typeof ProofSignatureCommitmentSchema>;
+export declare const ProofWrapperSchema: v.ObjectSchema<{
+    readonly version: v.NumberSchema<undefined>;
+    readonly info: v.ObjectSchema<{
+        readonly title: v.StringSchema<undefined>;
+        readonly date: v.StringSchema<undefined>;
+        readonly description: v.StringSchema<undefined>;
+        readonly author: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly virtual_blockchains: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly microblocks: v.ArraySchema<v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly channels: v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.NumberSchema<undefined>;
+                readonly is_public: v.BooleanSchema<undefined>;
+                readonly n_leaves: v.NumberSchema<undefined>;
+                readonly fields: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                    readonly type: v.LiteralSchema<ProofFieldTypeEnum.Public, undefined>;
+                    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<ProofFieldTypeEnum.Plain, undefined>;
+                    readonly salt: v.StringSchema<undefined>;
+                    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+                    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                    readonly index: v.NumberSchema<undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsPlain, undefined>;
+                    readonly salt: v.StringSchema<undefined>;
+                    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+                    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                    readonly index: v.NumberSchema<undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<ProofFieldTypeEnum.HashableAsHash, undefined>;
+                    readonly salt: v.StringSchema<undefined>;
+                    readonly hash: v.StringSchema<undefined>;
+                    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                    readonly index: v.NumberSchema<undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsAllParts, undefined>;
+                    readonly v_salt: v.StringSchema<undefined>;
+                    readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly h_salt: v.StringSchema<undefined>;
+                    readonly h_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                    readonly index: v.NumberSchema<undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<ProofFieldTypeEnum.MaskableAsVisibleParts, undefined>;
+                    readonly v_salt: v.StringSchema<undefined>;
+                    readonly v_parts: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly h_hash: v.StringSchema<undefined>;
+                    readonly path: v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                    readonly index: v.NumberSchema<undefined>;
+                }, undefined>], undefined>, undefined>;
+                readonly witnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly signature: v.OptionalSchema<v.ObjectSchema<{
+        readonly commitment: v.ObjectSchema<{
+            readonly issued_at: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly digest_alg: v.OptionalSchema<v.PicklistSchema<["sha256"], undefined>, undefined>;
+            readonly digest_target: v.OptionalSchema<v.PicklistSchema<["cbor_proof"], undefined>, undefined>;
+            readonly digest: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly signer: v.StringSchema<undefined>;
+        readonly pubkey: v.StringSchema<undefined>;
+        readonly alg: v.PicklistSchema<["ecdsa-secp256k1", "ml-dsa-65"], undefined>;
+        readonly sig: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type ProofWrapper = v.InferOutput<typeof ProofWrapperSchema>;
+declare const TypedPrimitiveValueSchema: v.ObjectSchema<{
+    readonly disclosure: v.PicklistSchema<["plain", "hashed", "masked"], undefined>;
+    readonly value: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+export type TypedPrimitiveValue = v.InferOutput<typeof TypedPrimitiveValueSchema>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/records/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/records/types.ts"],"names":[],"mappings":"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"}

package/dist/records-old/Merklizer.d.ts

@@ -0,0 +1,12 @@
+export declare abstract class Merklizer {
+    nLeaves: any;
+    tree: any;
+    constructor();
+    abstract addHashableItem(item: any, info: any): void;
+    abstract addMaskableItem(item: any, info: any): void;
+    abstract addRawItem(item: any, info: any): void;
+    addItem(item: any, parents: any): void;
+    getLeafInfo(item: any, parents: any): Uint8Array<ArrayBuffer>;
+    getWitnesses(knownPositions: any): any;
+}
+//# sourceMappingURL=Merklizer.d.ts.map