@misofm/platform 0.27.0 → 0.28.0

package/src/contracts/party_cta/party_cta.ts

@@ -15,7 +15,9 @@
  * The CTAs are an ordered list: **position is priority**. The whole list is
  * written at once (`set_ctas`) — the natural fit for a drag-to-reorder editor that
  * saves on submit — so there are no per-entry ids to track. Gated by the
- * `PartyAdminCap`; views are permissionless.
+ * `PartyAdminCap`; views are permissionless. Each successful write emits one
+ * self-contained event with the authorizing cap address and complete ordered
+ * prior/resulting label and URL bytes; an absent clear is silent.
  */
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
@@ -30,10 +32,21 @@ export const Cta = new MoveStruct({ name: `${$moduleName}::Cta`, fields: {
     } });
 export const CtasSetEvent = new MoveStruct({ name: `${$moduleName}::CtasSetEvent`, fields: {
         party_id: bcs.Address,
-        count: bcs.u64()
+        admin_cap_id: bcs.Address,
+        existed_before: bcs.bool(),
+        previous_count: bcs.u64(),
+        count: bcs.u64(),
+        previous_labels: bcs.vector(bcs.vector(bcs.u8())),
+        previous_urls: bcs.vector(bcs.vector(bcs.u8())),
+        labels: bcs.vector(bcs.vector(bcs.u8())),
+        urls: bcs.vector(bcs.vector(bcs.u8()))
     } });
 export const CtasClearedEvent = new MoveStruct({ name: `${$moduleName}::CtasClearedEvent`, fields: {
-        party_id: bcs.Address
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        previous_count: bcs.u64(),
+        previous_labels: bcs.vector(bcs.vector(bcs.u8())),
+        previous_urls: bcs.vector(bcs.vector(bcs.u8()))
     } });
 export interface NewCtaArguments {
     label: RawTransactionArgument<string>;
@@ -123,7 +136,12 @@ export interface SetCtasOptions {
         ctas: TransactionArgument
     ];
 }
