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

package/dist/type/valibot/account/Account.d.ts

@@ -0,0 +1,632 @@
+import * as v from "valibot";
+export declare const LOCK_TYPE_COUNT = 3;
+export declare enum LockType {
+    Escrow = 0,
+    Vesting = 1,
+    NodeStaking = 2
+}
+export declare const EscrowParametersSchema: v.ObjectSchema<{
+    readonly escrowIdentifier: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly fundEmitterAccountId: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly transferAuthorizerAccountId: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly startTimestamp: v.NumberSchema<undefined>;
+    readonly durationDays: v.NumberSchema<undefined>;
+}, undefined>;
+export type EscrowParameters = v.InferOutput<typeof EscrowParametersSchema>;
+export declare const EscrowLockSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<LockType.Escrow, undefined>;
+    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly parameters: v.ObjectSchema<{
+        readonly escrowIdentifier: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly fundEmitterAccountId: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly transferAuthorizerAccountId: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly startTimestamp: v.NumberSchema<undefined>;
+        readonly durationDays: v.NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export type EscrowLock = v.InferOutput<typeof EscrowLockSchema>;
+export declare const VestingParametersSchema: v.ObjectSchema<{
+    readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+    readonly cliffDurationDays: v.NumberSchema<undefined>;
+    readonly vestingDurationDays: v.NumberSchema<undefined>;
+}, undefined>;
+export type VestingParameters = v.InferOutput<typeof VestingParametersSchema>;
+export declare const VestingLockSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<LockType.Vesting, undefined>;
+    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly parameters: v.ObjectSchema<{
+        readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+        readonly cliffDurationDays: v.NumberSchema<undefined>;
+        readonly vestingDurationDays: v.NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export type VestingLock = v.InferOutput<typeof VestingLockSchema>;
+export declare const NodeStakingParametersSchema: v.ObjectSchema<{
+    readonly validatorNodeId: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+    readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+    readonly slashed: v.BooleanSchema<undefined>;
+    readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+    readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+}, undefined>;
+export type NodeStakingParameters = v.InferOutput<typeof NodeStakingParametersSchema>;
+export declare const NodeStakingLockSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<LockType.NodeStaking, undefined>;
+    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly parameters: v.ObjectSchema<{
+        readonly validatorNodeId: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+        readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+        readonly slashed: v.BooleanSchema<undefined>;
+        readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+        readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export type NodeStakingLock = v.InferOutput<typeof NodeStakingLockSchema>;
+export declare const LockSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<LockType.Escrow, undefined>;
+    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly parameters: v.ObjectSchema<{
+        readonly escrowIdentifier: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly fundEmitterAccountId: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly transferAuthorizerAccountId: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly startTimestamp: v.NumberSchema<undefined>;
+        readonly durationDays: v.NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<LockType.Vesting, undefined>;
+    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly parameters: v.ObjectSchema<{
+        readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+        readonly cliffDurationDays: v.NumberSchema<undefined>;
+        readonly vestingDurationDays: v.NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<LockType.NodeStaking, undefined>;
+    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+    readonly parameters: v.ObjectSchema<{
+        readonly validatorNodeId: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+        readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+        readonly slashed: v.BooleanSchema<undefined>;
+        readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+        readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>], undefined>;
+export type Lock = v.InferOutput<typeof LockSchema>;
+export declare const AccountBreakdownSchema: v.ObjectSchema<{
+    readonly balance: v.NumberSchema<undefined>;
+    readonly escrowed: v.NumberSchema<undefined>;
+    readonly vested: v.NumberSchema<undefined>;
+    readonly releasable: v.NumberSchema<undefined>;
+    readonly staked: v.NumberSchema<undefined>;
+    readonly stakeable: v.NumberSchema<undefined>;
+    readonly locked: v.NumberSchema<undefined>;
+    readonly spendable: v.NumberSchema<undefined>;
+}, undefined>;
+export type AccountBreakdown = v.InferOutput<typeof AccountBreakdownSchema>;
+export declare const AccountStateSchema: v.ObjectSchema<{
+    readonly height: v.NumberSchema<undefined>;
+    readonly balance: v.NumberSchema<undefined>;
+    readonly lastHistoryHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<LockType.Escrow, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly escrowIdentifier: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly fundEmitterAccountId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly startTimestamp: v.NumberSchema<undefined>;
+            readonly durationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<LockType.Vesting, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+            readonly cliffDurationDays: v.NumberSchema<undefined>;
+            readonly vestingDurationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<LockType.NodeStaking, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly validatorNodeId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+            readonly slashed: v.BooleanSchema<undefined>;
+            readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>;
+export type AccountState = v.InferOutput<typeof AccountStateSchema>;
+export declare const AccountInformationSchema: v.ObjectSchema<{
+    readonly type: v.NumberSchema<undefined>;
+    readonly exists: v.BooleanSchema<undefined>;
+    readonly state: v.ObjectSchema<{
+        readonly height: v.NumberSchema<undefined>;
+        readonly balance: v.NumberSchema<undefined>;
+        readonly lastHistoryHash: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<LockType.Escrow, undefined>;
+            readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly parameters: v.ObjectSchema<{
+                readonly escrowIdentifier: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly fundEmitterAccountId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly startTimestamp: v.NumberSchema<undefined>;
+                readonly durationDays: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<LockType.Vesting, undefined>;
+            readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly parameters: v.ObjectSchema<{
+                readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                readonly cliffDurationDays: v.NumberSchema<undefined>;
+                readonly vestingDurationDays: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<LockType.NodeStaking, undefined>;
+            readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly parameters: v.ObjectSchema<{
+                readonly validatorNodeId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                readonly slashed: v.BooleanSchema<undefined>;
+                readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type AccountInformation = v.InferOutput<typeof AccountInformationSchema>;
+export declare const AccountHistoryEntrySchema: v.ObjectSchema<{
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+    readonly publicReference: v.StringSchema<undefined>;
+    readonly privateReference: v.StringSchema<undefined>;
+    readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly chainReference: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type AccountHistoryEntry = v.InferOutput<typeof AccountHistoryEntrySchema>;
+export declare const AccountHistorySchema: v.ArraySchema<v.ObjectSchema<{
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+    readonly publicReference: v.StringSchema<undefined>;
+    readonly privateReference: v.StringSchema<undefined>;
+    readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly chainReference: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>, undefined>;
+export type AccountHistory = v.InferOutput<typeof AccountHistorySchema>;
+export declare const RequestedAccountUpdateSchema: v.ObjectSchema<{
+    readonly accountHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly lastKnownHistoryHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export type RequestedAccountUpdate = v.InferOutput<typeof RequestedAccountUpdateSchema>;
+export declare const AccountUpdateSchema: v.ObjectSchema<{
+    readonly accountHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly currentState: v.ObjectSchema<{
+        readonly height: v.NumberSchema<undefined>;
+        readonly balance: v.NumberSchema<undefined>;
+        readonly lastHistoryHash: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<LockType.Escrow, undefined>;
+            readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly parameters: v.ObjectSchema<{
+                readonly escrowIdentifier: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly fundEmitterAccountId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly startTimestamp: v.NumberSchema<undefined>;
+                readonly durationDays: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<LockType.Vesting, undefined>;
+            readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly parameters: v.ObjectSchema<{
+                readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                readonly cliffDurationDays: v.NumberSchema<undefined>;
+                readonly vestingDurationDays: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<LockType.NodeStaking, undefined>;
+            readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly parameters: v.ObjectSchema<{
+                readonly validatorNodeId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                readonly slashed: v.BooleanSchema<undefined>;
+                readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>;
+    readonly historyUpdate: v.ArraySchema<v.ObjectSchema<{
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly publicReference: v.StringSchema<undefined>;
+        readonly privateReference: v.StringSchema<undefined>;
+        readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly chainReference: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type AccountUpdate = v.InferOutput<typeof AccountUpdateSchema>;
+//# sourceMappingURL=Account.d.ts.map

package/dist/type/valibot/account/Account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Account.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/account/Account.ts"],"names":[],"mappings":"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"}