sui-effect 0.1.0

package/dist/domain/schemas.d.ts

@@ -0,0 +1,950 @@
+/**
+ * Branded schemas and the transport-neutral object model.
+ *
+ * Every schema here decodes from the shape `@mysten/sui` returns, so a raw SDK
+ * response can be validated at the boundary with one `Schema.decodeUnknownEffect`
+ * call. Names mirror the SDK names they model.
+ *
+ * @since 0.1.0
+ */
+import type { SuiClientTypes } from "@mysten/sui/client";
+import { Schema } from "effect";
+/**
+ * A 32-byte Sui account address, normalized to the padded lowercase `0x` form on
+ * decode. Rejects anything `isValidSuiAddress` rejects with a `SchemaError`.
+ */
+export declare const SuiAddress: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+export type SuiAddress = typeof SuiAddress.Type;
+/**
+ * A 32-byte object id. Same encoding rules as {@link SuiAddress}; the brand is
+ * separate so an address cannot be passed where an object id is expected.
+ */
+export declare const ObjectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+export type ObjectId = typeof ObjectId.Type;
+/** A base58 transaction digest. Not normalized; rejected when not 32 bytes. */
+export declare const Digest: Schema.brand<Schema.String, "Digest">;
+export type Digest = typeof Digest.Type;
+/**
+ * A fully qualified Move struct tag, normalized with `normalizeStructTag` on
+ * decode so `0x2::sui::SUI` and its padded form compare equal.
+ */
+export declare const StructTag: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "StructTag">;
+export type StructTag = typeof StructTag.Type;
+/** A coin type: a struct tag used as the type argument of `0x2::coin::Coin`. */
+export declare const CoinType: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "CoinType">;
+export type CoinType = typeof CoinType.Type;
+/**
+ * The `type` field of an object envelope. Almost always a struct tag, but gRPC
+ * reports the literal `package` for a Move package object (`grpc/core.mjs`
+ * leaves `objectType` untouched when it has no `::`), and a package is a
+ * readable object like any other.
+ */
+export declare const ObjectType: Schema.Union<readonly [Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "StructTag">, Schema.Literal<"package">]>;
+export type ObjectType = typeof ObjectType.Type;
+/** An amount in MIST. Encoded as the decimal string every SDK response uses. */
+export declare const Mist: Schema.brand<Schema.BigIntFromString, "Mist">;
+export type Mist = typeof Mist.Type;
+/** A Move object version. Encoded as the decimal string the SDK returns. */
+export declare const Version: Schema.brand<Schema.BigIntFromString, "Version">;
+export type Version = typeof Version.Type;
+/** The network a client is pointed at. Mirrors `SuiClientTypes.Network`. */
+export declare const Network: Schema.brand<Schema.String, "Network">;
+export type Network = typeof Network.Type;
+/** The four networks with a built-in default gRPC endpoint. */
+export declare const KnownNetwork: Schema.Literals<readonly ["mainnet", "testnet", "devnet", "localnet"]>;
+export type KnownNetwork = typeof KnownNetwork.Type;
+/**
+ * The genesis checkpoint digest of each public network whose chain identifier
+ * is fixed and known. These are the digests observed on the live networks
+ * (`getChainIdentifier` returns the genesis checkpoint digest); the SDK ships
+ * no such table. `devnet` and `localnet` are regenerated, so they are absent
+ * and `Sui.layerNoDeps` records whatever the node reports instead of asserting.
+ */
+export declare const KNOWN_CHAIN_IDS: Readonly<Record<string, string>>;
+/**
+ * An object owner. Mirrors `SuiClientTypes.ObjectOwner` exactly, including its
+ * `$kind` discriminant, so `Owner.match` and the SDK's own narrowing agree.
+ */
+export declare const Owner: Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+    readonly $kind: Schema.Literal<"AddressOwner">;
+    readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"ObjectOwner">;
+    readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"Shared">;
+    readonly Shared: Schema.Struct<{
+        readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"Immutable">;
+    readonly Immutable: Schema.Literal<true>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+    readonly ConsensusAddressOwner: Schema.Struct<{
+        readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+        readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"Unknown">;
+}>]>;
+export type Owner = typeof Owner.Type;
+/**
+ * Everything the transaction builder needs to consume an object again, plus the
+ * type and owner so a caller can tell a shared object from an owned one.
+ */
+export declare const ObjectRef: Schema.Struct<{
+    readonly id: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly type: Schema.Union<readonly [Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "StructTag">, Schema.Literal<"package">]>;
+    readonly version: Schema.brand<Schema.BigIntFromString, "Version">;
+    readonly digest: Schema.String;
+    readonly owner: Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+        readonly $kind: Schema.Literal<"AddressOwner">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ObjectOwner">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Shared">;
+        readonly Shared: Schema.Struct<{
+            readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Immutable">;
+        readonly Immutable: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+        readonly ConsensusAddressOwner: Schema.Struct<{
+            readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Unknown">;
+    }>]>;
+}>;
+export type ObjectRef = typeof ObjectRef.Type;
+/** A coin balance for one coin type. Mirrors `SuiClientTypes.Balance`. */
+export declare const Balance: Schema.Struct<{
+    readonly coinType: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "CoinType">;
+    readonly balance: Schema.brand<Schema.BigIntFromString, "Mist">;
+    readonly coinBalance: Schema.brand<Schema.BigIntFromString, "Mist">;
+    readonly addressBalance: Schema.brand<Schema.BigIntFromString, "Mist">;
+}>;
+export type Balance = typeof Balance.Type;
+/** The BCS-encoded name of a dynamic field. Mirrors `SuiClientTypes.DynamicFieldName`. */
+export declare const DynamicFieldName: Schema.Struct<{
+    readonly type: Schema.String;
+    readonly bcs: Schema.Uint8Array;
+}>;
+export type DynamicFieldName = typeof DynamicFieldName.Type;
+/** One entry of a dynamic-field listing. Mirrors `SuiClientTypes.DynamicFieldEntry`. */
+export declare const DynamicFieldEntry: Schema.Struct<{
+    readonly fieldId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly type: Schema.String;
+    readonly name: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly bcs: Schema.Uint8Array;
+    }>;
+    readonly valueType: Schema.String;
+    readonly $kind: Schema.Literals<readonly ["DynamicField", "DynamicObject"]>;
+    readonly childId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">>;
+}>;
+export type DynamicFieldEntry = typeof DynamicFieldEntry.Type;
+/** A dynamic field with its value. Mirrors `SuiClientTypes.DynamicField`. */
+export declare const DynamicField: Schema.Struct<{
+    readonly fieldId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly type: Schema.String;
+    readonly name: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly bcs: Schema.Uint8Array;
+    }>;
+    readonly valueType: Schema.String;
+    readonly $kind: Schema.Literals<readonly ["DynamicField", "DynamicObject"]>;
+    readonly childId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">>;
+    readonly value: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly bcs: Schema.Uint8Array;
+    }>;
+    readonly version: Schema.brand<Schema.BigIntFromString, "Version">;
+    readonly digest: Schema.String;
+}>;
+export type DynamicField = typeof DynamicField.Type;
+/** Gas cost breakdown. Mirrors `SuiClientTypes.GasCostSummary`. */
+export declare const GasCostSummary: Schema.Struct<{
+    readonly computationCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+    readonly storageCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+    readonly storageRebate: Schema.brand<Schema.BigIntFromString, "Mist">;
+    readonly nonRefundableStorageFee: Schema.brand<Schema.BigIntFromString, "Mist">;
+}>;
+export type GasCostSummary = typeof GasCostSummary.Type;
+/** One object touched by a transaction. Mirrors `SuiClientTypes.ChangedObject`. */
+export declare const ChangedObject: Schema.Struct<{
+    readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+    readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+    readonly inputDigest: Schema.NullOr<Schema.String>;
+    readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+        readonly $kind: Schema.Literal<"AddressOwner">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ObjectOwner">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Shared">;
+        readonly Shared: Schema.Struct<{
+            readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Immutable">;
+        readonly Immutable: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+        readonly ConsensusAddressOwner: Schema.Struct<{
+            readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Unknown">;
+    }>]>>;
+    readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+    readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+    readonly outputDigest: Schema.NullOr<Schema.String>;
+    readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+        readonly $kind: Schema.Literal<"AddressOwner">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ObjectOwner">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Shared">;
+        readonly Shared: Schema.Struct<{
+            readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Immutable">;
+        readonly Immutable: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+        readonly ConsensusAddressOwner: Schema.Struct<{
+            readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Unknown">;
+    }>]>>;
+    readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+}>;
+export type ChangedObject = typeof ChangedObject.Type;
+/** Mirrors `SuiClientTypes.UnchangedConsensusObject`. */
+export declare const UnchangedConsensusObject: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["Unknown", "ReadOnlyRoot", "MutateConsensusStreamEnded", "ReadConsensusStreamEnded", "Cancelled", "PerEpochConfig"]>;
+    readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly version: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+    readonly digest: Schema.NullOr<Schema.String>;
+}>;
+export type UnchangedConsensusObject = typeof UnchangedConsensusObject.Type;
+/** A balance delta produced by a transaction. Mirrors `SuiClientTypes.BalanceChange`. */
+export declare const BalanceChange: Schema.Struct<{
+    readonly coinType: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "CoinType">;
+    readonly address: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    readonly amount: Schema.BigIntFromString;
+}>;
+export type BalanceChange = typeof BalanceChange.Type;
+/** An emitted Move event. Mirrors `SuiClientTypes.Event`; `json` is dropped on purpose. */
+export declare const Event: Schema.Struct<{
+    readonly packageId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly module: Schema.String;
+    readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    readonly eventType: Schema.String;
+    readonly bcs: Schema.Uint8Array;
+}>;
+export type Event = typeof Event.Type;
+/**
+ * Where a Move abort happened. Mirrors `SuiClientTypes.MoveLocation`.
+ *
+ * `package` stays a plain string because the node may report a location for a
+ * package that no longer parses as an object id.
+ */
+export declare const MoveLocation: Schema.Struct<{
+    readonly package: Schema.optional<Schema.String>;
+    readonly module: Schema.optional<Schema.String>;
+    readonly function: Schema.optional<Schema.Number>;
+    readonly functionName: Schema.optional<Schema.String>;
+    readonly instruction: Schema.optional<Schema.Number>;
+}>;
+export type MoveLocation = typeof MoveLocation.Type;
+/** A decoded `#[error]` constant. Mirrors `SuiClientTypes.CleverError`. */
+export declare const CleverError: Schema.Struct<{
+    readonly errorCode: Schema.optional<Schema.Number>;
+    readonly lineNumber: Schema.optional<Schema.Number>;
+    readonly constantName: Schema.optional<Schema.String>;
+    readonly constantType: Schema.optional<Schema.String>;
+    readonly value: Schema.optional<Schema.String>;
+}>;
+export type CleverError = typeof CleverError.Type;
+/**
+ * Why a transaction failed on chain or in simulation. Mirrors
+ * `SuiClientTypes.ExecutionError` variant for variant, including its `$kind`
+ * discriminant, with two differences: `abortCode` is decoded to `bigint`, and
+ * the shared `message` and `command` fields live on the error class that
+ * carries the reason rather than being repeated in every variant.
+ */
+export declare const ExecutionReason: Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+    readonly $kind: Schema.Literal<"MoveAbort">;
+    readonly MoveAbort: Schema.Struct<{
+        readonly abortCode: Schema.BigIntFromString;
+        readonly location: Schema.optional<Schema.Struct<{
+            readonly package: Schema.optional<Schema.String>;
+            readonly module: Schema.optional<Schema.String>;
+            readonly function: Schema.optional<Schema.Number>;
+            readonly functionName: Schema.optional<Schema.String>;
+            readonly instruction: Schema.optional<Schema.Number>;
+        }>>;
+        readonly cleverError: Schema.optional<Schema.Struct<{
+            readonly errorCode: Schema.optional<Schema.Number>;
+            readonly lineNumber: Schema.optional<Schema.Number>;
+            readonly constantName: Schema.optional<Schema.String>;
+            readonly constantType: Schema.optional<Schema.String>;
+            readonly value: Schema.optional<Schema.String>;
+        }>>;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"SizeError">;
+    readonly SizeError: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly size: Schema.Number;
+        readonly maxSize: Schema.Number;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"CommandArgumentError">;
+    readonly CommandArgumentError: Schema.Struct<{
+        readonly argument: Schema.Number;
+        readonly name: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"TypeArgumentError">;
+    readonly TypeArgumentError: Schema.Struct<{
+        readonly typeArgument: Schema.Number;
+        readonly name: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"PackageUpgradeError">;
+    readonly PackageUpgradeError: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly packageId: Schema.optional<Schema.String>;
+        readonly digest: Schema.optional<Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"IndexError">;
+    readonly IndexError: Schema.Struct<{
+        readonly index: Schema.optional<Schema.Number>;
+        readonly subresult: Schema.optional<Schema.Number>;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"CoinDenyListError">;
+    readonly CoinDenyListError: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly coinType: Schema.String;
+        readonly address: Schema.optional<Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"CongestedObjects">;
+    readonly CongestedObjects: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly objects: Schema.$Array<Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"ObjectIdError">;
+    readonly ObjectIdError: Schema.Struct<{
+        readonly name: Schema.optional<Schema.String>;
+        readonly objectId: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"Unknown">;
+}>]>;
+export type ExecutionReason = typeof ExecutionReason.Type;
+/**
+ * Whether a transaction succeeded. Mirrors `SuiClientTypes.ExecutionStatus`
+ * minus its `error` payload: the failure detail is carried by `ExecutionFailed`
+ * and `SimulationFailed` as an {@link ExecutionReason}, so there is exactly one
+ * representation of an on-chain failure.
+ */
+export declare const ExecutionStatus: Schema.Struct<{
+    readonly success: Schema.Boolean;
+}>;
+export type ExecutionStatus = typeof ExecutionStatus.Type;
+/** Transaction effects. Mirrors `SuiClientTypes.TransactionEffects`. */
+export declare const TransactionEffects: Schema.Struct<{
+    readonly version: Schema.Number;
+    readonly status: Schema.Struct<{
+        readonly success: Schema.Boolean;
+    }>;
+    readonly gasUsed: Schema.Struct<{
+        readonly computationCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+        readonly storageCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+        readonly storageRebate: Schema.brand<Schema.BigIntFromString, "Mist">;
+        readonly nonRefundableStorageFee: Schema.brand<Schema.BigIntFromString, "Mist">;
+    }>;
+    readonly transactionDigest: Schema.brand<Schema.String, "Digest">;
+    readonly gasObject: Schema.NullOr<Schema.Struct<{
+        readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+        readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly inputDigest: Schema.NullOr<Schema.String>;
+        readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+            readonly $kind: Schema.Literal<"AddressOwner">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ObjectOwner">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Shared">;
+            readonly Shared: Schema.Struct<{
+                readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Immutable">;
+            readonly Immutable: Schema.Literal<true>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+            readonly ConsensusAddressOwner: Schema.Struct<{
+                readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Unknown">;
+        }>]>>;
+        readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+        readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly outputDigest: Schema.NullOr<Schema.String>;
+        readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+            readonly $kind: Schema.Literal<"AddressOwner">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ObjectOwner">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Shared">;
+            readonly Shared: Schema.Struct<{
+                readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Immutable">;
+            readonly Immutable: Schema.Literal<true>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+            readonly ConsensusAddressOwner: Schema.Struct<{
+                readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Unknown">;
+        }>]>>;
+        readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+    }>>;
+    readonly eventsDigest: Schema.NullOr<Schema.String>;
+    readonly dependencies: Schema.$Array<Schema.String>;
+    readonly lamportVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+    readonly changedObjects: Schema.$Array<Schema.Struct<{
+        readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+        readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly inputDigest: Schema.NullOr<Schema.String>;
+        readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+            readonly $kind: Schema.Literal<"AddressOwner">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ObjectOwner">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Shared">;
+            readonly Shared: Schema.Struct<{
+                readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Immutable">;
+            readonly Immutable: Schema.Literal<true>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+            readonly ConsensusAddressOwner: Schema.Struct<{
+                readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Unknown">;
+        }>]>>;
+        readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+        readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly outputDigest: Schema.NullOr<Schema.String>;
+        readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+            readonly $kind: Schema.Literal<"AddressOwner">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ObjectOwner">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Shared">;
+            readonly Shared: Schema.Struct<{
+                readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Immutable">;
+            readonly Immutable: Schema.Literal<true>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+            readonly ConsensusAddressOwner: Schema.Struct<{
+                readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Unknown">;
+        }>]>>;
+        readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+    }>>;
+    readonly unchangedConsensusObjects: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["Unknown", "ReadOnlyRoot", "MutateConsensusStreamEnded", "ReadConsensusStreamEnded", "Cancelled", "PerEpochConfig"]>;
+        readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly version: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly digest: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly auxiliaryDataDigest: Schema.NullOr<Schema.String>;
+}>;
+export type TransactionEffects = typeof TransactionEffects.Type;
+/**
+ * A serialized signature, as every SDK signer returns it: the base64 of the
+ * flag, signature and public key bytes. Branded so a signature cannot be passed
+ * where a digest or an address is expected.
+ */
+export declare const Signature: Schema.brand<Schema.String, "Signature">;
+export type Signature = typeof Signature.Type;
+/** The largest value a Move `u64` can hold. */
+export declare const U64_MAX = 18446744073709551615n;
+/** The largest value a Move `u32` can hold, which is the nonce's range. */
+export declare const U32_MAX = 4294967295;
+/**
+ * When a transaction stops being valid. Mirrors the SDK's
+ * `TransactionExpiration` enum variant for variant, including its `$kind`
+ * discriminant, so our narrowing and `TransactionDataBuilder`'s agree.
+ *
+ * `ValidDuring` is what `Tx.build` sets by default, bounded by **epochs**:
+ * `maxTimestamp` is `null` unless `SubmitConfig.validFor` asks for one, because
+ * no Sui network accepts a timestamp expiration yet. Its `chain` is a replay
+ * guard, so bytes signed for testnet cannot land on mainnet.
+ */
+export declare const TransactionExpiration: Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+    readonly $kind: Schema.Literal<"None">;
+    readonly None: Schema.Literal<true>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"Epoch">;
+    readonly Epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"ValidDuring">;
+    readonly ValidDuring: Schema.Struct<{
+        readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly chain: Schema.String;
+        readonly nonce: Schema.Number;
+    }>;
+}>, Schema.Struct<{
+    readonly $kind: Schema.Literal<"Validity">;
+    readonly Validity: Schema.Struct<{
+        readonly allowedProposers: Schema.NullOr<Schema.Struct<{
+            readonly epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+            readonly proposers: Schema.$Array<Schema.Number>;
+        }>>;
+        readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+        readonly chain: Schema.String;
+        readonly nonce: Schema.Number;
+    }>;
+}>]>;
+export type TransactionExpiration = typeof TransactionExpiration.Type;
+/**
+ * The signed bytes of a transaction, kept so an uncertain submission can be
+ * reconciled or re-submitted later without rebuilding.
+ *
+ * The expiration the transaction was built with rides along, because it is what
+ * `Tx.reconcile` needs to decide that a transaction can no longer land.
+ *
+ * `bytes` encodes as base64, not as a numeric object, so `SuiError.toJson` of a
+ * `SubmissionUnknown` is JSON the operator who has to reconcile it can read.
+ */
+export declare const SignedTransaction: Schema.Struct<{
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly signatures: Schema.$Array<Schema.brand<Schema.String, "Signature">>;
+    readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    readonly expiration: Schema.optional<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+        readonly $kind: Schema.Literal<"None">;
+        readonly None: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Epoch">;
+        readonly Epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ValidDuring">;
+        readonly ValidDuring: Schema.Struct<{
+            readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly chain: Schema.String;
+            readonly nonce: Schema.Number;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Validity">;
+        readonly Validity: Schema.Struct<{
+            readonly allowedProposers: Schema.NullOr<Schema.Struct<{
+                readonly epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+                readonly proposers: Schema.$Array<Schema.Number>;
+            }>>;
+            readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly chain: Schema.String;
+            readonly nonce: Schema.Number;
+        }>;
+    }>]>>;
+    /**
+     * The chain identifier the bytes were built against, recorded by `Tx.build`
+     * so `Tx.reconcile` can refuse to reason about a transaction with a node on
+     * another chain.
+     *
+     * A `ValidDuring` or `Validity` expiration already names its chain, and that
+     * is what is compared when it is there. This field is what an `Epoch` or
+     * `None` expiration — which name no chain at all — leaves behind instead, so
+     * a process-wide journal holding submissions from two networks cannot settle
+     * one of them against the other's epoch.
+     */
+    readonly chain: Schema.optional<Schema.String>;
+}>;
+export type SignedTransaction = typeof SignedTransaction.Type;
+/**
+ * Why a transaction provably never applied, and never will.
+ *
+ * `"expired"`: the expiration window was observed closed — the current epoch
+ * past the recorded `maxEpoch`, or `chainTime` past a recorded `maxTimestamp`
+ * by more than `SubmitConfig.expiryMargin` — around a `getTransaction` miss,
+ * twice. `"inputConsumed"`: a **different** transaction's own effects report
+ * that it took an object these bytes pinned at exactly the version they pinned.
+ *
+ * Shared by `NotApplied` and by the journal entry that records it, so the two
+ * cannot drift.
+ */
+export declare const NotAppliedEvidence: Schema.Literals<readonly ["expired", "inputConsumed"]>;
+export type NotAppliedEvidence = typeof NotAppliedEvidence.Type;
+/**
+ * A transaction built into bytes and ready to sign, with the expiration the
+ * builder settled on recorded so `Tx.reconcile` can decide, later and without
+ * the builder, whether the transaction can still land.
+ */
+export declare const Built: Schema.Struct<{
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    readonly gasOwner: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">>;
+    readonly expiration: Schema.optional<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+        readonly $kind: Schema.Literal<"None">;
+        readonly None: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Epoch">;
+        readonly Epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ValidDuring">;
+        readonly ValidDuring: Schema.Struct<{
+            readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly chain: Schema.String;
+            readonly nonce: Schema.Number;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Validity">;
+        readonly Validity: Schema.Struct<{
+            readonly allowedProposers: Schema.NullOr<Schema.Struct<{
+                readonly epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+                readonly proposers: Schema.$Array<Schema.Number>;
+            }>>;
+            readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+            readonly chain: Schema.String;
+            readonly nonce: Schema.Number;
+        }>;
+    }>]>>;
+    /** The chain identifier `Tx.build` was run against. See `SignedTransaction.chain`. */
+    readonly chain: Schema.optional<Schema.String>;
+}>;
+export type Built = typeof Built.Type;
+/**
+ * The last epoch in which a transaction can still be applied, or `undefined`
+ * when its expiration sets no such bound (`None`, or a `ValidDuring` with no
+ * `maxEpoch`).
+ *
+ * An `Epoch` expiration is that epoch: the SDK's `Epoch` variant means "valid
+ * until the end of this epoch", so it is its own upper bound.
+ *
+ * This is the bound that matters in practice. Epochs are what the default
+ * expiration carries and what the validator rule is written in, and unlike a
+ * wall clock an epoch is a consensus fact, so `Tx.reconcile` needs no skew
+ * margin to reason about it. Never fails.
+ */
+export declare const maxEpochOf: (expiration: TransactionExpiration | undefined) => bigint | undefined;
+/**
+ * The wall-clock bound after which a transaction can no longer be applied, in
+ * milliseconds, or `undefined` when its expiration sets no such bound — which
+ * is `None`, `Epoch`, and the default `ValidDuring`, whose `maxTimestamp` is
+ * `null` unless `SubmitConfig.validFor` asks for one.
+ *
+ * `Tx.reconcile` compares it against `chainTime` with
+ * `SubmitConfig.expiryMargin` for skew, which the epoch bound needs none of.
+ * Never fails.
+ */
+export declare const maxTimestampMsOf: (expiration: TransactionExpiration | undefined) => bigint | undefined;
+/**
+ * The chain identifier an expiration names, or `undefined` for the variants
+ * that name none (`None`, `Epoch`).
+ *
+ * This is the first half of the chain-identity guard `Tx.reconcile` applies
+ * before it asks a node anything: bytes built for one chain must not be
+ * declared expired by another chain's epoch. The second half is
+ * `SignedTransaction.chain`, which `Tx.build` records for the variants that
+ * carry no chain of their own. Never fails.
+ */
+export declare const chainOf: (expiration: TransactionExpiration | undefined) => string | undefined;
+/**
+ * The fixed set of object fields sui-effect always requests: `content`, plus
+ * the owner, type, version and digest the SDK returns unconditionally.
+ */
+export declare const ObjectEnvelope: Schema.Struct<{
+    readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly version: Schema.brand<Schema.BigIntFromString, "Version">;
+    readonly digest: Schema.String;
+    readonly owner: Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+        readonly $kind: Schema.Literal<"AddressOwner">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ObjectOwner">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Shared">;
+        readonly Shared: Schema.Struct<{
+            readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Immutable">;
+        readonly Immutable: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+        readonly ConsensusAddressOwner: Schema.Struct<{
+            readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        }>;
+    }>, Schema.Struct<{
+        readonly $kind: Schema.Literal<"Unknown">;
+    }>]>;
+    readonly type: Schema.Union<readonly [Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "StructTag">, Schema.Literal<"package">]>;
+}>;
+export type ObjectEnvelope = typeof ObjectEnvelope.Type;
+/**
+ * An object read through `Sui`, with its BCS content already decoded to `S` and
+ * a `ref` ready to feed straight back into the transaction builder.
+ */
+export interface SuiObject<S> {
+    readonly id: ObjectId;
+    readonly version: Version;
+    readonly digest: string;
+    readonly type: ObjectType;
+    readonly owner: Owner;
+    readonly content: S;
+    readonly ref: ObjectRef;
+}
+/** Builds a {@link SuiObject} from a decoded envelope and its decoded content. */
+export declare const makeSuiObject: <S>(envelope: ObjectEnvelope, content: S) => SuiObject<S>;
+/** The return values and mutated references of one command. Mirrors `SuiClientTypes.CommandResult`. */
+export declare const CommandResult: Schema.Struct<{
+    readonly returnValues: Schema.$Array<Schema.Struct<{
+        readonly bcs: Schema.Uint8Array;
+    }>>;
+    readonly mutatedReferences: Schema.$Array<Schema.Struct<{
+        readonly bcs: Schema.Uint8Array;
+    }>>;
+}>;
+export type CommandResult = typeof CommandResult.Type;
+/**
+ * The result of a successful simulation, with the fixed include set `Sui` asks
+ * for: effects, events, balance changes, object types and command results.
+ */
+export declare const Simulation: Schema.Struct<{
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+    readonly effects: Schema.Struct<{
+        readonly version: Schema.Number;
+        readonly status: Schema.Struct<{
+            readonly success: Schema.Boolean;
+        }>;
+        readonly gasUsed: Schema.Struct<{
+            readonly computationCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+            readonly storageCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+            readonly storageRebate: Schema.brand<Schema.BigIntFromString, "Mist">;
+            readonly nonRefundableStorageFee: Schema.brand<Schema.BigIntFromString, "Mist">;
+        }>;
+        readonly transactionDigest: Schema.brand<Schema.String, "Digest">;
+        readonly gasObject: Schema.NullOr<Schema.Struct<{
+            readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+            readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly inputDigest: Schema.NullOr<Schema.String>;
+            readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+            readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly outputDigest: Schema.NullOr<Schema.String>;
+            readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+        }>>;
+        readonly eventsDigest: Schema.NullOr<Schema.String>;
+        readonly dependencies: Schema.$Array<Schema.String>;
+        readonly lamportVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly changedObjects: Schema.$Array<Schema.Struct<{
+            readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+            readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly inputDigest: Schema.NullOr<Schema.String>;
+            readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+            readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly outputDigest: Schema.NullOr<Schema.String>;
+            readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+        }>>;
+        readonly unchangedConsensusObjects: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["Unknown", "ReadOnlyRoot", "MutateConsensusStreamEnded", "ReadConsensusStreamEnded", "Cancelled", "PerEpochConfig"]>;
+            readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly version: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly digest: Schema.NullOr<Schema.String>;
+        }>>;
+        readonly auxiliaryDataDigest: Schema.NullOr<Schema.String>;
+    }>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly packageId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly module: Schema.String;
+        readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        readonly eventType: Schema.String;
+        readonly bcs: Schema.Uint8Array;
+    }>>;
+    readonly balanceChanges: Schema.$Array<Schema.Struct<{
+        readonly coinType: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "CoinType">;
+        readonly address: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        readonly amount: Schema.BigIntFromString;
+    }>>;
+    readonly objectTypes: Schema.$Record<Schema.String, Schema.String>;
+    readonly commandResults: Schema.$Array<Schema.Struct<{
+        readonly returnValues: Schema.$Array<Schema.Struct<{
+            readonly bcs: Schema.Uint8Array;
+        }>>;
+        readonly mutatedReferences: Schema.$Array<Schema.Struct<{
+            readonly bcs: Schema.Uint8Array;
+        }>>;
+    }>>;
+}>;
+export type Simulation = typeof Simulation.Type;
+/**
+ * Decodes the SDK's `ExecutionError` into an {@link ExecutionReason}, falling
+ * back to `Unknown` when the node reports a variant this version does not
+ * model. Never fails.
+ */
+export declare const executionReasonOf: (error: SuiClientTypes.ExecutionError) => ExecutionReason;
+//# sourceMappingURL=schemas.d.ts.map