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

package/dist/type/valibot/blockchain/microblock/MicroblockStruct.d.ts

@@ -0,0 +1,608 @@
+import * as v from 'valibot';
+export declare const MicroblockStructSchema: v.ObjectSchema<{
+    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 body: v.ObjectSchema<{
+        readonly sections: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../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("../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("../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("../section/SectionType").SectionType.CUSTOM, undefined>;
+        }, v.UnknownSchema, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../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("../section/SectionType").SectionType.PROTOCOL_UPDATE, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../section/SectionType").SectionType.PROTOCOL_VARIABLES, undefined>;
+            readonly protocolVariables: v.AnySchema;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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("../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 type MicroblockStruct = v.InferOutput<typeof MicroblockStructSchema>;
+//# sourceMappingURL=MicroblockStruct.d.ts.map

package/dist/type/valibot/blockchain/microblock/MicroblockStruct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MicroblockStruct.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/microblock/MicroblockStruct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAGjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAA"}