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

package/dist/type/valibot/clientBridge/clientBridgeMessages.d.ts

@@ -0,0 +1,215 @@
+import * as v from 'valibot';
+export declare const WI_MAX_SERVER_URL_LENGTH = 100;
+export declare enum ClientBridgeMessageType {
+    REQUEST = "CLIENT_BRIDGE_REQUEST",
+    UPDATE_QR = "CLIENT_BRIDGE_UPDATE_QR",
+    CONNECTION_TOKEN = "CLIENT_BRIDGE_CONNECTION_TOKEN",
+    FORWARDED_ANSWER = "CLIENT_BRIDGE_FORWARDED_ANSWER",
+    GET_CONNECTION_INFO = "CLIENT_BRIDGE_GET_CONNECTION_INFO",
+    ANSWER = "CLIENT_BRIDGE_ANSWER",
+    CONNECTION_INFO = "CLIENT_BRIDGE_CONNECTION_INFO",
+    CONNECTION_ACCEPTED = "CLIENT_BRIDGE_CONNECTION_ACCEPTED",
+    FORWARDED_REQUEST = "CLIENT_BRIDGE_FORWARDED_REQUEST",
+    ERROR = "CLIENT_BRIDGE_ERROR"
+}
+export declare const WiQrCodeSchema: v.ObjectSchema<{
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+    readonly timestamp: v.NumberSchema<undefined>;
+    readonly serverUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 100, undefined>]>;
+}, undefined>;
+export type WiQrCode = v.InferOutput<typeof WiQrCodeSchema>;
+export declare const ClientBridgeMessageSchema_Request: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.REQUEST, undefined>;
+    readonly walletRequest: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly base64EncodedChallenge: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.DATA_APPROVAL, undefined>;
+        readonly anchorRequestId: v.StringSchema<undefined>;
+        readonly serverUrl: v.StringSchema<undefined>;
+    }, undefined>], undefined>;
+    readonly deviceId: 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 withToken: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_UpdateQr: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.UPDATE_QR, undefined>;
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+    readonly timestamp: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_ConnectionToken: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.CONNECTION_TOKEN, undefined>;
+    readonly token: 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;
+    }>]>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_ForwardedAnswer: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.FORWARDED_ANSWER, undefined>;
+    readonly walletResponse: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly publicKey: v.StringSchema<undefined>;
+        readonly signature: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.DATA_APPROVAL, undefined>;
+        readonly b64VbHash: v.StringSchema<undefined>;
+        readonly b64MbHash: v.StringSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+    }, undefined>], undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_GetConnectionInfo: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.GET_CONNECTION_INFO, undefined>;
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_Answer: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.ANSWER, undefined>;
+    readonly walletResponse: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly publicKey: v.StringSchema<undefined>;
+        readonly signature: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.DATA_APPROVAL, undefined>;
+        readonly b64VbHash: v.StringSchema<undefined>;
+        readonly b64MbHash: v.StringSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+    }, undefined>], undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_ConnectionInfo: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.CONNECTION_INFO, undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_ConnectionAccepted: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.CONNECTION_ACCEPTED, undefined>;
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_ForwardedRequest: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.FORWARDED_REQUEST, undefined>;
+    readonly walletRequest: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly base64EncodedChallenge: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.DATA_APPROVAL, undefined>;
+        readonly anchorRequestId: v.StringSchema<undefined>;
+        readonly serverUrl: v.StringSchema<undefined>;
+    }, undefined>], undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema_Error: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.ERROR, undefined>;
+    readonly errorMessage: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ClientBridgeMessageSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.REQUEST, undefined>;
+    readonly walletRequest: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly base64EncodedChallenge: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.DATA_APPROVAL, undefined>;
+        readonly anchorRequestId: v.StringSchema<undefined>;
+        readonly serverUrl: v.StringSchema<undefined>;
+    }, undefined>], undefined>;
+    readonly deviceId: 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 withToken: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.UPDATE_QR, undefined>;
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+    readonly timestamp: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.CONNECTION_TOKEN, undefined>;
+    readonly token: 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;
+    }>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.FORWARDED_ANSWER, undefined>;
+    readonly walletResponse: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly publicKey: v.StringSchema<undefined>;
+        readonly signature: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.DATA_APPROVAL, undefined>;
+        readonly b64VbHash: v.StringSchema<undefined>;
+        readonly b64MbHash: v.StringSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+    }, undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.GET_CONNECTION_INFO, undefined>;
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.ANSWER, undefined>;
+    readonly walletResponse: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly publicKey: v.StringSchema<undefined>;
+        readonly signature: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletResponseType.DATA_APPROVAL, undefined>;
+        readonly b64VbHash: v.StringSchema<undefined>;
+        readonly b64MbHash: v.StringSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+    }, undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.CONNECTION_INFO, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.CONNECTION_ACCEPTED, undefined>;
+    readonly base64EncodedQrId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.FORWARDED_REQUEST, undefined>;
+    readonly walletRequest: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.AUTH_BY_PUBLIC_KEY, undefined>;
+        readonly base64EncodedChallenge: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../walletRequest/walletRequests").WalletRequestType.DATA_APPROVAL, undefined>;
+        readonly anchorRequestId: v.StringSchema<undefined>;
+        readonly serverUrl: v.StringSchema<undefined>;
+    }, undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<ClientBridgeMessageType.ERROR, undefined>;
+    readonly errorMessage: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+export type ClientBridgeMessage = v.InferOutput<typeof ClientBridgeMessageSchema>;
+export type ClientBridgeMessage_Request = v.InferOutput<typeof ClientBridgeMessageSchema_Request>;
+export type ClientBridgeMessage_UpdateQr = v.InferOutput<typeof ClientBridgeMessageSchema_UpdateQr>;
+export type ClientBridgeMessage_ConnectionToken = v.InferOutput<typeof ClientBridgeMessageSchema_ConnectionToken>;
+export type ClientBridgeMessage_ForwardedAnswer = v.InferOutput<typeof ClientBridgeMessageSchema_ForwardedAnswer>;
+export type ClientBridgeMessage_GetConnectionInfo = v.InferOutput<typeof ClientBridgeMessageSchema_GetConnectionInfo>;
+export type ClientBridgeMessage_Answer = v.InferOutput<typeof ClientBridgeMessageSchema_Answer>;
+export type ClientBridgeMessage_ConnectionInfo = v.InferOutput<typeof ClientBridgeMessageSchema_ConnectionInfo>;
+export type ClientBridgeMessage_ConnectionAccepted = v.InferOutput<typeof ClientBridgeMessageSchema_ConnectionAccepted>;
+export type ClientBridgeMessage_ForwardedRequest = v.InferOutput<typeof ClientBridgeMessageSchema_ForwardedRequest>;
+export type ClientBridgeMessage_Error = v.InferOutput<typeof ClientBridgeMessageSchema_Error>;
+//# sourceMappingURL=clientBridgeMessages.d.ts.map