-/** Sets (or replaces) the party's ordered CTA list. Position is priority. */
+/**
+ * Sets (or replaces) the party's ordered CTA list. Position is priority. Length is
+ * checked before authorization. Every successful call, including an empty or
+ * identical replacement, emits exactly one event with complete prior and resulting
+ * label and URL byte vectors.
+ */
 export function setCtas(options: SetCtasOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_cta';
     const argumentsTypes = [
@@ -150,7 +168,11 @@ export interface ClearCtasOptions {
         cap: RawTransactionArgument<string>
     ];
 }
-/** Removes the party's CTA list. No-op if none is set. */
+/**
+ * Removes the party's CTA list. Authorization happens before checking existence;
+ * an absent list is a silent no-op, while an existing list emits exactly one event
+ * containing the complete removed payload.
+ */
 export function clearCtas(options: ClearCtasOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_cta';
     const argumentsTypes = [

package/src/contracts/party_genre/party_genre.ts

@@ -27,14 +27,25 @@ const $moduleName = '@local-pkg/party_genre::party_genre';
 export const GenresKey = new MoveTuple({ name: `${$moduleName}::GenresKey`, fields: [bcs.bool()] });
 export const GenreAddedEvent = new MoveStruct({ name: `${$moduleName}::GenreAddedEvent`, fields: {
         party_id: bcs.Address,
-        genre_id: bcs.Address
+        admin_cap_id: bcs.Address,
+        genre_id: bcs.Address,
+        genre_name: bcs.vector(bcs.u8()),
+        genre_ids_before: bcs.vector(bcs.Address),
+        genre_ids_after: bcs.vector(bcs.Address),
+        max_genres: bcs.u64()
     } });
 export const GenreRemovedEvent = new MoveStruct({ name: `${$moduleName}::GenreRemovedEvent`, fields: {
         party_id: bcs.Address,
-        genre_id: bcs.Address
+        admin_cap_id: bcs.Address,
+        genre_id: bcs.Address,
+        genre_ids_before: bcs.vector(bcs.Address),
+        genre_ids_after: bcs.vector(bcs.Address)
     } });
 export const GenresClearedEvent = new MoveStruct({ name: `${$moduleName}::GenresClearedEvent`, fields: {
-        party_id: bcs.Address
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        genre_ids_before: bcs.vector(bcs.Address),
+        genre_ids_after: bcs.vector(bcs.Address)
     } });
 export interface AddGenreArguments {
     self: RawTransactionArgument<string>;

package/src/contracts/party_media/party_media.ts

@@ -15,7 +15,10 @@
  * The chain is deliberately role-agnostic: which patch is the avatar vs the header
  * is a client convention (quilt patch _identifiers_, e.g. "avatar" / "header"),
  * derived off-chain — never stored here. Updating any image means re-storing the
- * quilt and calling `set_media` with the new id.
+ * quilt and calling `set_media` with the new id. Every successful set emits the
+ * prior/resulting quilt ids and the authorizing cap address; a clear emits the
+ * removed id only when a field existed. All writes are cap-gated through
+ * `party::uid_mut`, and views are permissionless.
  */
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
@@ -34,10 +37,15 @@ export const Media = new MoveStruct({ name: `${$moduleName}::Media`, fields: {
     } });
 export const MediaSetEvent = new MoveStruct({ name: `${$moduleName}::MediaSetEvent`, fields: {
         party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        existed_before: bcs.bool(),
+        previous_quilt: bcs.u256(),
         quilt: bcs.u256()
     } });
 export const MediaClearedEvent = new MoveStruct({ name: `${$moduleName}::MediaClearedEvent`, fields: {
-        party_id: bcs.Address
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        previous_quilt: bcs.u256()
     } });
 export interface SetMediaArguments {
     self: RawTransactionArgument<string>;
@@ -52,7 +60,11 @@ export interface SetMediaOptions {
         quilt: RawTransactionArgument<number | bigint>
     ];
 }
-/** Sets (or replaces) the party's media quilt. Aborts on a zero id. */
+/**
+ * Sets (or replaces) the party's media quilt. Aborts on a zero id before
+ * authorization. Every successful call, including an identical replacement, emits
+ * exactly one event with the complete prior/resulting quilt snapshot.
+ */
 export function setMedia(options: SetMediaOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_media';
     const argumentsTypes = [
@@ -79,7 +91,11 @@ export interface ClearMediaOptions {
         cap: RawTransactionArgument<string>
     ];
 }
-/** Removes the party's media. No-op if none is set. */
+/**
+ * Removes the party's media. Authorization happens before checking existence; an
+ * absent field is a silent no-op, while an existing field emits exactly one event
+ * containing the removed quilt id.
+ */
 export function clearMedia(options: ClearMediaOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_media';
     const argumentsTypes = [

package/src/contracts/party_platform_link/party_platform_link.ts

@@ -12,11 +12,11 @@
  * This one module serves every platform (social, music, anything) because it is
  * generic over `Data`; the payload types live in their own small packages
  * (`party_social`, `party_music`, …). All writes are gated by the `PartyAdminCap`
- * via `uid_mut`; views are permissionless. Events are phantom-typed per platform
- * so an indexer can see which platform changed — dynamic-field mutations are not
- * otherwise observable. These events carry no payload by convention: they are
- * change signals, and the indexer re-reads the field. (Small, stable payloads are
- * the exception elsewhere — `party_media`'s quilt id or a role or tag string.)
+ * via `uid_mut`; views are permissionless. Storage mutations emit the
+ * authoritative rich `platform_link::PlatformLinkSetEvent` or
+ * `platform_link::PlatformLinkRemovedEvent` from the primitive, so the event
+ * carries the parent, defining-ID-qualified payload type, existence transition,
+ * and bounded payload summaries. This module adds no replacement event.
  */
 
 import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
@@ -46,7 +46,11 @@ export interface SetLinkOptions {
         string
     ];
 }
-/** Sets (or replaces) a platform's link on the party. */
+/**
+ * Sets (or replaces) a platform's link on the party. The primitive emits one
+ * `PlatformLinkSetEvent<Data>` for every successful call, including an equal
+ * replacement.
+ */
 export function setLink(options: SetLinkOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_platform_link';
     const argumentsTypes = [
@@ -77,7 +81,11 @@ export interface ClearLinkOptions {
         string
     ];
 }
-/** Clears a platform's link from the party. No-op if unset. */
+/**
+ * Clears a platform's link from the party. Cap authorization is checked before the
+ * existence check. A present link delegates to the primitive, which emits one
+ * `PlatformLinkRemovedEvent<Data>`; absent and repeated clears are silent.
+ */
 export function clearLink(options: ClearLinkOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_platform_link';
     const argumentsTypes = [

package/src/contracts/party_profile/party_profile.ts

@@ -14,7 +14,10 @@
  * validated code primitives (`country_code`, `language_code`), so a stored value
  * is always a real code. The party's `name` is NOT duplicated here — it lives on
  * the core `Party` (`party::set_name`) — and the join date comes from the party's
- * creation event (the indexer has it for free).
+ * creation event (the indexer has it for free). Every successful set emits a
+ * complete before/after byte snapshot and the authorizing cap address; a clear
+ * emits the complete removed snapshot only when a profile exists. All writes are
+ * cap-gated through `party::uid_mut`, and views are permissionless.
  */
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
@@ -31,11 +34,26 @@ export const Profile = new MoveStruct({ name: `${$moduleName}::Profile`, fields:
         country: bcs.option(country_code.CountryCode),
         languages: bcs.vector(language_code.LanguageCode)
     } });
-export const ProfileSetEvent = new MoveStruct({ name: `${$moduleName}::ProfileSetEvent`, fields: {
-        party_id: bcs.Address
+export const PartyProfileSetEvent = new MoveStruct({ name: `${$moduleName}::PartyProfileSetEvent`, fields: {
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        had_profile: bcs.bool(),
+        previous_bio_short: bcs.vector(bcs.u8()),
+        previous_bio_long: bcs.option(bcs.vector(bcs.u8())),
+        previous_country: bcs.option(bcs.vector(bcs.u8())),
+        previous_languages: bcs.vector(bcs.vector(bcs.u8())),
+        bio_short: bcs.vector(bcs.u8()),
+        bio_long: bcs.option(bcs.vector(bcs.u8())),
+        country: bcs.option(bcs.vector(bcs.u8())),
+        languages: bcs.vector(bcs.vector(bcs.u8()))
     } });
-export const ProfileClearedEvent = new MoveStruct({ name: `${$moduleName}::ProfileClearedEvent`, fields: {
-        party_id: bcs.Address
+export const PartyProfileClearedEvent = new MoveStruct({ name: `${$moduleName}::PartyProfileClearedEvent`, fields: {
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        previous_bio_short: bcs.vector(bcs.u8()),
+        previous_bio_long: bcs.option(bcs.vector(bcs.u8())),
+        previous_country: bcs.option(bcs.vector(bcs.u8())),
+        previous_languages: bcs.vector(bcs.vector(bcs.u8()))
     } });
 export interface SetProfileArguments {
     self: RawTransactionArgument<string>;
@@ -57,8 +75,11 @@ export interface SetProfileOptions {
     ];
 }
 /**
- * Sets (creates or replaces) the party's whole profile. The single write entry
- * point: a profile is a cohesive card, edited as a whole and saved in one call.
+ * Sets (creates or replaces) the party's whole profile. Validation and profile
+ * construction happen before authorization, preserving validation precedence;
+ * authorization happens before any dynamic-field snapshot or mutation. Every
+ * successful call, including an identical replacement, emits exactly one event
+ * containing complete prior and resulting raw-byte snapshots.
  */
 export function setProfile(options: SetProfileOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_profile';
@@ -89,7 +110,11 @@ export interface ClearProfileOptions {
         cap: RawTransactionArgument<string>
     ];
 }
-/** Removes the party's profile. No-op if none is set. */
+/**
+ * Removes the party's profile. Authorization happens before checking existence; an
+ * absent field is a silent no-op, while an existing field is removed and emits
+ * exactly one complete snapshot event.
+ */
 export function clearProfile(options: ClearProfileOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_profile';
     const argumentsTypes = [

package/src/contracts/party_roles/party_roles.ts

@@ -14,7 +14,9 @@
  * live in the shared `typed_set` primitive; this package keeps the role type, name
  * validation, the capacity, and the typed events. Duplicate / not-present /
  * over-max aborts come from `typed_set` with its own error codes. Gated by the
- * `PartyAdminCap`; views are permissionless.
+ * `PartyAdminCap`; views are permissionless. Mutation events carry the party and
+ * cap addresses, a stable kind/name pair, and before/after counts; a populated
+ * clear also carries ordered removed role snapshots.
  */
 
 import { MoveTuple, MoveStruct, MoveEnum, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
@@ -25,14 +27,27 @@ const $moduleName = '@local-pkg/party_roles::party_roles';
 export const RolesKey = new MoveTuple({ name: `${$moduleName}::RolesKey`, fields: [bcs.bool()] });
 export const RoleAddedEvent = new MoveStruct({ name: `${$moduleName}::RoleAddedEvent`, fields: {
         party_id: bcs.Address,
-        role: bcs.string()
+        admin_cap_id: bcs.Address,
+        role_kind: bcs.u8(),
+        role_name: bcs.vector(bcs.u8()),
+        roles_count_before: bcs.u64(),
+        roles_count_after: bcs.u64()
     } });
 export const RoleRemovedEvent = new MoveStruct({ name: `${$moduleName}::RoleRemovedEvent`, fields: {
         party_id: bcs.Address,
-        role: bcs.string()
+        admin_cap_id: bcs.Address,
+        role_kind: bcs.u8(),
+        role_name: bcs.vector(bcs.u8()),
+        roles_count_before: bcs.u64(),
+        roles_count_after: bcs.u64()
     } });
 export const RolesClearedEvent = new MoveStruct({ name: `${$moduleName}::RolesClearedEvent`, fields: {
-        party_id: bcs.Address
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        removed_role_kinds: bcs.vector(bcs.u8()),
+        removed_role_names: bcs.vector(bcs.vector(bcs.u8())),
+        roles_count_before: bcs.u64(),
+        roles_count_after: bcs.u64()
     } });
 /** The kind of act a party represents. Closed enum + `Custom` escape hatch. */
 export const ArtistRole = new MoveEnum({ name: `${$moduleName}::ArtistRole`, fields: {

package/src/contracts/party_tags/party_tags.ts

@@ -14,7 +14,9 @@
  * validation, the capacity, and the typed events. Duplicate / not-present /
  * over-max aborts come from `typed_set` with its own error codes. Tags are stored
  * as given (exact dedupe); normalization for search/display is a client concern.
- * Gated by the `PartyAdminCap`; views are permissionless.
+ * Gated by the `PartyAdminCap`; views are permissionless. Mutation events carry
+ * the party and cap addresses, the raw tag bytes, and before/after counts; a
+ * populated clear also carries the ordered raw tag snapshots.
  */
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
@@ -25,14 +27,24 @@ const $moduleName = '@local-pkg/party_tags::party_tags';
 export const TagsKey = new MoveTuple({ name: `${$moduleName}::TagsKey`, fields: [bcs.bool()] });
 export const TagAddedEvent = new MoveStruct({ name: `${$moduleName}::TagAddedEvent`, fields: {
         party_id: bcs.Address,
-        tag: bcs.string()
+        admin_cap_id: bcs.Address,
+        tag: bcs.vector(bcs.u8()),
+        tag_count_before: bcs.u64(),
+        tag_count_after: bcs.u64()
     } });
 export const TagRemovedEvent = new MoveStruct({ name: `${$moduleName}::TagRemovedEvent`, fields: {
         party_id: bcs.Address,
-        tag: bcs.string()
+        admin_cap_id: bcs.Address,
+        tag: bcs.vector(bcs.u8()),
+        tag_count_before: bcs.u64(),
+        tag_count_after: bcs.u64()
     } });
 export const TagsClearedEvent = new MoveStruct({ name: `${$moduleName}::TagsClearedEvent`, fields: {
-        party_id: bcs.Address
+        party_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        removed_tags: bcs.vector(bcs.vector(bcs.u8())),
+        tag_count_before: bcs.u64(),
+        tag_count_after: bcs.u64()
     } });
 export interface AddTagArguments {
     self: RawTransactionArgument<string>;

package/src/contracts/party_wallet/party_wallet.ts

@@ -20,12 +20,13 @@ import { bcs } from '@mysten/sui/bcs';
 import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/party_wallet::party_wallet';
-export const ObjectReceivedEvent = new MoveStruct({ name: `${$moduleName}::ObjectReceivedEvent`, fields: {
+export const ObjectReceivedEvent = new MoveStruct({ name: `${$moduleName}::ObjectReceivedEvent<phantom T>`, fields: {
         party_id: bcs.Address,
         object_id: bcs.Address
     } });
 export const CoinsReceivedEvent = new MoveStruct({ name: `${$moduleName}::CoinsReceivedEvent<phantom Currency>`, fields: {
         party_id: bcs.Address,
+        coin_ids: bcs.vector(bcs.Address),
         amount: bcs.u64(),
         coins: bcs.u64()
     } });

package/src/contracts/platform_link/platform_link.ts

@@ -0,0 +1,322 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * `PlatformLink<Data>` — a typed link to an entity on one external platform: a
+ * streaming service (Spotify, Bandcamp), a social network (X, Instagram), or any
+ * other site.
+ *
+ * A protocol-agnostic primitive: it knows nothing about any specific platform, nor
+ * about any consumer object (a `Party`, a `Release`, …). It is a generic wrapper
+ * around a `Data` payload plus the machinery to store exactly one such link, by
+ * type, as a dynamic field on any object's `UID`.
+ *
+ * `Data` is the platform-specific native identifier(s) — an Instagram handle, a
+ * Spotify artist id, a Bandcamp subdomain, etc. Each platform defines its own
+ * `Data` type in its own small package, so adding a platform is a new type, never
+ * a change here. URLs are never stored: a client rebuilds the public URL from the
+ * `Data` it reads back, so a platform reshaping its URLs needs no on-chain change.
+ *
+ * Storage is keyed by `PlatformLinkKey<Data>`, whose `phantom Data` makes
+ * `PlatformLinkKey<InstagramData>` and `PlatformLinkKey<SpotifyData>` distinct
+ * keys — so each platform occupies its own independent field on the same `UID`,
+ * and a new platform can be added to a record without touching the others.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/platform_link::platform_link';
+/**
+ * A link to an entity on one platform. `Data` carries that platform's native
+ * identifier(s); the public URL is rebuilt from it client-side.
+ */
+export function PlatformLink<Data extends BcsType<any>>(...typeParameters: [
+    Data
+]) {
+    return new MoveStruct({ name: `${$moduleName}::PlatformLink<${typeParameters[0].name as Data['name']}>`, fields: {
+            data: typeParameters[0]
+        } });
+}
+export const PlatformLinkKey = new MoveTuple({ name: `${$moduleName}::PlatformLinkKey<phantom Data>`, fields: [bcs.bool()] });
+export const PlatformLinkSetEvent = new MoveStruct({ name: `${$moduleName}::PlatformLinkSetEvent<phantom Data>`, fields: {
+        parent_id: bcs.Address,
+        data_type: bcs.vector(bcs.u8()),
+        existed_before: bcs.bool(),
+        exists_after: bcs.bool(),
+        previous_bcs_length: bcs.u64(),
+        previous_bcs_hash: bcs.vector(bcs.u8()),
+        data_bcs_length: bcs.u64(),
+        data_bcs_hash: bcs.vector(bcs.u8())
+    } });
+export const PlatformLinkRemovedEvent = new MoveStruct({ name: `${$moduleName}::PlatformLinkRemovedEvent<phantom Data>`, fields: {
+        parent_id: bcs.Address,
+        data_type: bcs.vector(bcs.u8()),
+        existed_before: bcs.bool(),
+        exists_after: bcs.bool(),
+        removed_bcs_length: bcs.u64(),
+        removed_bcs_hash: bcs.vector(bcs.u8())
+    } });
+export interface MaxIdentifierLengthOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/**
+ * Maximum length of a platform identifier — a handle, username, id, or subdomain —
+ * in bytes.
+ */
+export function maxIdentifierLength(options: MaxIdentifierLengthOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'max_identifier_length',
+    });
+}
+export interface MaxUrlLengthOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/**
+ * Maximum length of a stored URL in bytes, for payloads whose URL is the identity
+ * (no reconstructable handle).
+ */
+export function maxUrlLength(options: MaxUrlLengthOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'max_url_length',
+    });
+}
+export interface NewArguments<Data extends BcsType<any>> {
+    data: RawTransactionArgument<Data>;
+}
+export interface NewOptions<Data extends BcsType<any>> {
+    package?: string;
+    arguments: NewArguments<Data> | [
+        data: RawTransactionArgument<Data>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Wraps a platform-specific payload into a link. */
+export function _new<Data extends BcsType<any>>(options: NewOptions<Data>) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        `${options.typeArguments[0]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["data"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface DataArguments {
+    self: TransactionArgument;
+}
+export interface DataOptions {
+    package?: string;
+    arguments: DataArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The wrapped platform-specific payload. */
+export function data(options: DataOptions) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface Exists_Arguments {
+    uid: RawTransactionArgument<string>;
+}
+export interface Exists_Options {
+    package?: string;
+    arguments: Exists_Arguments | [
+        uid: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Whether a `PlatformLink<Data>` is stored under `uid`. */
+export function exists_(options: Exists_Options) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["uid"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'exists_',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface SetArguments {
+    uid: RawTransactionArgument<string>;
+    link: TransactionArgument;
+}
+export interface SetOptions {
+    package?: string;
+    arguments: SetArguments | [
+        uid: RawTransactionArgument<string>,
+        link: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Sets the `PlatformLink<Data>` under `uid`, replacing any existing one. Emits
+ * `PlatformLinkSetEvent<Data>` with bounded summaries of the previous and new
+ * payloads. An equal replacement still emits an event.
+ */
+export function set(options: SetOptions) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        '0x2::object::ID',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["uid", "link"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'set',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface GetArguments {
+    uid: RawTransactionArgument<string>;
+}
+export interface GetOptions {
+    package?: string;
+    arguments: GetArguments | [
+        uid: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The stored `PlatformLink<Data>`, or `none` if absent. */
+export function get(options: GetOptions) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["uid"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'get',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowArguments {
+    uid: RawTransactionArgument<string>;
+}
+export interface BorrowOptions {
+    package?: string;
+    arguments: BorrowArguments | [
+        uid: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Borrows the stored link. Aborts if none is stored. */
+export function borrow(options: BorrowOptions) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["uid"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'borrow',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveArguments {
+    uid: RawTransactionArgument<string>;
+}
+export interface RemoveOptions {
+    package?: string;
+    arguments: RemoveArguments | [
+        uid: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Removes and returns the stored link. Aborts if none is stored. Emits
+ * `PlatformLinkRemovedEvent<Data>` for the removed payload.
+ */
+export function remove(options: RemoveOptions) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["uid"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'remove',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ClearArguments {
+    uid: RawTransactionArgument<string>;
+}
+export interface ClearOptions {
+    package?: string;
+    arguments: ClearArguments | [
+        uid: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Removes the stored link if present, discarding it. No-op if absent. */
+export function clear(options: ClearOptions) {
+    const packageAddress = options.package ?? '@local-pkg/platform_link';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["uid"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'platform_link',
+        function: 'clear',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}