@unconfirmed/sui-effect 0.1.0 → 0.1.2

package/dist/domain/schemas.d.ts

@@ -12,15 +12,31 @@ 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`.
+ *
+ * `SuiAddress.make(value)` is the branding constructor: it **validates without
+ * decoding**, so it takes the padded 32-byte spelling and nothing else —
+ * `SuiAddress.make("0x1")` throws. `SuiAddress.normalize("0x1")` is the one
+ * that accepts every spelling a human writes, because it decodes first.
  */
-export declare const SuiAddress: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
-export type SuiAddress = typeof SuiAddress.Type;
+declare const SuiAddressSchema: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+/** The schema, plus {@link normalizeSuiAddressValue} as `SuiAddress.normalize`. */
+export declare const SuiAddress: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+    normalize: (input: string) => typeof SuiAddressSchema.Type;
+};
+export type SuiAddress = typeof SuiAddressSchema.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.
+ *
+ * `ObjectId.make` validates without decoding; `ObjectId.normalize` decodes
+ * first and is what takes `"0x6"`.
  */
-export declare const ObjectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
-export type ObjectId = typeof ObjectId.Type;
+declare const ObjectIdSchema: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+/** The schema, plus {@link normalizeObjectIdValue} as `ObjectId.normalize`. */
+export declare const ObjectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+    normalize: (input: string) => typeof ObjectIdSchema.Type;
+};
+export type ObjectId = typeof ObjectIdSchema.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;
@@ -67,10 +83,14 @@ export declare const KNOWN_CHAIN_IDS: Readonly<Record<string, string>>;
  */
 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">;
+    readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+        normalize: (input: string) => typeof SuiAddressSchema.Type;
+    };
 }>, Schema.Struct<{
     readonly $kind: Schema.Literal<"ObjectOwner">;
-    readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
 }>, Schema.Struct<{
     readonly $kind: Schema.Literal<"Shared">;
     readonly Shared: Schema.Struct<{
@@ -83,7 +103,9 @@ export declare const Owner: Schema.toTaggedUnion<"$kind", readonly [Schema.Struc
     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">;
+        readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
     }>;
 }>, Schema.Struct<{
     readonly $kind: Schema.Literal<"Unknown">;
@@ -94,16 +116,22 @@ export type Owner = typeof Owner.Type;
  * 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 id: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     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">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"ObjectOwner">;
-        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Shared">;
         readonly Shared: Schema.Struct<{
@@ -116,7 +144,9 @@ export declare const ObjectRef: 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">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>;
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Unknown">;
@@ -139,7 +169,9 @@ export declare const DynamicFieldName: Schema.Struct<{
 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 fieldId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     readonly type: Schema.String;
     readonly name: Schema.Struct<{
         readonly type: Schema.String;
@@ -147,12 +179,16 @@ export declare const DynamicFieldEntry: Schema.Struct<{
     }>;
     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 childId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    }>;
 }>;
 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 fieldId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     readonly type: Schema.String;
     readonly name: Schema.Struct<{
         readonly type: Schema.String;
@@ -160,7 +196,9 @@ export declare const DynamicField: Schema.Struct<{
     }>;
     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 childId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    }>;
     readonly value: Schema.Struct<{
         readonly type: Schema.String;
         readonly bcs: Schema.Uint8Array;
@@ -179,16 +217,22 @@ export declare const GasCostSummary: Schema.Struct<{
 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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     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">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"ObjectOwner">;
-        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Shared">;
         readonly Shared: Schema.Struct<{
@@ -201,7 +245,9 @@ export declare const ChangedObject: 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">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>;
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Unknown">;
@@ -211,10 +257,14 @@ export declare const ChangedObject: Schema.Struct<{
     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">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"ObjectOwner">;
-        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Shared">;
         readonly Shared: Schema.Struct<{
@@ -227,7 +277,9 @@ export declare const ChangedObject: 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">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>;
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Unknown">;
@@ -238,7 +290,9 @@ 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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     readonly version: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
     readonly digest: Schema.NullOr<Schema.String>;
 }>;
@@ -246,17 +300,41 @@ 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 address: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+        normalize: (input: string) => typeof SuiAddressSchema.Type;
+    };
     readonly amount: Schema.BigIntFromString;
 }>;
 export type BalanceChange = typeof BalanceChange.Type;
-/** An emitted Move event. Mirrors `SuiClientTypes.Event`; `json` is dropped on purpose. */
+/**
+ * An emitted Move event. Mirrors `SuiClientTypes.Event` with the branded ids
+ * this package uses.
+ *
+ * The decode a caller wants is `SuiSchema.decode(codec, event.bcs)`, which
+ * gives a typed value; `json` is the node's own rendering and is **not**
+ * something to build on — it is absent on most transports and its shape follows
+ * whatever the node feels like. It is kept only when the source carried it,
+ * which in practice means a relay or sponsor envelope decoded through
+ * `Executed.fromPartial`, where it may be the only form of the event there is.
+ */
 export declare const Event: Schema.Struct<{
-    readonly packageId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly packageId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     readonly module: Schema.String;
-    readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+    readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+        normalize: (input: string) => typeof SuiAddressSchema.Type;
+    };
     readonly eventType: Schema.String;
     readonly bcs: Schema.Uint8Array;
+    /**
+     * The node's own JSON rendering of the event, when whatever produced this
+     * carried one. Never populated from a gRPC execute; never to be preferred
+     * over `bcs`.
+     *
+     * @since 0.1.2
+     */
+    readonly json: Schema.optional<Schema.Unknown>;
 }>;
 export type Event = typeof Event.Type;
 /**
@@ -387,16 +465,22 @@ export declare const TransactionEffects: Schema.Struct<{
     }>;
     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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
         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">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"ObjectOwner">;
-            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Shared">;
             readonly Shared: Schema.Struct<{
@@ -409,7 +493,9 @@ export declare const TransactionEffects: 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">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>;
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Unknown">;
@@ -419,10 +505,14 @@ export declare const TransactionEffects: Schema.Struct<{
         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">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"ObjectOwner">;
-            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Shared">;
             readonly Shared: Schema.Struct<{
@@ -435,7 +525,9 @@ export declare const TransactionEffects: 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">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>;
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Unknown">;
@@ -446,16 +538,22 @@ export declare const TransactionEffects: Schema.Struct<{
     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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
         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">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"ObjectOwner">;
-            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Shared">;
             readonly Shared: Schema.Struct<{
@@ -468,7 +566,9 @@ export declare const TransactionEffects: 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">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>;
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Unknown">;
@@ -478,10 +578,14 @@ export declare const TransactionEffects: Schema.Struct<{
         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">;
+            readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"ObjectOwner">;
-            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Shared">;
             readonly Shared: Schema.Struct<{
@@ -494,7 +598,9 @@ export declare const TransactionEffects: 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">;
+                readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>;
         }>, Schema.Struct<{
             readonly $kind: Schema.Literal<"Unknown">;
@@ -503,7 +609,9 @@ export declare const TransactionEffects: Schema.Struct<{
     }>>;
     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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
         readonly version: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
         readonly digest: Schema.NullOr<Schema.String>;
     }>>;
@@ -577,7 +685,9 @@ 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 sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+        normalize: (input: string) => typeof SuiAddressSchema.Type;
+    };
     readonly expiration: Schema.optional<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
         readonly $kind: Schema.Literal<"None">;
         readonly None: Schema.Literal<true>;
@@ -645,8 +755,12 @@ export type NotAppliedEvidence = typeof NotAppliedEvidence.Type;
 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 sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+        normalize: (input: string) => typeof SuiAddressSchema.Type;
+    };
+    readonly gasOwner: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+        normalize: (input: string) => typeof SuiAddressSchema.Type;
+    }>;
     readonly expiration: Schema.optional<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
         readonly $kind: Schema.Literal<"None">;
         readonly None: Schema.Literal<true>;
@@ -723,15 +837,21 @@ export declare const chainOf: (expiration: TransactionExpiration | undefined) =>
  * 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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+        normalize: (input: string) => typeof ObjectIdSchema.Type;
+    };
     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">;
+        readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"ObjectOwner">;
-        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+        readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Shared">;
         readonly Shared: Schema.Struct<{
@@ -744,7 +864,9 @@ export declare const ObjectEnvelope: 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">;
+            readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                normalize: (input: string) => typeof SuiAddressSchema.Type;
+            };
         }>;
     }>, Schema.Struct<{
         readonly $kind: Schema.Literal<"Unknown">;
@@ -796,16 +918,22 @@ export declare const Simulation: Schema.Struct<{
         }>;
         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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
             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">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"ObjectOwner">;
-                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                    normalize: (input: string) => typeof ObjectIdSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Shared">;
                 readonly Shared: Schema.Struct<{
@@ -818,7 +946,9 @@ export declare const Simulation: 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">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                        normalize: (input: string) => typeof SuiAddressSchema.Type;
+                    };
                 }>;
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Unknown">;
@@ -828,10 +958,14 @@ export declare const Simulation: Schema.Struct<{
             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">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"ObjectOwner">;
-                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                    normalize: (input: string) => typeof ObjectIdSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Shared">;
                 readonly Shared: Schema.Struct<{
@@ -844,7 +978,9 @@ export declare const Simulation: 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">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                        normalize: (input: string) => typeof SuiAddressSchema.Type;
+                    };
                 }>;
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Unknown">;
@@ -855,16 +991,22 @@ export declare const Simulation: Schema.Struct<{
         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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
             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">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"ObjectOwner">;
-                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                    normalize: (input: string) => typeof ObjectIdSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Shared">;
                 readonly Shared: Schema.Struct<{
@@ -877,7 +1019,9 @@ export declare const Simulation: 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">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                        normalize: (input: string) => typeof SuiAddressSchema.Type;
+                    };
                 }>;
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Unknown">;
@@ -887,10 +1031,14 @@ export declare const Simulation: Schema.Struct<{
             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">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                    normalize: (input: string) => typeof SuiAddressSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"ObjectOwner">;
-                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                    normalize: (input: string) => typeof ObjectIdSchema.Type;
+                };
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Shared">;
                 readonly Shared: Schema.Struct<{
@@ -903,7 +1051,9 @@ export declare const Simulation: 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">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+                        normalize: (input: string) => typeof SuiAddressSchema.Type;
+                    };
                 }>;
             }>, Schema.Struct<{
                 readonly $kind: Schema.Literal<"Unknown">;
@@ -912,22 +1062,38 @@ export declare const Simulation: Schema.Struct<{
         }>>;
         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 objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+                normalize: (input: string) => typeof ObjectIdSchema.Type;
+            };
             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 packageId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId"> & {
+            normalize: (input: string) => typeof ObjectIdSchema.Type;
+        };
         readonly module: Schema.String;
-        readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+        readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
         readonly eventType: Schema.String;
         readonly bcs: Schema.Uint8Array;
+        /**
+         * The node's own JSON rendering of the event, when whatever produced this
+         * carried one. Never populated from a gRPC execute; never to be preferred
+         * over `bcs`.
+         *
+         * @since 0.1.2
+         */
+        readonly json: Schema.optional<Schema.Unknown>;
     }>>;
     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 address: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress"> & {
+            normalize: (input: string) => typeof SuiAddressSchema.Type;
+        };
         readonly amount: Schema.BigIntFromString;
     }>>;
     readonly objectTypes: Schema.$Record<Schema.String, Schema.String>;
@@ -947,4 +1113,5 @@ export type Simulation = typeof Simulation.Type;
  * model. Never fails.
  */
 export declare const executionReasonOf: (error: SuiClientTypes.ExecutionError) => ExecutionReason;
+export {};
 //# sourceMappingURL=schemas.d.ts.map