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

package/dist/type/valibot/blockchain/economics/RetentionPolicy.d.ts

@@ -0,0 +1,20 @@
+import * as v from 'valibot';
+export declare const RetentionTierSchema: v.ObjectSchema<{
+    readonly retentionRatio: v.NumberSchema<undefined>;
+    readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+    readonly dayDivisor: v.NumberSchema<undefined>;
+}, undefined>;
+export type RetentionTier = v.InferOutput<typeof RetentionTierSchema>;
+export declare const RetentionPolicySchema: v.ArraySchema<v.ObjectSchema<{
+    readonly retentionRatio: v.NumberSchema<undefined>;
+    readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+    readonly dayDivisor: v.NumberSchema<undefined>;
+}, undefined>, undefined>;
+export type RetentionPolicy = v.InferOutput<typeof RetentionPolicySchema>;
+export declare const RetentionCostBreakdownSchema: v.ObjectSchema<{
+    readonly numberOfDays: v.NumberSchema<undefined>;
+    readonly retentionRatio: v.NumberSchema<undefined>;
+    readonly costInGasAtoms: v.NumberSchema<undefined>;
+}, undefined>;
+export type RetentionCostBreakdown = v.InferOutput<typeof RetentionCostBreakdownSchema>;
+//# sourceMappingURL=RetentionPolicy.d.ts.map

package/dist/type/valibot/blockchain/economics/RetentionPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetentionPolicy.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/economics/RetentionPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,mBAAmB;;;;aAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,qBAAqB;;;;yBAA+B,CAAA;AACjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,4BAA4B;;;;aAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

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

@@ -0,0 +1,567 @@
+import * as v from 'valibot';
+export declare const MicroblockBodySchema: 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>;
+export type MicroblockBody = v.InferOutput<typeof MicroblockBodySchema>;
+//# sourceMappingURL=MicroblockBody.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MicroblockBody.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/microblock/MicroblockBody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAE/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC"}