npm - @cmts-dev/carmentis-sdk-core - Versions diffs - 1.2.3 → 1.2.4 - Mend

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

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 (486) hide show

package/dist/type/valibot/provider/abci/AbciResponse.d.ts ADDED Viewed

@@ -0,0 +1,2884 @@
+import * as v from 'valibot';
+export declare enum AbciResponseType {
+    ERROR = 0,
+    CHAIN_INFORMATION = 2,
+    BLOCK_INFORMATION = 4,
+    BLOCK_CONTENT = 6,
+    VIRTUAL_BLOCKCHAIN_STATE = 8,
+    VIRTUAL_BLOCKCHAIN_UPDATE = 10,
+    MICROBLOCK_INFORMATION = 12,
+    MICROBLOCK_ANCHORING = 14,
+    MICROBLOCK_BODYS = 16,
+    ACCOUNT_STATE = 18,
+    ACCOUNT_HISTORY = 20,
+    ACCOUNT_BY_PUBLIC_KEY_HASH = 22,
+    VALIDATOR_NODE_BY_ADDRESS = 24,
+    OBJECT_LIST = 26,
+    GENESIS_SNAPSHOT = 28,
+    RAW_BLOCK_CONTENT = 30,
+    BLOCK_MODIFIED_ACCOUNTS = 32,
+    ACCOUNT_UPDATES = 34
+}
+export declare const ErrorAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ERROR, undefined>;
+    readonly error: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ChainInformationAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.CHAIN_INFORMATION, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastBlockTimestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly objectCounts: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>;
+export declare const BlockInformationAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_INFORMATION, undefined>;
+    readonly hash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly proposerAddress: 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 size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const BlockContentAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_CONTENT, undefined>;
+    readonly microblocks: v.ArraySchema<v.ObjectSchema<{
+        readonly hash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly vbId: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly vbType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly sectionCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const VirtualBlockchainStateAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.VIRTUAL_BLOCKCHAIN_STATE, undefined>;
+    readonly serializedVirtualBlockchainState: 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 declare const VirtualBlockchainUpdateAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.VIRTUAL_BLOCKCHAIN_UPDATE, undefined>;
+    readonly exists: v.BooleanSchema<undefined>;
+    readonly changed: v.BooleanSchema<undefined>;
+    readonly serializedVirtualBlockchainState: 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 serializedHeaders: v.ArraySchema<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 declare const MicroblockInformationAbciResponseSchema: v.ObjectSchema<{
+    readonly virtualBlockchainId: 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: 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 feesPayerAccount: 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>;
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_INFORMATION, undefined>;
+}, undefined>;
+export declare const MicroblockAnchoringAbciResponseSchema: v.ObjectSchema<{
+    readonly virtualBlockchainId: 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: 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 feesPayerAccount: 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>;
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_ANCHORING, undefined>;
+}, undefined>;
+export declare const MicroblockBodyItemSchema: v.ObjectSchema<{
+    readonly microblockHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly microblockBody: v.ObjectSchema<{
+        readonly sections: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+            readonly tag: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly signature: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
+            readonly signature: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
+            readonly allowedWriterAccountId: 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.ObjectWithRestSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.CUSTOM, undefined>;
+        }, v.UnknownSchema, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_CREATION, undefined>;
+            readonly organizationId: 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 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.NumberSchema<undefined>;
+                readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                readonly maxBlockSizeInBytes: v.NumberSchema<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: v.NumberSchema<undefined>;
+            }, undefined>;
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_UPDATE, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_VARIABLES, undefined>;
+            readonly protocolVariables: v.AnySchema;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
+            readonly publicKey: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
+            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_CREATION, undefined>;
+            readonly sellerAccount: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TRANSFER, undefined>;
+            readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
+            readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly cliffDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly vestingDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
+            readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly escrowIdentifier: 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 agentAccount: 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 durationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_SETTLEMENT, undefined>;
+            readonly escrowIdentifier: 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 confirmed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                readonly typeId: 4;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_STAKE, undefined>;
+            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly objectType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly objectIdentifier: 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<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_UNSTAKE, undefined>;
+            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly objectType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly objectIdentifier: 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<import("../../blockchain/section/SectionType").SectionType.VN_CREATION, undefined>;
+            readonly organizationId: 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<import("../../blockchain/section/SectionType").SectionType.VN_COMETBFT_PUBLIC_KEY_DECLARATION, undefined>;
+            readonly cometPublicKeyType: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly cometPublicKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_RPC_ENDPOINT, undefined>;
+            readonly rpcEndpoint: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_APPROVAL, undefined>;
+            readonly status: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                readonly typeId: 4;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_SLASHING_CANCELLATION, undefined>;
+            readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ORG_CREATION, undefined>;
+            readonly accountId: 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<import("../../blockchain/section/SectionType").SectionType.ORG_DESCRIPTION, undefined>;
+            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 city: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly countryCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly website: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly misc: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_CREATION, undefined>;
+            readonly organizationId: 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<import("../../blockchain/section/SectionType").SectionType.APP_DESCRIPTION, undefined>;
+            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 logoUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly homepageUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly misc: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ALLOWED_SIG_SCHEMES, undefined>;
+            readonly schemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ALLOWED_PKE_SCHEMES, undefined>;
+            readonly schemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CREATION, undefined>;
+            readonly applicationId: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_CREATION, undefined>;
+            readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CHANNEL_CREATION, undefined>;
+            readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly isPrivate: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                readonly typeId: 4;
+            }>]>;
+            readonly creatorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_SHARED_SECRET, undefined>;
+            readonly hostId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly guestId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly encryptedSharedKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CHANNEL_INVITATION, undefined>;
+            readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly hostId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly guestId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly encryptedChannelKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
+            readonly actorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly organizationId: 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 signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+            readonly signaturePublicKey: 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 pkeSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+            readonly pkePublicKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
+            readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            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>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
+            readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly merkleRootHash: 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 encryptedData: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_AUTHOR, undefined>;
+            readonly authorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
+            readonly endorserId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const MicroblockBodysAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_BODYS, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly microblockHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly microblockBody: v.ObjectSchema<{
+            readonly sections: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+                readonly tag: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly signature: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
+                readonly signature: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
+                readonly allowedWriterAccountId: 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.ObjectWithRestSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.CUSTOM, undefined>;
+            }, v.UnknownSchema, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_CREATION, undefined>;
+                readonly organizationId: 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 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.NumberSchema<undefined>;
+                    readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                    readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                    readonly maxBlockSizeInBytes: v.NumberSchema<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: v.NumberSchema<undefined>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_UPDATE, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_VARIABLES, undefined>;
+                readonly protocolVariables: v.AnySchema;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
+                readonly publicKey: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_CREATION, undefined>;
+                readonly sellerAccount: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly cliffDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly vestingDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly escrowIdentifier: 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 agentAccount: 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 durationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_SETTLEMENT, undefined>;
+                readonly escrowIdentifier: 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 confirmed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_STAKE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectIdentifier: 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<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_UNSTAKE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectIdentifier: 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<import("../../blockchain/section/SectionType").SectionType.VN_CREATION, undefined>;
+                readonly organizationId: 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<import("../../blockchain/section/SectionType").SectionType.VN_COMETBFT_PUBLIC_KEY_DECLARATION, undefined>;
+                readonly cometPublicKeyType: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly cometPublicKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_RPC_ENDPOINT, undefined>;
+                readonly rpcEndpoint: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_APPROVAL, undefined>;
+                readonly status: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_SLASHING_CANCELLATION, undefined>;
+                readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ORG_CREATION, undefined>;
+                readonly accountId: 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<import("../../blockchain/section/SectionType").SectionType.ORG_DESCRIPTION, undefined>;
+                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 city: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly countryCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly website: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly misc: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_CREATION, undefined>;
+                readonly organizationId: 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<import("../../blockchain/section/SectionType").SectionType.APP_DESCRIPTION, undefined>;
+                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 logoUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly homepageUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly misc: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ALLOWED_SIG_SCHEMES, undefined>;
+                readonly schemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ALLOWED_PKE_SCHEMES, undefined>;
+                readonly schemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CREATION, undefined>;
+                readonly applicationId: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_CREATION, undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CHANNEL_CREATION, undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly isPrivate: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+                readonly creatorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_SHARED_SECRET, undefined>;
+                readonly hostId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly guestId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly encryptedSharedKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CHANNEL_INVITATION, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly hostId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly guestId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly encryptedChannelKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
+                readonly actorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly organizationId: 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 signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+                readonly signaturePublicKey: 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 pkeSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+                readonly pkePublicKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                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>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly merkleRootHash: 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 encryptedData: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_AUTHOR, undefined>;
+                readonly authorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
+                readonly endorserId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const AccountStateAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_STATE, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly balance: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastHistoryHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly escrowIdentifier: 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 fundEmitterAccountId: 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 transferAuthorizerAccountId: 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 startTimestamp: v.NumberSchema<undefined>;
+            readonly durationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+            readonly cliffDurationDays: v.NumberSchema<undefined>;
+            readonly vestingDurationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly validatorNodeId: 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 plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+            readonly slashed: v.BooleanSchema<undefined>;
+            readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>;
+export declare const AccountHistoryAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_HISTORY, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly previousHistoryHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly publicReference: v.StringSchema<undefined>;
+        readonly privateReference: v.StringSchema<undefined>;
+        readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly linkedAccount: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly chainReference: 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>;
+}, undefined>;
+export declare const AccountByPublicKeyHashAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_BY_PUBLIC_KEY_HASH, undefined>;
+    readonly accountHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+}, undefined>;
+export declare const ValidatorNodeByAddressAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.VALIDATOR_NODE_BY_ADDRESS, undefined>;
+    readonly validatorNodeHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+}, undefined>;
+export declare const ObjectListAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.OBJECT_LIST, undefined>;
+    readonly list: v.ArraySchema<v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>, undefined>;
+}, undefined>;
+export declare const GenesisSnapshotAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.GENESIS_SNAPSHOT, undefined>;
+    readonly base64EncodedChunks: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const RawBlockContentAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.RAW_BLOCK_CONTENT, undefined>;
+    readonly partIndex: v.NumberSchema<undefined>;
+    readonly numberOfParts: v.NumberSchema<undefined>;
+    readonly serializedMicroblocks: v.ArraySchema<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 declare const BlockModifiedAccountsAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_MODIFIED_ACCOUNTS, undefined>;
+    readonly modifiedAccounts: v.ArraySchema<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 declare const AccountUpdatesAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_UPDATES, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly accountHash: 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 currentState: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly balance: v.NumberSchema<undefined>;
+            readonly lastHistoryHash: 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 locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly escrowIdentifier: 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 fundEmitterAccountId: 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 transferAuthorizerAccountId: 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 startTimestamp: v.NumberSchema<undefined>;
+                    readonly durationDays: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                    readonly cliffDurationDays: v.NumberSchema<undefined>;
+                    readonly vestingDurationDays: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly validatorNodeId: 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 plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                    readonly slashed: v.BooleanSchema<undefined>;
+                    readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+        readonly historyUpdate: v.ArraySchema<v.ObjectSchema<{
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly previousHistoryHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+            readonly publicReference: v.StringSchema<undefined>;
+            readonly privateReference: v.StringSchema<undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly linkedAccount: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly chainReference: 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>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ERROR, undefined>;
+    readonly error: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.CHAIN_INFORMATION, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastBlockTimestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly objectCounts: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_INFORMATION, undefined>;
+    readonly hash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly proposerAddress: 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 size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_CONTENT, undefined>;
+    readonly microblocks: v.ArraySchema<v.ObjectSchema<{
+        readonly hash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly vbId: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly vbType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly sectionCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.RAW_BLOCK_CONTENT, undefined>;
+    readonly partIndex: v.NumberSchema<undefined>;
+    readonly numberOfParts: v.NumberSchema<undefined>;
+    readonly serializedMicroblocks: v.ArraySchema<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>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.VIRTUAL_BLOCKCHAIN_STATE, undefined>;
+    readonly serializedVirtualBlockchainState: 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 responseType: v.LiteralSchema<AbciResponseType.VIRTUAL_BLOCKCHAIN_UPDATE, undefined>;
+    readonly exists: v.BooleanSchema<undefined>;
+    readonly changed: v.BooleanSchema<undefined>;
+    readonly serializedVirtualBlockchainState: 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 serializedHeaders: v.ArraySchema<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>, v.ObjectSchema<{
+    readonly virtualBlockchainId: 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: 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 feesPayerAccount: 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>;
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_INFORMATION, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly virtualBlockchainId: 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: 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 feesPayerAccount: 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>;
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_ANCHORING, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_BODYS, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly microblockHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly microblockBody: v.ObjectSchema<{
+            readonly sections: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+                readonly tag: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly signature: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
+                readonly signature: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
+                readonly allowedWriterAccountId: 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.ObjectWithRestSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.CUSTOM, undefined>;
+            }, v.UnknownSchema, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_CREATION, undefined>;
+                readonly organizationId: 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 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.NumberSchema<undefined>;
+                    readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                    readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                    readonly maxBlockSizeInBytes: v.NumberSchema<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: v.NumberSchema<undefined>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_UPDATE, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_VARIABLES, undefined>;
+                readonly protocolVariables: v.AnySchema;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
+                readonly publicKey: 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 schemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_CREATION, undefined>;
+                readonly sellerAccount: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly cliffDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly vestingDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly escrowIdentifier: 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 agentAccount: 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 durationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_SETTLEMENT, undefined>;
+                readonly escrowIdentifier: 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 confirmed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_STAKE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectIdentifier: 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<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_UNSTAKE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly objectIdentifier: 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<import("../../blockchain/section/SectionType").SectionType.VN_CREATION, undefined>;
+                readonly organizationId: 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<import("../../blockchain/section/SectionType").SectionType.VN_COMETBFT_PUBLIC_KEY_DECLARATION, undefined>;
+                readonly cometPublicKeyType: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly cometPublicKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_RPC_ENDPOINT, undefined>;
+                readonly rpcEndpoint: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_APPROVAL, undefined>;
+                readonly status: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.VN_SLASHING_CANCELLATION, undefined>;
+                readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ORG_CREATION, undefined>;
+                readonly accountId: 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<import("../../blockchain/section/SectionType").SectionType.ORG_DESCRIPTION, undefined>;
+                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 city: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly countryCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly website: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly misc: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_CREATION, undefined>;
+                readonly organizationId: 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<import("../../blockchain/section/SectionType").SectionType.APP_DESCRIPTION, undefined>;
+                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 logoUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly homepageUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly misc: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ALLOWED_SIG_SCHEMES, undefined>;
+                readonly schemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ALLOWED_PKE_SCHEMES, undefined>;
+                readonly schemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CREATION, undefined>;
+                readonly applicationId: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_CREATION, undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CHANNEL_CREATION, undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly isPrivate: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+                readonly creatorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_SHARED_SECRET, undefined>;
+                readonly hostId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly guestId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly encryptedSharedKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_CHANNEL_INVITATION, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly hostId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly guestId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly encryptedChannelKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
+                readonly actorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly organizationId: 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 signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+                readonly signaturePublicKey: 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 pkeSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+                readonly pkePublicKey: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                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>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly merkleRootHash: 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 encryptedData: 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<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_AUTHOR, undefined>;
+                readonly authorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
+                readonly endorserId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_STATE, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly balance: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastHistoryHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly escrowIdentifier: 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 fundEmitterAccountId: 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 transferAuthorizerAccountId: 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 startTimestamp: v.NumberSchema<undefined>;
+            readonly durationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+            readonly cliffDurationDays: v.NumberSchema<undefined>;
+            readonly vestingDurationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly validatorNodeId: 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 plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+            readonly slashed: v.BooleanSchema<undefined>;
+            readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_HISTORY, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly previousHistoryHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly publicReference: v.StringSchema<undefined>;
+        readonly privateReference: v.StringSchema<undefined>;
+        readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly linkedAccount: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly chainReference: 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>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_BY_PUBLIC_KEY_HASH, undefined>;
+    readonly accountHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.VALIDATOR_NODE_BY_ADDRESS, undefined>;
+    readonly validatorNodeHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.OBJECT_LIST, undefined>;
+    readonly list: v.ArraySchema<v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.GENESIS_SNAPSHOT, undefined>;
+    readonly base64EncodedChunks: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_MODIFIED_ACCOUNTS, undefined>;
+    readonly modifiedAccounts: v.ArraySchema<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>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_UPDATES, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly accountHash: 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 currentState: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly balance: v.NumberSchema<undefined>;
+            readonly lastHistoryHash: 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 locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly escrowIdentifier: 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 fundEmitterAccountId: 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 transferAuthorizerAccountId: 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 startTimestamp: v.NumberSchema<undefined>;
+                    readonly durationDays: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                    readonly cliffDurationDays: v.NumberSchema<undefined>;
+                    readonly vestingDurationDays: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly validatorNodeId: 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 plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                    readonly slashed: v.BooleanSchema<undefined>;
+                    readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+        readonly historyUpdate: v.ArraySchema<v.ObjectSchema<{
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly previousHistoryHash: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+            readonly publicReference: v.StringSchema<undefined>;
+            readonly privateReference: v.StringSchema<undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly linkedAccount: v.SchemaWithPipe<readonly [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>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly chainReference: 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>;
+    }, undefined>, undefined>;
+}, undefined>], undefined>;
+export type AbciResponse = v.InferOutput<typeof AbciResponseSchema>;
+export type ErrorAbciResponse = v.InferOutput<typeof ErrorAbciResponseSchema>;
+export type ChainInformationAbciResponse = v.InferOutput<typeof ChainInformationAbciResponseSchema>;
+export type BlockInformationAbciResponse = v.InferOutput<typeof BlockInformationAbciResponseSchema>;
+export type BlockContentAbciResponse = v.InferOutput<typeof BlockContentAbciResponseSchema>;
+export type RawBlockContentAbciResponse = v.InferOutput<typeof RawBlockContentAbciResponseSchema>;
+export type VirtualBlockchainStateAbciResponse = v.InferOutput<typeof VirtualBlockchainStateAbciResponseSchema>;
+export type VirtualBlockchainUpdateAbciResponse = v.InferOutput<typeof VirtualBlockchainUpdateAbciResponseSchema>;
+export type MicroblockInformationAbciResponse = v.InferOutput<typeof MicroblockInformationAbciResponseSchema>;
+export type MicroblockAnchoringAbciResponse = v.InferOutput<typeof MicroblockAnchoringAbciResponseSchema>;
+export type MicroblockBodysAbciResponse = v.InferOutput<typeof MicroblockBodysAbciResponseSchema>;
+export type AccountStateAbciResponse = v.InferOutput<typeof AccountStateAbciResponseSchema>;
+export type AccountHistoryAbciResponse = v.InferOutput<typeof AccountHistoryAbciResponseSchema>;
+export type AccountByPublicKeyHashAbciResponse = v.InferOutput<typeof AccountByPublicKeyHashAbciResponseSchema>;
+export type ValidatorNodeByAddressAbciResponse = v.InferOutput<typeof ValidatorNodeByAddressAbciResponseSchema>;
+export type ObjectListAbciResponse = v.InferOutput<typeof ObjectListAbciResponseSchema>;
+export type GenesisSnapshotAbciResponse = v.InferOutput<typeof GenesisSnapshotAbciResponseSchema>;
+export type BlockModifiedAccountsAbciResponse = v.InferOutput<typeof BlockModifiedAccountsAbciResponseSchema>;
+export type AccountUpdatesAbciResponse = v.InferOutput<typeof AccountUpdatesAbciResponseSchema>;
+//# sourceMappingURL=AbciResponse.d.ts.map