package/dist/type/valibot/clientBridge/clientBridgeMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientBridgeMessages.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/clientBridge/clientBridgeMessages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAG5C,oBAAY,uBAAuB;IAC/B,OAAO,0BAA0B;IACjC,SAAS,4BAA4B;IACrC,gBAAgB,mCAAmC;IACnD,gBAAgB,mCAAmC;IACnD,mBAAmB,sCAAsC;IACzD,MAAM,yBAAyB;IAC/B,eAAe,kCAAkC;IACjD,mBAAmB,sCAAsC;IACzD,iBAAiB,oCAAoC;IACrD,KAAK,wBAAwB;CAChC;AAGD,eAAO,MAAM,cAAc;;;;aAIzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAG5D,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;aAK5C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;aAI7C,CAAC;AAEH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;aAGpD,CAAC;AAEH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;aAGpD,CAAC;AAEH,eAAO,MAAM,2CAA2C;;;aAGtD,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;aAG3C,CAAC;AAEH,eAAO,MAAM,wCAAwC;;aAEnD,CAAC;AAEH,eAAO,MAAM,4CAA4C;;;aAGvD,CAAC;AAEH,eAAO,MAAM,0CAA0C;;;;;;;;;;aAGrD,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;aAG1C,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAWpC,CAAC;AAGH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAClF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAClG,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC;AACpG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAClH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAClH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2CAA2C,CAAC,CAAC;AACtH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAChG,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAChH,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4CAA4C,CAAC,CAAC;AACxH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0CAA0C,CAAC,CAAC;AACpH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/type/valibot/network/NetworksSchema.d.ts

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+export declare const NetworksFileSchema: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+    readonly networkName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly nodes: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+        readonly nodeName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly hostname: v.StringSchema<undefined>;
+        readonly rpcEndpoint: v.StringSchema<undefined>;
+        readonly p2pEndpoint: v.StringSchema<undefined>;
+        readonly trusted: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+        readonly nodeId: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>, undefined>;
+export type NetworksFile = v.InferOutput<typeof NetworksFileSchema>;
+//# sourceMappingURL=NetworksSchema.d.ts.map

