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

package/dist/type/valibot/blockchain/section/sections.d.ts

@@ -0,0 +1,1201 @@
+import { SectionType } from './SectionType';
+import * as val from 'valibot';
+export declare const CustomSectionSchema: val.ObjectWithRestSchema<{
+    readonly type: val.LiteralSchema<SectionType.CUSTOM, undefined>;
+}, val.UnknownSchema, undefined>;
+export type CustomSection = val.InferOutput<typeof CustomSectionSchema>;
+export declare const SignatureSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.SIGNATURE, undefined>;
+    readonly signature: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>;
+export type SignatureSection = val.InferOutput<typeof SignatureSectionSchema>;
+export declare const AuxiliarySignatureSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.AUXILIARY_SIGNATURE, undefined>;
+    readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly signature: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>;
+export type AuxiliarySignatureSection = val.InferOutput<typeof AuxiliarySignatureSectionSchema>;
+export declare const AllowedAdditionalWriterSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
+    readonly allowedWriterAccountId: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type AllowedAdditionalWriterSection = val.InferOutput<typeof AllowedAdditionalWriterSectionSchema>;
+export declare const ProtocolCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.PROTOCOL_CREATION, undefined>;
+    readonly organizationId: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ProtocolCreationSection = val.InferOutput<typeof ProtocolCreationSectionSchema>;
+export declare const ProtocolUpdateSectionSchema: val.ObjectSchema<{
+    readonly protocolVersion: val.NumberSchema<undefined>;
+    readonly protocolVersionName: val.StringSchema<undefined>;
+    readonly changeLog: val.StringSchema<undefined>;
+    readonly protocolVariables: val.ObjectSchema<{
+        readonly protocolVersionName: val.StringSchema<undefined>;
+        readonly protocolVersion: val.NumberSchema<undefined>;
+        readonly feesCalculationVersion: val.NumberSchema<undefined>;
+        readonly globalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly applicationLedgerInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly applicationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly organizationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly validatorNodeInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly accountInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly protocolInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly minimumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+        readonly maximumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+        readonly unstakingDelayInDays: val.NumberSchema<undefined>;
+        readonly maxBlockSizeInBytes: val.NumberSchema<undefined>;
+        readonly retentionPolicy: val.ArraySchema<val.ObjectSchema<{
+            readonly retentionRatio: val.NumberSchema<undefined>;
+            readonly maximumNumberOfDays: val.NumberSchema<undefined>;
+            readonly dayDivisor: val.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly abciVersion: val.NumberSchema<undefined>;
+    }, undefined>;
+    readonly type: val.LiteralSchema<SectionType.PROTOCOL_UPDATE, undefined>;
+}, undefined>;
+export type ProtocolUpdateSection = val.InferOutput<typeof ProtocolUpdateSectionSchema>;
+export declare const ProtocolVariablesSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.PROTOCOL_VARIABLES, undefined>;
+    readonly protocolVariables: val.AnySchema;
+}, undefined>;
+export type ProtocolVariablesSection = val.InferOutput<typeof ProtocolVariablesSectionSchema>;
+export declare const AccountPublicKeySectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
+    readonly publicKey: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>;
+export type AccountPublicKeySection = val.InferOutput<typeof AccountPublicKeySectionSchema>;
+export declare const AccountTokenIssuanceSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
+    readonly amount: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>;
+export type AccountTokenIssuanceSection = val.InferOutput<typeof AccountTokenIssuanceSectionSchema>;
+export declare const AccountCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_CREATION, undefined>;
+    readonly sellerAccount: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>;
+export type AccountCreationSection = val.InferOutput<typeof AccountCreationSectionSchema>;
+export declare const AccountTransferSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_TRANSFER, undefined>;
+    readonly account: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly publicReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly privateReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type AccountTransferSection = val.InferOutput<typeof AccountTransferSectionSchema>;
+export declare const AccountVestingTransferSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
+    readonly account: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly publicReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly privateReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly cliffDurationDays: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly vestingDurationDays: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>;
+export type AccountVestingTransferSection = val.InferOutput<typeof AccountVestingTransferSectionSchema>;
+export declare const AccountEscrowTransferSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
+    readonly account: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly publicReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly privateReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly escrowIdentifier: val.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: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>;
+export type AccountEscrowTransferSection = val.InferOutput<typeof AccountEscrowTransferSectionSchema>;
+export declare const AccountEscrowSettlementSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_ESCROW_SETTLEMENT, undefined>;
+    readonly escrowIdentifier: val.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: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+        readonly typeId: 4;
+    }>]>;
+}, undefined>;
+export type AccountEscrowSettlementSection = val.InferOutput<typeof AccountEscrowSettlementSectionSchema>;
+export declare const AccountStakeSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_STAKE, undefined>;
+    readonly amount: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectIdentifier: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type AccountStakeSection = val.InferOutput<typeof AccountStakeSectionSchema>;
+export declare const AccountUnstakeSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_UNSTAKE, undefined>;
+    readonly amount: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectIdentifier: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type AccountUnstakeSection = val.InferOutput<typeof AccountUnstakeSectionSchema>;
+export declare const ValidatorNodeCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_CREATION, undefined>;
+    readonly organizationId: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ValidatorNodeCreationSection = val.InferOutput<typeof ValidatorNodeCreationSectionSchema>;
+export declare const ValidatorNodeCometbftPublicKeyDeclarationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_COMETBFT_PUBLIC_KEY_DECLARATION, undefined>;
+    readonly cometPublicKeyType: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly cometPublicKey: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type ValidatorNodeCometbftPublicKeyDeclarationSection = val.InferOutput<typeof ValidatorNodeCometbftPublicKeyDeclarationSectionSchema>;
+export declare const ValidatorNodeRpcEndpointSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_RPC_ENDPOINT, undefined>;
+    readonly rpcEndpoint: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type ValidatorNodeRpcEndpointSection = val.InferOutput<typeof ValidatorNodeRpcEndpointSectionSchema>;
+export declare const ValidatorNodeApprovalSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_APPROVAL, undefined>;
+    readonly status: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+        readonly typeId: 4;
+    }>]>;
+}, undefined>;
+export type ValidatorNodeVotingPowerUpdateSection = val.InferOutput<typeof ValidatorNodeApprovalSectionSchema>;
+export declare const ValidatorNodeSlashingCancellationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_SLASHING_CANCELLATION, undefined>;
+    readonly reason: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type ValidatorNodeSlashingCancellationSection = val.InferOutput<typeof ValidatorNodeSlashingCancellationSectionSchema>;
+export declare const OrganizationCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ORG_CREATION, undefined>;
+    readonly accountId: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type OrganizationCreationSection = val.InferOutput<typeof OrganizationCreationSectionSchema>;
+export declare const OrganizationDescriptionSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ORG_DESCRIPTION, undefined>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly city: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly countryCode: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly website: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly misc: val.OptionalSchema<val.RecordSchema<val.StringSchema<undefined>, val.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export type OrganizationDescriptionSection = val.InferOutput<typeof OrganizationDescriptionSectionSchema>;
+export declare const ApplicationCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_CREATION, undefined>;
+    readonly organizationId: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationCreationSection = val.InferOutput<typeof ApplicationCreationSectionSchema>;
+export declare const ApplicationDescriptionSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_DESCRIPTION, undefined>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly logoUrl: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly homepageUrl: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly description: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly misc: val.OptionalSchema<val.RecordSchema<val.StringSchema<undefined>, val.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export type ApplicationDescriptionSection = val.InferOutput<typeof ApplicationDescriptionSectionSchema>;
+export declare const ApplicationLedgerAllowedSigSchemesSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ALLOWED_SIG_SCHEMES, undefined>;
+    readonly schemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>, undefined>;
+}, undefined>;
+export type ApplicationLedgerAllowedSigSchemesSection = val.InferOutput<typeof ApplicationLedgerAllowedSigSchemesSectionSchema>;
+export declare const ApplicationLedgerAllowedPkeSchemesSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ALLOWED_PKE_SCHEMES, undefined>;
+    readonly schemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>, undefined>;
+}, undefined>;
+export type ApplicationLedgerAllowedPkeSchemesSection = val.InferOutput<typeof ApplicationLedgerAllowedPkeSchemesSectionSchema>;
+export declare const ApplicationLedgerCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_CREATION, undefined>;
+    readonly applicationId: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationLedgerCreationSection = val.InferOutput<typeof ApplicationLedgerCreationSectionSchema>;
+export declare const ApplicationLedgerActorCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ACTOR_CREATION, undefined>;
+    readonly id: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly actorType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type ApplicationLedgerActorCreationSection = val.InferOutput<typeof ApplicationLedgerActorCreationSectionSchema>;
+export declare const ApplicationLedgerChannelCreationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_CHANNEL_CREATION, undefined>;
+    readonly id: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly isPrivate: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+        readonly typeId: 4;
+    }>]>;
+    readonly creatorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type ApplicationLedgerChannelCreationSection = val.InferOutput<typeof ApplicationLedgerChannelCreationSectionSchema>;
+export declare const ApplicationLedgerSharedSecretSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_SHARED_SECRET, undefined>;
+    readonly hostId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly guestId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly encryptedSharedKey: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationLedgerSharedSecretSection = val.InferOutput<typeof ApplicationLedgerSharedSecretSectionSchema>;
+export declare const ApplicationLedgerChannelInvitationSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_CHANNEL_INVITATION, undefined>;
+    readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly hostId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly guestId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly encryptedChannelKey: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationLedgerChannelInvitationSection = val.InferOutput<typeof ApplicationLedgerChannelInvitationSectionSchema>;
+export declare const ApplicationLedgerActorSubscriptionSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
+    readonly actorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly actorType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly organizationId: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+    readonly signaturePublicKey: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+    readonly pkePublicKey: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationLedgerActorSubscriptionSection = val.InferOutput<typeof ApplicationLedgerActorSubscriptionSectionSchema>;
+export declare const ApplicationLedgerPublicChannelDataSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
+    readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly data: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationLedgerPublicChannelDataSection = val.InferOutput<typeof ApplicationLedgerPublicChannelDataSectionSchema>;
+export declare const ApplicationLedgerPrivateChannelDataSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
+    readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly merkleRootHash: val.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: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type ApplicationLedgerPrivateChannelDataSection = val.InferOutput<typeof ApplicationLedgerPrivateChannelDataSectionSchema>;
+export declare const ApplicationLedgerAuthorSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_AUTHOR, undefined>;
+    readonly authorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>;
+export type ApplicationLedgerAuthorSection = val.InferOutput<typeof ApplicationLedgerAuthorSectionSchema>;
+export declare const ApplicationLedgerEndorsementRequestSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
+    readonly endorserId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly message: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>;
+export type ApplicationLedgerEndorsementRequestSection = val.InferOutput<typeof ApplicationLedgerEndorsementRequestSectionSchema>;
+export declare const SectionSchema: val.VariantSchema<"type", [val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.AUXILIARY_SIGNATURE, undefined>;
+    readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly signature: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.SIGNATURE, undefined>;
+    readonly signature: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
+    readonly allowedWriterAccountId: val.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>, val.ObjectWithRestSchema<{
+    readonly type: val.LiteralSchema<SectionType.CUSTOM, undefined>;
+}, val.UnknownSchema, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.PROTOCOL_CREATION, undefined>;
+    readonly organizationId: val.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>, val.ObjectSchema<{
+    readonly protocolVersion: val.NumberSchema<undefined>;
+    readonly protocolVersionName: val.StringSchema<undefined>;
+    readonly changeLog: val.StringSchema<undefined>;
+    readonly protocolVariables: val.ObjectSchema<{
+        readonly protocolVersionName: val.StringSchema<undefined>;
+        readonly protocolVersion: val.NumberSchema<undefined>;
+        readonly feesCalculationVersion: val.NumberSchema<undefined>;
+        readonly globalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly applicationLedgerInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly applicationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly organizationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly validatorNodeInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly accountInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly protocolInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+        readonly minimumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+        readonly maximumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+        readonly unstakingDelayInDays: val.NumberSchema<undefined>;
+        readonly maxBlockSizeInBytes: val.NumberSchema<undefined>;
+        readonly retentionPolicy: val.ArraySchema<val.ObjectSchema<{
+            readonly retentionRatio: val.NumberSchema<undefined>;
+            readonly maximumNumberOfDays: val.NumberSchema<undefined>;
+            readonly dayDivisor: val.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly abciVersion: val.NumberSchema<undefined>;
+    }, undefined>;
+    readonly type: val.LiteralSchema<SectionType.PROTOCOL_UPDATE, undefined>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.PROTOCOL_VARIABLES, undefined>;
+    readonly protocolVariables: val.AnySchema;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
+    readonly publicKey: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
+    readonly amount: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_CREATION, undefined>;
+    readonly sellerAccount: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_TRANSFER, undefined>;
+    readonly account: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly publicReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly privateReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
+    readonly account: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly publicReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly privateReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly cliffDurationDays: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly vestingDurationDays: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
+    readonly account: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly publicReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly privateReference: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly escrowIdentifier: val.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: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_ESCROW_SETTLEMENT, undefined>;
+    readonly escrowIdentifier: val.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: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+        readonly typeId: 4;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_STAKE, undefined>;
+    readonly amount: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectIdentifier: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ACCOUNT_UNSTAKE, undefined>;
+    readonly amount: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly objectIdentifier: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_CREATION, undefined>;
+    readonly organizationId: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_COMETBFT_PUBLIC_KEY_DECLARATION, undefined>;
+    readonly cometPublicKeyType: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly cometPublicKey: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_RPC_ENDPOINT, undefined>;
+    readonly rpcEndpoint: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_APPROVAL, undefined>;
+    readonly status: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+        readonly typeId: 4;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.VN_SLASHING_CANCELLATION, undefined>;
+    readonly reason: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ORG_CREATION, undefined>;
+    readonly accountId: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.ORG_DESCRIPTION, undefined>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly city: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly countryCode: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly website: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly misc: val.OptionalSchema<val.RecordSchema<val.StringSchema<undefined>, val.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_CREATION, undefined>;
+    readonly organizationId: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_DESCRIPTION, undefined>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly logoUrl: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly homepageUrl: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly description: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly misc: val.OptionalSchema<val.RecordSchema<val.StringSchema<undefined>, val.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ALLOWED_SIG_SCHEMES, undefined>;
+    readonly schemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>, undefined>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ALLOWED_PKE_SCHEMES, undefined>;
+    readonly schemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>, undefined>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_CREATION, undefined>;
+    readonly applicationId: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ACTOR_CREATION, undefined>;
+    readonly id: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly actorType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_CHANNEL_CREATION, undefined>;
+    readonly id: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly isPrivate: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+        readonly typeId: 4;
+    }>]>;
+    readonly creatorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_SHARED_SECRET, undefined>;
+    readonly hostId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly guestId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly encryptedSharedKey: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_CHANNEL_INVITATION, undefined>;
+    readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly hostId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly guestId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly encryptedChannelKey: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
+    readonly actorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly actorType: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly organizationId: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+    readonly signaturePublicKey: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+    readonly pkePublicKey: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
+    readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly data: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
+    readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly merkleRootHash: val.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: val.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>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_AUTHOR, undefined>;
+    readonly authorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
+    readonly endorserId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly message: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+}, undefined>], undefined>;
+export type Section = val.InferOutput<typeof SectionSchema>;
+//# sourceMappingURL=sections.d.ts.map