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

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (486) hide show

package/dist/type/valibot/blockchain/virtualBlockchain/virtualBlockchains.d.ts ADDED Viewed

@@ -0,0 +1,605 @@
+import { VirtualBlockchainType } from '../../../VirtualBlockchainType';
+import * as v from 'valibot';
+export declare const VirtualBlockchainSharedPropertiesSchema: v.ObjectSchema<{
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+}, undefined>;
+export declare const AccountVirtualBlockchainStateSchema: v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+            readonly typeId: 3;
+        }>]>;
+        readonly publicKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>;
+export type AccountVirtualBlockchainState = v.InferOutput<typeof AccountVirtualBlockchainStateSchema>;
+export declare const OrganizationVirtualBlockchainStateSchema: v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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>;
+        readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>;
+export type OrganizationVirtualBlockchainState = v.InferOutput<typeof OrganizationVirtualBlockchainStateSchema>;
+export declare const ValidatorNodeVirtualBlockchainStateSchema: v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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 cometbftPublicKeyDeclarationHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly lastKnownApprovalStatus: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+            readonly typeId: 4;
+        }>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>;
+export type ValidatorNodeVirtualBlockchainState = v.InferOutput<typeof ValidatorNodeVirtualBlockchainStateSchema>;
+export declare const ApplicationVirtualBlockchainStateSchema: v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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 descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>;
+export type ApplicationVirtualBlockchainState = v.InferOutput<typeof ApplicationVirtualBlockchainStateSchema>;
+export declare const ApplicationLedgerVirtualBlockchainStateSchema: v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        readonly allowedAdditionalWriters: v.ArraySchema<v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, undefined>;
+        readonly allowedSignatureSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+            readonly typeId: 3;
+        }>]>, undefined>;
+        readonly allowedPkeSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+            readonly typeId: 3;
+        }>]>, 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>;
+        readonly channels: v.ArraySchema<v.ObjectSchema<{
+            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 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;
+            }>]>;
+        }, undefined>, undefined>;
+        readonly actors: v.ArraySchema<v.ObjectSchema<{
+            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 subscribed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                readonly typeId: 4;
+            }>]>;
+            readonly signatureKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly pkeKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly sharedSecrets: v.ArraySchema<v.ObjectSchema<{
+                readonly peerActorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, undefined>;
+            readonly invitations: v.ArraySchema<v.ObjectSchema<{
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>;
+export type ApplicationLedgerVirtualBlockchainState = v.InferOutput<typeof ApplicationLedgerVirtualBlockchainStateSchema>;
+export declare const ProtocolVirtualBlockchainStateSchema: v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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 currentProtocolVariables: 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 protocolUpdates: v.ArraySchema<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>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>;
+export type ProtocolVirtualBlockchainState = v.InferOutput<typeof ProtocolVirtualBlockchainStateSchema>;
+export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+            readonly typeId: 3;
+        }>]>;
+        readonly publicKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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>;
+        readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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 cometbftPublicKeyDeclarationHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly lastKnownApprovalStatus: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+            readonly typeId: 4;
+        }>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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 descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        readonly allowedAdditionalWriters: v.ArraySchema<v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, undefined>;
+        readonly allowedSignatureSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+            readonly typeId: 3;
+        }>]>, undefined>;
+        readonly allowedPkeSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+            readonly typeId: 3;
+        }>]>, 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>;
+        readonly channels: v.ArraySchema<v.ObjectSchema<{
+            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 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;
+            }>]>;
+        }, undefined>, undefined>;
+        readonly actors: v.ArraySchema<v.ObjectSchema<{
+            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 subscribed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                readonly typeId: 4;
+            }>]>;
+            readonly signatureKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly pkeKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly sharedSecrets: v.ArraySchema<v.ObjectSchema<{
+                readonly peerActorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, undefined>;
+            readonly invitations: v.ArraySchema<v.ObjectSchema<{
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly internalState: v.ObjectSchema<{
+        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 currentProtocolVariables: 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 protocolUpdates: v.ArraySchema<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>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+        readonly typeId: 3;
+    }>]>;
+    readonly lastMicroblockHash: 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 type: v.LiteralSchema<VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
+}, undefined>], undefined>;
+export type VirtualBlockchainState = v.InferOutput<typeof VirtualBlockchainStateSchema>;
+//# sourceMappingURL=virtualBlockchains.d.ts.map

package/dist/type/valibot/blockchain/virtualBlockchain/virtualBlockchains.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"virtualBlockchains.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/virtualBlockchain/virtualBlockchains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAC,qBAAqB,EAAC,MAAM,gCAAgC,CAAC;AAUrE,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;aAIlD,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;aAI9C,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEtG,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAInD,CAAA;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAEhH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIpD,CAAA;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAElH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIlD,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAE9G,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIxD,CAAA;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6CAA6C,CAAC,CAAC;AAE1H,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI/C,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAExG,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAUxC,CAAA;AAGD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/type/valibot/clientBridge/ClientBridgeEncoder.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { ClientBridgeMessage } from './clientBridgeMessages';
+export declare class ClientBridgeEncoder {
+    static encode(message: ClientBridgeMessage): Uint8Array;
+    static decode(data: Uint8Array): ClientBridgeMessage;
+}
+export declare class ClientBridgeValidation {
+    static validateClientBridgeMessage(message: unknown): ClientBridgeMessage;
+}
+//# sourceMappingURL=ClientBridgeEncoder.d.ts.map

package/dist/type/valibot/clientBridge/ClientBridgeEncoder.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"ClientBridgeEncoder.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/clientBridge/ClientBridgeEncoder.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,mBAAmB,EAEtB,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,mBAAmB;IAC5B,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,UAAU;IAIvD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB;CAGvD;AAED,qBAAa,sBAAsB;IAC/B,MAAM,CAAC,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB;CAG5E"}

package/dist/type/valibot/clientBridge/WiQrCodeEncoder.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import { WiQrCode } from './clientBridgeMessages';
+export declare class WiQrCodeEncoder {
+    static encode(qrCode: WiQrCode): Uint8Array;
+    static decode(data: Uint8Array): WiQrCode;
+}
+//# sourceMappingURL=WiQrCodeEncoder.d.ts.map

package/dist/type/valibot/clientBridge/WiQrCodeEncoder.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"WiQrCodeEncoder.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/clientBridge/WiQrCodeEncoder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,QAAQ,EAAiB,MAAM,wBAAwB,CAAC;AAEhE,qBAAa,eAAe;IACxB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,UAAU;IAI3C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ;CAG5C"}