package/dist/type/valibot/network/NetworksSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworksSchema.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/network/NetworksSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,kBAAkB;;;;;;;;;;yBAgB9B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/type/valibot/primitives.d.ts

@@ -0,0 +1,105 @@
+import * as val from "valibot";
+export declare const ARRAY = 0;
+export declare const OBJECT = 1;
+export declare const STRING = 2;
+export declare const NUMBER = 3;
+export declare const BOOLEAN = 4;
+export declare const NULL = 5;
+export declare const UINT8 = 6;
+export declare const UINT16 = 7;
+export declare const UINT24 = 8;
+export declare const UINT32 = 9;
+export declare const UINT48 = 10;
+export declare const BINARY = 11;
+export declare const BIN256 = 12;
+export declare const HASH_STR = 13;
+export type AnySchema = val.BaseSchema<any, any, any>;
+export interface ArrayOptions {
+    items: AnySchema;
+}
+export interface NumberOptions {
+}
+export interface StringOptions {
+    size?: number;
+}
+export interface NumberOptions {
+}
+export interface BooleanOptions {
+}
+export interface NilOptions {
+}
+export interface UintOptions {
+}
+export interface BinaryOptions {
+    size?: number;
+}
+export interface Bin256Options {
+}
+export declare function array(options: ArrayOptions): val.SchemaWithPipe<readonly [val.ArraySchema<AnySchema, undefined>, val.MetadataAction<any[], {
+    readonly items: AnySchema;
+    readonly typeId: 0;
+    readonly elementSchema: AnySchema;
+}>]>;
+export declare function string(options?: StringOptions): val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+    size: number;
+    readonly typeId: 2;
+}>]>;
+export declare function number(options?: NumberOptions): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+    readonly typeId: 3;
+}>]>;
+export declare function boolean(options?: BooleanOptions): val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+    readonly typeId: 4;
+}>]>;
+export declare function uint8(options?: UintOptions): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+    readonly typeId: number;
+}>]>;
+export declare function uint16(options?: UintOptions): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+    readonly typeId: number;
+}>]>;
+export declare function uint24(options?: UintOptions): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+    readonly typeId: number;
+}>]>;
+export declare function uint32(options?: UintOptions): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+    readonly typeId: number;
+}>]>;
+export declare function uint48(options?: UintOptions): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+    readonly typeId: number;
+}>]>;
+export declare function binary(options?: BinaryOptions): val.SchemaWithPipe<readonly [val.InstanceSchema<Uint8ArrayConstructor, undefined>, val.CustomSchema<Uint8Array<ArrayBuffer>, `Expected size is ${number} bytes`>, val.MetadataAction<Uint8Array<ArrayBuffer>, {
+    readonly size?: number;
+    readonly typeId: 11;
+}>]>;
+export declare function bin256(options?: Bin256Options): val.SchemaWithPipe<readonly [val.InstanceSchema<{
+    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+    readonly prototype: Uint8Array<ArrayBufferLike>;
+    readonly BYTES_PER_ELEMENT: number;
+    of(...items: number[]): Uint8Array<ArrayBuffer>;
+    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+}, undefined>, val.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, val.MetadataAction<Uint8Array<ArrayBufferLike>, {
+    readonly typeId: 12;
+}>]>;
+export declare function uint8array(): val.InstanceSchema<{
+    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+    readonly prototype: Uint8Array<ArrayBufferLike>;
+    readonly BYTES_PER_ELEMENT: number;
+    of(...items: number[]): Uint8Array<ArrayBuffer>;
+    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+}, undefined>;
+export declare function accountId(): val.InstanceSchema<{
+    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+    readonly prototype: Uint8Array<ArrayBufferLike>;
+    readonly BYTES_PER_ELEMENT: number;
+    of(...items: number[]): Uint8Array<ArrayBuffer>;
+    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+}, undefined>;
+export declare function height(): val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/type/valibot/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../../src/type/valibot/primitives.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAE/B,eAAO,MAAM,KAAK,IAAS,CAAC;AAC5B,eAAO,MAAM,MAAM,IAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,IAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,IAAQ,CAAC;AAC5B,eAAO,MAAM,OAAO,IAAO,CAAC;AAC5B,eAAO,MAAM,IAAI,IAAU,CAAC;AAC5B,eAAO,MAAM,KAAK,IAAS,CAAC;AAC5B,eAAO,MAAM,MAAM,IAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,IAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,IAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,KAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,KAAQ,CAAC;AAC5B,eAAO,MAAM,MAAM,KAAQ,CAAC;AAC5B,eAAO,MAAM,QAAQ,KAAM,CAAC;AAE5B,MAAM,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAEtD,MAAM,WAAW,YAAY;IAAG,KAAK,EAAE,SAAS,CAAA;CAAE;AAClD,MAAM,WAAW,aAAa;CAAG;AACjC,MAAM,WAAW,aAAa;IAAG,IAAI,CAAC,EAAE,MAAM,CAAC;CAAE;AACjD,MAAM,WAAW,aAAa;CAAG;AACjC,MAAM,WAAW,cAAc;CAAG;AAClC,MAAM,WAAW,UAAU;CAAG;AAC9B,MAAM,WAAW,WAAW;CAAG;AAC/B,MAAM,WAAW,aAAa;IAAG,IAAI,CAAC,EAAE,MAAM,CAAC;CAAE;AACjD,MAAM,WAAW,aAAa;CAAI;AAGlC,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY;oBAXJ,SAAS;;;KAkB/C;AAGD,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB;UAnBV,MAAM;;KA6B7C;AAED,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB;;KAOjD;AAGD,wBAAgB,OAAO,CAAC,OAAO,GAAE,cAAmB;;KAOnD;AAcD,wBAAgB,KAAK,CAAC,OAAO,GAAE,WAAgB;;KAAqC;AACpF,wBAAgB,MAAM,CAAC,OAAO,GAAE,WAAgB;;KAAuC;AACvF,wBAAgB,MAAM,CAAC,OAAO,GAAE,WAAgB;;KAAuC;AACvF,wBAAgB,MAAM,CAAC,OAAO,GAAE,WAAgB;;KAAuC;AACvF,wBAAgB,MAAM,CAAC,OAAO,GAAE,WAAgB;;KAAuC;AAGvF,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB;oBAhEV,MAAM;;KA0E7C;AAED,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB;;;;;;;;;;;KAQjD;AAED,wBAAgB,UAAU;;;;;;;;;cAEzB;AAED,wBAAgB,SAAS;;;;;;;;;cAExB;AAED,wBAAgB,MAAM,yGAKrB"}

package/dist/type/valibot/provider/MicroblockInformationSchema.d.ts

@@ -0,0 +1,55 @@
+import * as v from 'valibot';
+export declare const MicroblockInformationSchema: v.ObjectSchema<{
+    readonly virtualBlockchainId: 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly feesPayerAccount: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>;
+export type MicroblockInformation = v.InferOutput<typeof MicroblockInformationSchema>;
+//# sourceMappingURL=MicroblockInformationSchema.d.ts.map

package/dist/type/valibot/provider/MicroblockInformationSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MicroblockInformationSchema.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/provider/MicroblockInformationSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAItC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/type/valibot/provider/VirtualBlockchainInfo.d.ts

@@ -0,0 +1,16 @@
+import * as v from 'valibot';
+export declare const VirtualBlockchainInfoSchema: v.ObjectSchema<{
+    readonly virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly virtualBlockchainId: 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 VirtualBlockchainInfo = v.InferOutput<typeof VirtualBlockchainInfoSchema>;
+//# sourceMappingURL=VirtualBlockchainInfo.d.ts.map

package/dist/type/valibot/provider/VirtualBlockchainInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualBlockchainInfo.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/provider/VirtualBlockchainInfo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAO7B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;aAGtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC"}