npm - @cmts-dev/carmentis-sdk-core - Versions diffs - 1.2.31 → 1.2.33 - Mend

@cmts-dev/carmentis-sdk-core 1.2.31 → 1.2.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (100) hide show

package/dist/type/valibot/{stateProofs → proofs}/MicroblockProof.d.ts RENAMED Viewed

@@ -1,8 +1,8 @@
-import * as val from 'valibot';
-export declare const MicroblockProofSchema: val.ObjectSchema<{
-    readonly block: val.ObjectSchema<{
-        readonly height: val.NumberSchema<undefined>;
-        readonly vbRadixHash: val.InstanceSchema<{
+import * as v from 'valibot';
+export declare const MicroblockProofObjectSchema: v.ObjectSchema<{
+    readonly block: v.ObjectSchema<{
+        readonly height: v.NumberSchema<undefined>;
+        readonly vbRadixHash: v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -12,7 +12,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
-        readonly tokenRadixHash: val.InstanceSchema<{
+        readonly tokenRadixHash: v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -22,7 +22,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
-        readonly storageHash: val.InstanceSchema<{
+        readonly storageHash: v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -32,7 +32,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
-        readonly appHash: val.InstanceSchema<{
+        readonly appHash: v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -43,8 +43,8 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
     }, undefined>;
-    readonly microblock: val.ObjectSchema<{
-        readonly virtualBlockchainId: val.InstanceSchema<{
+    readonly microblock: v.ObjectSchema<{
+        readonly virtualBlockchainId: v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -54,8 +54,8 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
-        readonly height: val.NumberSchema<undefined>;
-        readonly hash: val.InstanceSchema<{
+        readonly height: v.NumberSchema<undefined>;
+        readonly hash: v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -66,21 +66,21 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
     }, undefined>;
-    readonly virtualBlockchain: val.ObjectSchema<{
-        readonly state: val.VariantSchema<"type", [val.ObjectSchema<{
-            readonly internalState: val.ObjectSchema<{
-                readonly signatureSchemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+    readonly virtualBlockchain: v.ObjectSchema<{
+        readonly state: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly internalState: v.ObjectSchema<{
+                readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                     readonly typeId: 3;
                 }>]>;
-                readonly publicKeyHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
+                readonly publicKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             }, undefined>;
-            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly lastMicroblockHash: val.InstanceSchema<{
+            readonly lastMicroblockHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -90,7 +90,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly merkleRootHash: val.InstanceSchema<{
+            readonly merkleRootHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -100,10 +100,10 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly type: val.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
-        }, undefined>, val.ObjectSchema<{
-            readonly internalState: val.ObjectSchema<{
-                readonly accountId: val.InstanceSchema<{
+            readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly internalState: v.ObjectSchema<{
+                readonly accountId: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -113,15 +113,15 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
-                readonly descriptionHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
+                readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             }, undefined>;
-            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly lastMicroblockHash: val.InstanceSchema<{
+            readonly lastMicroblockHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -131,7 +131,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly merkleRootHash: val.InstanceSchema<{
+            readonly merkleRootHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -141,10 +141,10 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly type: val.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
-        }, undefined>, val.ObjectSchema<{
-            readonly internalState: val.ObjectSchema<{
-                readonly organizationId: val.InstanceSchema<{
+            readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly internalState: v.ObjectSchema<{
+                readonly organizationId: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -154,19 +154,19 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
-                readonly cometbftPublicKeyDeclarationHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                readonly rpcEndpointHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                readonly lastKnownApprovalStatus: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+                readonly cometbftPublicKeyDeclarationHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly lastKnownApprovalStatus: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
                     readonly typeId: 4;
                 }>]>;
             }, undefined>;
-            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly lastMicroblockHash: val.InstanceSchema<{
+            readonly lastMicroblockHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -176,7 +176,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly merkleRootHash: val.InstanceSchema<{
+            readonly merkleRootHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -186,10 +186,10 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly type: val.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
-        }, undefined>, val.ObjectSchema<{
-            readonly internalState: val.ObjectSchema<{
-                readonly organizationId: val.InstanceSchema<{
+            readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly internalState: v.ObjectSchema<{
+                readonly organizationId: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -199,15 +199,15 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
-                readonly descriptionHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
+                readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             }, undefined>;
-            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly lastMicroblockHash: val.InstanceSchema<{
+            readonly lastMicroblockHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -217,7 +217,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly merkleRootHash: val.InstanceSchema<{
+            readonly merkleRootHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -227,10 +227,10 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly type: val.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
-        }, undefined>, val.ObjectSchema<{
-            readonly internalState: val.ObjectSchema<{
-                readonly allowedAdditionalWriters: val.ArraySchema<val.InstanceSchema<{
+            readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly internalState: v.ObjectSchema<{
+                readonly allowedAdditionalWriters: v.ArraySchema<v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -240,13 +240,13 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>, undefined>;
-                readonly allowedSignatureSchemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly allowedSignatureSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                     readonly typeId: 3;
                 }>]>, undefined>;
-                readonly allowedPkeSchemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly allowedPkeSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                     readonly typeId: 3;
                 }>]>, undefined>;
-                readonly applicationId: val.InstanceSchema<{
+                readonly applicationId: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -256,53 +256,53 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
-                readonly channels: val.ArraySchema<val.ObjectSchema<{
-                    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                readonly channels: v.ArraySchema<v.ObjectSchema<{
+                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
                         size: number;
                         readonly typeId: 2;
                     }>]>;
-                    readonly isPrivate: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+                    readonly isPrivate: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
                         readonly typeId: 4;
                     }>]>;
-                    readonly creatorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly creatorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                         readonly typeId: 3;
                     }>]>;
                 }, undefined>, undefined>;
-                readonly actors: val.ArraySchema<val.ObjectSchema<{
-                    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                readonly actors: v.ArraySchema<v.ObjectSchema<{
+                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
                         size: number;
                         readonly typeId: 2;
                     }>]>;
-                    readonly subscribed: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+                    readonly subscribed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
                         readonly typeId: 4;
                     }>]>;
-                    readonly signatureKeyHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly signatureKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                         readonly typeId: 3;
                     }>]>;
-                    readonly pkeKeyHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly pkeKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                         readonly typeId: 3;
                     }>]>;
-                    readonly sharedSecrets: val.ArraySchema<val.ObjectSchema<{
-                        readonly peerActorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly sharedSecrets: v.ArraySchema<v.ObjectSchema<{
+                        readonly peerActorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                             readonly typeId: 3;
                         }>]>;
-                        readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
+                        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
                     }, undefined>, undefined>;
-                    readonly invitations: val.ArraySchema<val.ObjectSchema<{
-                        readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly invitations: v.ArraySchema<v.ObjectSchema<{
+                        readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                             readonly typeId: 3;
                         }>]>;
-                        readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
+                        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
                     }, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;
-            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly lastMicroblockHash: val.InstanceSchema<{
+            readonly lastMicroblockHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -312,7 +312,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly merkleRootHash: val.InstanceSchema<{
+            readonly merkleRootHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -322,10 +322,10 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly type: val.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
-        }, undefined>, val.ObjectSchema<{
-            readonly internalState: val.ObjectSchema<{
-                readonly organizationId: val.InstanceSchema<{
+            readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly internalState: v.ObjectSchema<{
+                readonly organizationId: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -335,73 +335,73 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
-                readonly currentProtocolVariables: val.ObjectSchema<{
-                    readonly protocolVersionName: val.StringSchema<undefined>;
-                    readonly protocolVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly feesCalculationVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly fixedGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                    readonly secp256k1SignatureGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                    readonly mlDsa65SignatureGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                    readonly pkmsSecp256k1SignatureGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                    readonly globalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly applicationLedgerInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly applicationInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly organizationInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly validatorNodeInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly accountInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly protocolInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly minimumNodeStakingAmountInAtomics: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly maximumNodeStakingAmountInAtomics: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly unstakingDelayInDays: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                    readonly maxBlockSizeInBytes: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly retentionPolicy: val.ArraySchema<val.ObjectSchema<{
-                        readonly retentionRatio: val.NumberSchema<undefined>;
-                        readonly maximumNumberOfDays: val.NumberSchema<undefined>;
-                        readonly dayDivisor: val.NumberSchema<undefined>;
+                readonly currentProtocolVariables: v.ObjectSchema<{
+                    readonly protocolVersionName: v.StringSchema<undefined>;
+                    readonly protocolVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly feesCalculationVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly fixedGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly secp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly mlDsa65SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly pkmsSecp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly globalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly applicationLedgerInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly applicationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly organizationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly validatorNodeInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly accountInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly protocolInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly minimumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly maximumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly unstakingDelayInDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly maxBlockSizeInBytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly retentionPolicy: v.ArraySchema<v.ObjectSchema<{
+                        readonly retentionRatio: v.NumberSchema<undefined>;
+                        readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+                        readonly dayDivisor: v.NumberSchema<undefined>;
                     }, undefined>, undefined>;
-                    readonly abciVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                    readonly maxMicroblocksPerBlock: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
+                    readonly abciVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    readonly maxMicroblocksPerBlock: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
                 }, undefined>;
-                readonly protocolUpdates: val.ArraySchema<val.ObjectSchema<{
-                    readonly protocolVersion: val.NumberSchema<undefined>;
-                    readonly protocolVersionName: val.StringSchema<undefined>;
-                    readonly changeLog: val.StringSchema<undefined>;
-                    readonly protocolVariables: val.ObjectSchema<{
-                        readonly protocolVersionName: val.StringSchema<undefined>;
-                        readonly protocolVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly feesCalculationVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly fixedGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                        readonly secp256k1SignatureGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                        readonly mlDsa65SignatureGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                        readonly pkmsSecp256k1SignatureGasCost: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                        readonly globalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly applicationLedgerInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly applicationInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly organizationInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly validatorNodeInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly accountInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly protocolInternalStateUpdaterVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly minimumNodeStakingAmountInAtomics: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly maximumNodeStakingAmountInAtomics: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly unstakingDelayInDays: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>]>;
-                        readonly maxBlockSizeInBytes: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly retentionPolicy: val.ArraySchema<val.ObjectSchema<{
-                            readonly retentionRatio: val.NumberSchema<undefined>;
-                            readonly maximumNumberOfDays: val.NumberSchema<undefined>;
-                            readonly dayDivisor: val.NumberSchema<undefined>;
+                readonly protocolUpdates: v.ArraySchema<v.ObjectSchema<{
+                    readonly protocolVersion: v.NumberSchema<undefined>;
+                    readonly protocolVersionName: v.StringSchema<undefined>;
+                    readonly changeLog: v.StringSchema<undefined>;
+                    readonly protocolVariables: v.ObjectSchema<{
+                        readonly protocolVersionName: v.StringSchema<undefined>;
+                        readonly protocolVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly feesCalculationVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly fixedGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly secp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly mlDsa65SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly pkmsSecp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly globalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly applicationLedgerInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly applicationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly organizationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly validatorNodeInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly accountInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly protocolInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly minimumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly maximumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly unstakingDelayInDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly maxBlockSizeInBytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly retentionPolicy: v.ArraySchema<v.ObjectSchema<{
+                            readonly retentionRatio: v.NumberSchema<undefined>;
+                            readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+                            readonly dayDivisor: v.NumberSchema<undefined>;
                         }, undefined>, undefined>;
-                        readonly abciVersion: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
-                        readonly maxMicroblocksPerBlock: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 1, undefined>]>;
+                        readonly abciVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly maxMicroblocksPerBlock: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
                     }, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;
-            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+            readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                 readonly typeId: 3;
             }>]>;
-            readonly lastMicroblockHash: val.InstanceSchema<{
+            readonly lastMicroblockHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -411,7 +411,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly merkleRootHash: val.InstanceSchema<{
+            readonly merkleRootHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -421,9 +421,9 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly type: val.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
+            readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
         }, undefined>], undefined>;
-        readonly merkleWitnesses: val.ArraySchema<val.InstanceSchema<{
+        readonly merkleWitnesses: v.ArraySchema<v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -433,7 +433,7 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
             from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>, undefined>;
-        readonly radixProof: val.ArraySchema<val.InstanceSchema<{
+        readonly radixProof: v.ArraySchema<v.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
             readonly prototype: Uint8Array<ArrayBufferLike>;
             readonly BYTES_PER_ELEMENT: number;
@@ -445,5 +445,47 @@ export declare const MicroblockProofSchema: val.ObjectSchema<{
         }, undefined>, undefined>;
     }, undefined>;
 }, undefined>;
-export type MicroblockProof = val.InferOutput<typeof MicroblockProofSchema>;
+export type MicroblockProofObject = v.InferOutput<typeof MicroblockProofObjectSchema>;
+export declare const MicroblockProofEntrySchema: v.ObjectSchema<{
+    readonly block: v.ObjectSchema<{
+        readonly height: v.NumberSchema<undefined>;
+        readonly vbRadixHash: v.StringSchema<undefined>;
+        readonly tokenRadixHash: v.StringSchema<undefined>;
+        readonly storageHash: v.StringSchema<undefined>;
+        readonly appHash: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly microblock: v.ObjectSchema<{
+        readonly virtualBlockchainId: v.StringSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly hash: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly virtualBlockchain: v.ObjectSchema<{
+        readonly serializedState: v.StringSchema<undefined>;
+        readonly merkleWitnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly radixProof: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type MicroblockProofEntry = v.InferOutput<typeof MicroblockProofEntrySchema>;
+export declare const MicroblockProofSchema: v.ObjectSchema<{
+    readonly microblocks: v.ArraySchema<v.ObjectSchema<{
+        readonly block: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly vbRadixHash: v.StringSchema<undefined>;
+            readonly tokenRadixHash: v.StringSchema<undefined>;
+            readonly storageHash: v.StringSchema<undefined>;
+            readonly appHash: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly microblock: v.ObjectSchema<{
+            readonly virtualBlockchainId: v.StringSchema<undefined>;
+            readonly height: v.NumberSchema<undefined>;
+            readonly hash: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly virtualBlockchain: v.ObjectSchema<{
+            readonly serializedState: v.StringSchema<undefined>;
+            readonly merkleWitnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly radixProof: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type MicroblockProof = v.InferOutput<typeof MicroblockProofSchema>;
 //# sourceMappingURL=MicroblockProof.d.ts.map

package/dist/type/valibot/proofs/MicroblockProof.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"MicroblockProof.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/proofs/MicroblockProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAK7B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAYtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEtF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;aAYrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEpF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;aAEhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC"}