@haneullabs/haneul 0.1.0

package/dist/cjs/transactions/data/internal.js

@@ -0,0 +1,216 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  $Intent: () => $Intent,
+  ArgumentSchema: () => ArgumentSchema,
+  BCSBytes: () => BCSBytes,
+  CommandSchema: () => CommandSchema,
+  GasDataSchema: () => GasDataSchema,
+  HaneulAddress: () => HaneulAddress,
+  JsonU64: () => JsonU64,
+  NormalizedCallArg: () => NormalizedCallArg,
+  ObjectArgSchema: () => ObjectArgSchema,
+  ObjectID: () => ObjectID,
+  ObjectRefSchema: () => ObjectRefSchema,
+  OpenMoveTypeSignatureBodySchema: () => OpenMoveTypeSignatureBodySchema,
+  OpenMoveTypeSignatureSchema: () => OpenMoveTypeSignatureSchema,
+  StructTagSchema: () => StructTagSchema,
+  TransactionDataSchema: () => TransactionDataSchema,
+  TransactionExpiration: () => TransactionExpiration,
+  safeEnum: () => safeEnum
+});
+module.exports = __toCommonJS(internal_exports);
+var import_valibot = require("valibot");
+var import_haneul_types = require("../../utils/haneul-types.js");
+function safeEnum(options) {
+  const unionOptions = Object.entries(options).map(([key, value]) => (0, import_valibot.object)({ [key]: value }));
+  return (0, import_valibot.pipe)(
+    (0, import_valibot.union)(unionOptions),
+    (0, import_valibot.transform)(
+      (value) => ({
+        ...value,
+        $kind: Object.keys(value)[0]
+      })
+    )
+  );
+}
+const HaneulAddress = (0, import_valibot.pipe)(
+  (0, import_valibot.string)(),
+  (0, import_valibot.transform)((value) => (0, import_haneul_types.normalizeHaneulAddress)(value)),
+  (0, import_valibot.check)(import_haneul_types.isValidHaneulAddress)
+);
+const ObjectID = HaneulAddress;
+const BCSBytes = (0, import_valibot.string)();
+const JsonU64 = (0, import_valibot.pipe)(
+  (0, import_valibot.union)([(0, import_valibot.string)(), (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)())]),
+  (0, import_valibot.check)((val) => {
+    try {
+      BigInt(val);
+      return BigInt(val) >= 0 && BigInt(val) <= 18446744073709551615n;
+    } catch {
+      return false;
+    }
+  }, "Invalid u64")
+);
+const ObjectRefSchema = (0, import_valibot.object)({
+  objectId: HaneulAddress,
+  version: JsonU64,
+  digest: (0, import_valibot.string)()
+});
+const ArgumentSchema = (0, import_valibot.pipe)(
+  (0, import_valibot.union)([
+    (0, import_valibot.object)({ GasCoin: (0, import_valibot.literal)(true) }),
+    (0, import_valibot.object)({ Input: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()), type: (0, import_valibot.optional)((0, import_valibot.literal)("pure")) }),
+    (0, import_valibot.object)({ Input: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()), type: (0, import_valibot.optional)((0, import_valibot.literal)("object")) }),
+    (0, import_valibot.object)({ Result: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()) }),
+    (0, import_valibot.object)({ NestedResult: (0, import_valibot.tuple)([(0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()), (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)())]) })
+  ]),
+  (0, import_valibot.transform)((value) => ({
+    ...value,
+    $kind: Object.keys(value)[0]
+  }))
+  // Defined manually to add `type?: 'pure' | 'object'` to Input
+);
+const GasDataSchema = (0, import_valibot.object)({
+  budget: (0, import_valibot.nullable)(JsonU64),
+  price: (0, import_valibot.nullable)(JsonU64),
+  owner: (0, import_valibot.nullable)(HaneulAddress),
+  payment: (0, import_valibot.nullable)((0, import_valibot.array)(ObjectRefSchema))
+});
+const StructTagSchema = (0, import_valibot.object)({
+  address: (0, import_valibot.string)(),
+  module: (0, import_valibot.string)(),
+  name: (0, import_valibot.string)(),
+  // type_params in rust, should be updated to use camelCase
+  typeParams: (0, import_valibot.array)((0, import_valibot.string)())
+});
+const OpenMoveTypeSignatureBodySchema = (0, import_valibot.union)([
+  (0, import_valibot.literal)("address"),
+  (0, import_valibot.literal)("bool"),
+  (0, import_valibot.literal)("u8"),
+  (0, import_valibot.literal)("u16"),
+  (0, import_valibot.literal)("u32"),
+  (0, import_valibot.literal)("u64"),
+  (0, import_valibot.literal)("u128"),
+  (0, import_valibot.literal)("u256"),
+  (0, import_valibot.object)({ vector: (0, import_valibot.lazy)(() => OpenMoveTypeSignatureBodySchema) }),
+  (0, import_valibot.object)({
+    datatype: (0, import_valibot.object)({
+      package: (0, import_valibot.string)(),
+      module: (0, import_valibot.string)(),
+      type: (0, import_valibot.string)(),
+      typeParameters: (0, import_valibot.array)((0, import_valibot.lazy)(() => OpenMoveTypeSignatureBodySchema))
+    })
+  }),
+  (0, import_valibot.object)({ typeParameter: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()) })
+]);
+const OpenMoveTypeSignatureSchema = (0, import_valibot.object)({
+  ref: (0, import_valibot.nullable)((0, import_valibot.union)([(0, import_valibot.literal)("&"), (0, import_valibot.literal)("&mut")])),
+  body: OpenMoveTypeSignatureBodySchema
+});
+const ProgrammableMoveCallSchema = (0, import_valibot.object)({
+  package: ObjectID,
+  module: (0, import_valibot.string)(),
+  function: (0, import_valibot.string)(),
+  // snake case in rust
+  typeArguments: (0, import_valibot.array)((0, import_valibot.string)()),
+  arguments: (0, import_valibot.array)(ArgumentSchema),
+  _argumentTypes: (0, import_valibot.optional)((0, import_valibot.nullable)((0, import_valibot.array)(OpenMoveTypeSignatureSchema)))
+});
+const $Intent = (0, import_valibot.object)({
+  name: (0, import_valibot.string)(),
+  inputs: (0, import_valibot.record)((0, import_valibot.string)(), (0, import_valibot.union)([ArgumentSchema, (0, import_valibot.array)(ArgumentSchema)])),
+  data: (0, import_valibot.record)((0, import_valibot.string)(), (0, import_valibot.unknown)())
+});
+const CommandSchema = safeEnum({
+  MoveCall: ProgrammableMoveCallSchema,
+  TransferObjects: (0, import_valibot.object)({
+    objects: (0, import_valibot.array)(ArgumentSchema),
+    address: ArgumentSchema
+  }),
+  SplitCoins: (0, import_valibot.object)({
+    coin: ArgumentSchema,
+    amounts: (0, import_valibot.array)(ArgumentSchema)
+  }),
+  MergeCoins: (0, import_valibot.object)({
+    destination: ArgumentSchema,
+    sources: (0, import_valibot.array)(ArgumentSchema)
+  }),
+  Publish: (0, import_valibot.object)({
+    modules: (0, import_valibot.array)(BCSBytes),
+    dependencies: (0, import_valibot.array)(ObjectID)
+  }),
+  MakeMoveVec: (0, import_valibot.object)({
+    type: (0, import_valibot.nullable)((0, import_valibot.string)()),
+    elements: (0, import_valibot.array)(ArgumentSchema)
+  }),
+  Upgrade: (0, import_valibot.object)({
+    modules: (0, import_valibot.array)(BCSBytes),
+    dependencies: (0, import_valibot.array)(ObjectID),
+    package: ObjectID,
+    ticket: ArgumentSchema
+  }),
+  $Intent
+});
+const ObjectArgSchema = safeEnum({
+  ImmOrOwnedObject: ObjectRefSchema,
+  SharedObject: (0, import_valibot.object)({
+    objectId: ObjectID,
+    // snake case in rust
+    initialSharedVersion: JsonU64,
+    mutable: (0, import_valibot.boolean)()
+  }),
+  Receiving: ObjectRefSchema
+});
+const CallArgSchema = safeEnum({
+  Object: ObjectArgSchema,
+  Pure: (0, import_valibot.object)({
+    bytes: BCSBytes
+  }),
+  UnresolvedPure: (0, import_valibot.object)({
+    value: (0, import_valibot.unknown)()
+  }),
+  UnresolvedObject: (0, import_valibot.object)({
+    objectId: ObjectID,
+    version: (0, import_valibot.optional)((0, import_valibot.nullable)(JsonU64)),
+    digest: (0, import_valibot.optional)((0, import_valibot.nullable)((0, import_valibot.string)())),
+    initialSharedVersion: (0, import_valibot.optional)((0, import_valibot.nullable)(JsonU64)),
+    mutable: (0, import_valibot.optional)((0, import_valibot.nullable)((0, import_valibot.boolean)()))
+  })
+});
+const NormalizedCallArg = safeEnum({
+  Object: ObjectArgSchema,
+  Pure: (0, import_valibot.object)({
+    bytes: BCSBytes
+  })
+});
+const TransactionExpiration = safeEnum({
+  None: (0, import_valibot.literal)(true),
+  Epoch: JsonU64
+});
+const TransactionDataSchema = (0, import_valibot.object)({
+  version: (0, import_valibot.literal)(2),
+  sender: (0, import_valibot.nullish)(HaneulAddress),
+  expiration: (0, import_valibot.nullish)(TransactionExpiration),
+  gasData: GasDataSchema,
+  inputs: (0, import_valibot.array)(CallArgSchema),
+  commands: (0, import_valibot.array)(CommandSchema)
+});
+//# sourceMappingURL=internal.js.map

package/dist/cjs/transactions/data/internal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/transactions/data/internal.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { EnumInputShape, EnumOutputShape } from '@haneullabs/bcs';\nimport type { GenericSchema, InferInput, InferOutput } from 'valibot';\nimport {\n\tarray,\n\tboolean,\n\tcheck,\n\tinteger,\n\tlazy,\n\tliteral,\n\tnullable,\n\tnullish,\n\tnumber,\n\tobject,\n\toptional,\n\tpipe,\n\trecord,\n\tstring,\n\ttransform,\n\ttuple,\n\tunion,\n\tunknown,\n} from 'valibot';\n\nimport { isValidHaneulAddress, normalizeHaneulAddress } from '../../utils/haneul-types.js';\nimport type { Simplify } from '@haneullabs/utils';\n\ntype EnumSchemaInput<T extends Record<string, GenericSchema<any>>> = EnumInputShape<\n\tSimplify<{\n\t\t[K in keyof T]: InferInput<T[K]>;\n\t}>\n>;\n\ntype EnumSchemaOutput<T extends Record<string, GenericSchema<any>>> = EnumOutputShape<\n\tSimplify<{\n\t\t[K in keyof T]: InferOutput<T[K]>;\n\t}>\n>;\n\ntype EnumSchema<T extends Record<string, GenericSchema<any>>> = GenericSchema<\n\tEnumSchemaInput<T>,\n\tEnumSchemaOutput<T>\n>;\n\nexport function safeEnum<T extends Record<string, GenericSchema<any>>>(options: T): EnumSchema<T> {\n\tconst unionOptions = Object.entries(options).map(([key, value]) => object({ [key]: value }));\n\n\treturn pipe(\n\t\tunion(unionOptions),\n\t\ttransform(\n\t\t\t(value) =>\n\t\t\t\t({\n\t\t\t\t\t...value,\n\t\t\t\t\t$kind: Object.keys(value)[0] as keyof typeof value,\n\t\t\t\t}) as EnumSchemaOutput<T>,\n\t\t),\n\t) as EnumSchema<T>;\n}\n\nexport const HaneulAddress = pipe(\n\tstring(),\n\ttransform((value) => normalizeHaneulAddress(value)),\n\tcheck(isValidHaneulAddress),\n);\nexport const ObjectID = HaneulAddress;\nexport const BCSBytes = string();\nexport const JsonU64 = pipe(\n\tunion([string(), pipe(number(), integer())]),\n\n\tcheck((val) => {\n\t\ttry {\n\t\t\tBigInt(val);\n\t\t\treturn BigInt(val) >= 0 && BigInt(val) <= 18446744073709551615n;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}, 'Invalid u64'),\n);\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/base_types.rs#L138\n// Implemented as a tuple in rust\nexport const ObjectRefSchema = object({\n\tobjectId: HaneulAddress,\n\tversion: JsonU64,\n\tdigest: string(),\n});\nexport type ObjectRef = InferOutput<typeof ObjectRefSchema>;\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L690-L702\nexport const ArgumentSchema = pipe(\n\tunion([\n\t\tobject({ GasCoin: literal(true) }),\n\t\tobject({ Input: pipe(number(), integer()), type: optional(literal('pure')) }),\n\t\tobject({ Input: pipe(number(), integer()), type: optional(literal('object')) }),\n\t\tobject({ Result: pipe(number(), integer()) }),\n\t\tobject({ NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]) }),\n\t]),\n\ttransform((value) => ({\n\t\t...value,\n\t\t$kind: Object.keys(value)[0] as keyof typeof value,\n\t})),\n\t// Defined manually to add `type?: 'pure' | 'object'` to Input\n) as GenericSchema<\n\t// Input\n\t| { GasCoin: true }\n\t| { Input: number; type?: 'pure' | 'object' }\n\t| { Result: number }\n\t| { NestedResult: [number, number] },\n\t// Output\n\t| { $kind: 'GasCoin'; GasCoin: true }\n\t| { $kind: 'Input'; Input: number; type?: 'pure' }\n\t| { $kind: 'Input'; Input: number; type?: 'object' }\n\t| { $kind: 'Result'; Result: number }\n\t| { $kind: 'NestedResult'; NestedResult: [number, number] }\n>;\n\nexport type Argument = InferOutput<typeof ArgumentSchema>;\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L1387-L1392\nexport const GasDataSchema = object({\n\tbudget: nullable(JsonU64),\n\tprice: nullable(JsonU64),\n\towner: nullable(HaneulAddress),\n\tpayment: nullable(array(ObjectRefSchema)),\n});\nexport type GasData = InferOutput<typeof GasDataSchema>;\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/external-crates/move/crates/move-core-types/src/language_storage.rs#L140-L147\nexport const StructTagSchema = object({\n\taddress: string(),\n\tmodule: string(),\n\tname: string(),\n\t// type_params in rust, should be updated to use camelCase\n\ttypeParams: array(string()),\n});\nexport type StructTag = InferOutput<typeof StructTagSchema>;\n\n// https://github.com/GeunhwaJeong/haneul/blob/cea8742e810142a8145fd83c4c142d61e561004a/crates/sui-graphql-rpc/schema/current_progress_schema.graphql#L1614-L1627\nexport type OpenMoveTypeSignatureBody =\n\t| 'address'\n\t| 'bool'\n\t| 'u8'\n\t| 'u16'\n\t| 'u32'\n\t| 'u64'\n\t| 'u128'\n\t| 'u256'\n\t| { vector: OpenMoveTypeSignatureBody }\n\t| {\n\t\t\tdatatype: {\n\t\t\t\tpackage: string;\n\t\t\t\tmodule: string;\n\t\t\t\ttype: string;\n\t\t\t\ttypeParameters: OpenMoveTypeSignatureBody[];\n\t\t\t};\n\t  }\n\t| { typeParameter: number };\n\nexport const OpenMoveTypeSignatureBodySchema: GenericSchema<OpenMoveTypeSignatureBody> = union([\n\tliteral('address'),\n\tliteral('bool'),\n\tliteral('u8'),\n\tliteral('u16'),\n\tliteral('u32'),\n\tliteral('u64'),\n\tliteral('u128'),\n\tliteral('u256'),\n\tobject({ vector: lazy(() => OpenMoveTypeSignatureBodySchema) }),\n\tobject({\n\t\tdatatype: object({\n\t\t\tpackage: string(),\n\t\t\tmodule: string(),\n\t\t\ttype: string(),\n\t\t\ttypeParameters: array(lazy(() => OpenMoveTypeSignatureBodySchema)),\n\t\t}),\n\t}),\n\tobject({ typeParameter: pipe(number(), integer()) }),\n]);\n\n// https://github.com/GeunhwaJeong/haneul/blob/cea8742e810142a8145fd83c4c142d61e561004a/crates/sui-graphql-rpc/schema/current_progress_schema.graphql#L1609-L1612\nexport const OpenMoveTypeSignatureSchema = object({\n\tref: nullable(union([literal('&'), literal('&mut')])),\n\tbody: OpenMoveTypeSignatureBodySchema,\n});\nexport type OpenMoveTypeSignature = InferOutput<typeof OpenMoveTypeSignatureSchema>;\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L707-L718\nconst ProgrammableMoveCallSchema = object({\n\tpackage: ObjectID,\n\tmodule: string(),\n\tfunction: string(),\n\t// snake case in rust\n\ttypeArguments: array(string()),\n\targuments: array(ArgumentSchema),\n\t_argumentTypes: optional(nullable(array(OpenMoveTypeSignatureSchema))),\n});\nexport type ProgrammableMoveCall = InferOutput<typeof ProgrammableMoveCallSchema>;\n\nexport const $Intent = object({\n\tname: string(),\n\tinputs: record(string(), union([ArgumentSchema, array(ArgumentSchema)])),\n\tdata: record(string(), unknown()),\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L657-L685\nexport const CommandSchema = safeEnum({\n\tMoveCall: ProgrammableMoveCallSchema,\n\tTransferObjects: object({\n\t\tobjects: array(ArgumentSchema),\n\t\taddress: ArgumentSchema,\n\t}),\n\tSplitCoins: object({\n\t\tcoin: ArgumentSchema,\n\t\tamounts: array(ArgumentSchema),\n\t}),\n\tMergeCoins: object({\n\t\tdestination: ArgumentSchema,\n\t\tsources: array(ArgumentSchema),\n\t}),\n\tPublish: object({\n\t\tmodules: array(BCSBytes),\n\t\tdependencies: array(ObjectID),\n\t}),\n\tMakeMoveVec: object({\n\t\ttype: nullable(string()),\n\t\telements: array(ArgumentSchema),\n\t}),\n\tUpgrade: object({\n\t\tmodules: array(BCSBytes),\n\t\tdependencies: array(ObjectID),\n\t\tpackage: ObjectID,\n\t\tticket: ArgumentSchema,\n\t}),\n\t$Intent,\n});\n\nexport type Command<Arg = Argument> = EnumOutputShape<{\n\tMoveCall: {\n\t\tpackage: string;\n\t\tmodule: string;\n\t\tfunction: string;\n\t\ttypeArguments: string[];\n\t\targuments: Arg[];\n\t\t_argumentTypes?: OpenMoveTypeSignature[] | null;\n\t};\n\tTransferObjects: {\n\t\tobjects: Arg[];\n\t\taddress: Arg;\n\t};\n\tSplitCoins: {\n\t\tcoin: Arg;\n\t\tamounts: Arg[];\n\t};\n\tMergeCoins: {\n\t\tdestination: Arg;\n\t\tsources: Arg[];\n\t};\n\tPublish: {\n\t\tmodules: string[];\n\t\tdependencies: string[];\n\t};\n\tMakeMoveVec: {\n\t\ttype: string | null;\n\t\telements: Arg[];\n\t};\n\tUpgrade: {\n\t\tmodules: string[];\n\t\tdependencies: string[];\n\t\tpackage: string;\n\t\tticket: Arg;\n\t};\n\t$Intent: {\n\t\tname: string;\n\t\tinputs: Record<string, Argument | Argument[]>;\n\t\tdata: Record<string, unknown>;\n\t};\n}>;\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L102-L114\nexport const ObjectArgSchema = safeEnum({\n\tImmOrOwnedObject: ObjectRefSchema,\n\tSharedObject: object({\n\t\tobjectId: ObjectID,\n\t\t// snake case in rust\n\t\tinitialSharedVersion: JsonU64,\n\t\tmutable: boolean(),\n\t}),\n\tReceiving: ObjectRefSchema,\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L75-L80\nconst CallArgSchema = safeEnum({\n\tObject: ObjectArgSchema,\n\tPure: object({\n\t\tbytes: BCSBytes,\n\t}),\n\tUnresolvedPure: object({\n\t\tvalue: unknown(),\n\t}),\n\tUnresolvedObject: object({\n\t\tobjectId: ObjectID,\n\t\tversion: optional(nullable(JsonU64)),\n\t\tdigest: optional(nullable(string())),\n\t\tinitialSharedVersion: optional(nullable(JsonU64)),\n\t\tmutable: optional(nullable(boolean())),\n\t}),\n});\nexport type CallArg = InferOutput<typeof CallArgSchema>;\n\nexport const NormalizedCallArg = safeEnum({\n\tObject: ObjectArgSchema,\n\tPure: object({\n\t\tbytes: BCSBytes,\n\t}),\n});\n\nexport const TransactionExpiration = safeEnum({\n\tNone: literal(true),\n\tEpoch: JsonU64,\n});\n\nexport type TransactionExpiration = InferOutput<typeof TransactionExpiration>;\n\nexport const TransactionDataSchema = object({\n\tversion: literal(2),\n\tsender: nullish(HaneulAddress),\n\texpiration: nullish(TransactionExpiration),\n\tgasData: GasDataSchema,\n\tinputs: array(CallArgSchema),\n\tcommands: array(CommandSchema),\n});\n\nexport type TransactionData = InferOutput<typeof TransactionDataSchema>;\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/transactions/data/v1.d.ts

@@ -0,0 +1,312 @@
+import type { GenericSchema, InferOutput } from 'valibot';
+import type { StructTag as StructTagType, TypeTag as TypeTagType } from '../../bcs/types.js';
+import type { TransactionData } from './internal.js';
+export declare const ObjectRef: import("valibot").ObjectSchema<{
+    readonly digest: import("valibot").StringSchema<undefined>;
+    readonly objectId: import("valibot").StringSchema<undefined>;
+    readonly version: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>;
+}, undefined>;
+export declare const NormalizedCallArg: import("valibot").BaseSchema<{
+    Pure: number[];
+} | {
+    Object: {
+        Receiving: {
+            digest: string;
+            objectId: string;
+            version: string | number | bigint;
+        };
+    } | {
+        Shared: {
+            objectId: string;
+            initialSharedVersion: string | number;
+            mutable: boolean;
+        };
+    } | {
+        ImmOrOwned: {
+            digest: string;
+            objectId: string;
+            version: string | number | bigint;
+        };
+    };
+}, import("@haneullabs/bcs").EnumOutputShapeWithKeys<{
+    Object: import("@haneullabs/bcs").EnumOutputShapeWithKeys<{
+        ImmOrOwned: {
+            digest: string;
+            objectId: string;
+            version: string | number | bigint;
+        };
+        Shared: {
+            objectId: string;
+            initialSharedVersion: string | number;
+            mutable: boolean;
+        };
+        Receiving: {
+            digest: string;
+            objectId: string;
+            version: string | number | bigint;
+        };
+    }, "Receiving" | "Shared" | "ImmOrOwned">;
+    Pure: number[];
+}, "Pure" | "Object">, import("valibot").BaseIssue<unknown>>;
+export declare const TypeTag: GenericSchema<TypeTagType>;
+export declare const StructTag: GenericSchema<StructTagType>;
+export declare const TransactionArgument: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+    readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+    readonly value: import("valibot").UnknownSchema;
+    readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+    readonly value: import("valibot").UnknownSchema;
+    readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+}, undefined>], undefined>, import("valibot").ObjectSchema<{
+    readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+    readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+}, undefined>], undefined>;
+export declare const SerializedTransactionDataV1: import("valibot").ObjectSchema<{
+    readonly version: import("valibot").LiteralSchema<1, undefined>;
+    readonly sender: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly expiration: import("valibot").NullishSchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly Epoch: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly None: import("valibot").NullableSchema<import("valibot").LiteralSchema<true, undefined>, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly gasConfig: import("valibot").ObjectSchema<{
+        readonly budget: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").NumberSchema<undefined>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>, import("valibot").CheckAction<string | number | bigint, undefined>]>, undefined>;
+        readonly price: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").NumberSchema<undefined>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>, import("valibot").CheckAction<string | number | bigint, undefined>]>, undefined>;
+        readonly payment: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly digest: import("valibot").StringSchema<undefined>;
+            readonly objectId: import("valibot").StringSchema<undefined>;
+            readonly version: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>;
+        }, undefined>, undefined>, undefined>;
+        readonly owner: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly inputs: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+        readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        readonly value: import("valibot").UnknownSchema;
+        readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+        readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        readonly value: import("valibot").UnknownSchema;
+        readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly transactions: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"MoveCall", undefined>;
+        readonly target: GenericSchema<`${string}::${string}::${string}`>;
+        readonly typeArguments: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly arguments: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"TransferObjects", undefined>;
+        readonly objects: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>, undefined>;
+        readonly address: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"SplitCoins", undefined>;
+        readonly coin: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>;
+        readonly amounts: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"MergeCoins", undefined>;
+        readonly destination: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>;
+        readonly sources: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"Publish", undefined>;
+        readonly modules: import("valibot").ArraySchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, undefined>, undefined>;
+        readonly dependencies: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"Upgrade", undefined>;
+        readonly modules: import("valibot").ArraySchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, undefined>, undefined>;
+        readonly dependencies: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly packageId: import("valibot").StringSchema<undefined>;
+        readonly ticket: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly kind: import("valibot").LiteralSchema<"MakeMoveVec", undefined>;
+        readonly type: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly Some: GenericSchema<TypeTagType>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly None: import("valibot").NullableSchema<import("valibot").LiteralSchema<true, undefined>, undefined>;
+        }, undefined>], undefined>;
+        readonly objects: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly value: import("valibot").UnknownSchema;
+            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
+        }, undefined>], undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
+            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>;
+export type SerializedTransactionDataV1 = InferOutput<typeof SerializedTransactionDataV1>;
+export declare function serializeV1TransactionData(transactionData: TransactionData): SerializedTransactionDataV1;
+export declare function transactionDataFromV1(data: SerializedTransactionDataV1): TransactionData;