@misofm/sdk 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misofm/sdk",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Typed query helpers and transaction builders for the Miso platform layer on Sui \u2014 pressings, listings, records, and opinionated work publishing.",
   "license": "Apache-2.0",
   "repository": {
@@ -64,6 +64,18 @@
       "types": "./dist/catalog.d.ts",
       "default": "./dist/catalog.js"
     },
+    "./credits": {
+      "types": "./dist/credits.d.ts",
+      "default": "./dist/credits.js"
+    },
+    "./cover": {
+      "types": "./dist/cover.d.ts",
+      "default": "./dist/cover.js"
+    },
+    "./extensions/royalty-pool": {
+      "types": "./dist/extensions/royalty-pool.d.ts",
+      "default": "./dist/extensions/royalty-pool.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -93,7 +105,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@misonetwork/sdk": "^0.2.2"
+    "@misonetwork/sdk": "^0.3.0"
   },
   "main": "./dist/index.js"
 }

package/src/contracts/composition_credits/composition_credits.ts

@@ -0,0 +1,169 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * First-party credits extension for compositions.
+ * 
+ * Attribution (writing credits) is display-oriented and varies across platforms,
+ * so it lives here as a dynamic field on the composition rather than in immutable
+ * core. The data is attached under `ExtensionKey()` via the composition's
+ * cap-gated `uid_mut`, so every mutation is authorized by the composition's admin
+ * and credits survive into any lifecycle state (they may be attached before or
+ * after the composition is published).
+ * 
+ * This is Miso's canonical credits standard; because it is an extension, other
+ * parties may publish their own composition-credits standard against the same
+ * `Composition`. Credits are NOT read by the economics — they are attribution.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as vec_map from './deps/sui/vec_map.js';
+import * as credit from './deps/miso_credit/credit.js';
+import * as composition_party_role from './composition_party_role.js';
+const $moduleName = '@local-pkg/composition_credits::composition_credits';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const CompositionCredits = new MoveStruct({ name: `${$moduleName}::CompositionCredits`, fields: {
+        /** Map of party IDs to their credit (display name + roles). */
+        credits: vec_map.VecMap(bcs.Address, credit.Credit(composition_party_role.CompositionPartyRole))
+    } });
+export const CreditAddedEvent = new MoveStruct({ name: `${$moduleName}::CreditAddedEvent`, fields: {
+        composition_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+    } });
+export const CreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CreditRemovedEvent`, fields: {
+        composition_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+    } });
+export interface AddCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    credit: TransactionArgument;
+}
+export interface AddCreditOptions {
+    package?: string;
+    arguments: AddCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        credit: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Adds a credit for a party on the composition, lazily creating the credits record
+ * on first use. Each credit must have 1-5 roles, and a party may hold at most one
+ * credit. Requires the composition's admin capability.
+ */
+export function addCredit(options: AddCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party", "credit"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'add_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemoveCreditOptions {
+    package?: string;
+    arguments: RemoveCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Removes a party's credit. Requires the composition's admin capability. */
+export function removeCredit(options: RemoveCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'remove_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasCreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCreditsOptions {
+    package?: string;
+    arguments: HasCreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns whether a credits record has been attached to this composition yet. */
+export function hasCredits(options: HasCreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'has_credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface CreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CreditsOptions {
+    package?: string;
+    arguments: CreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns the party-to-credit map. Aborts if no credits are attached. */
+export function credits(options: CreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/composition_credits/composition_party_role.ts

@@ -0,0 +1,189 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Defines the roles that parties can hold on a composition. Compositions are the
+ * underlying musical works (melody + lyrics), and these roles represent the
+ * writing and adaptation contributions to them.
+ * 
+ * ### Design
+ * 
+ * `CompositionPartyRole` is a closed enum: variants can only be constructed and
+ * matched inside this module, so the `new_*_role` constructors are the external
+ * write-API and `name()` is the external read-API.
+ * 
+ * - **No seniority axis.** Unlike recording roles, composition roles carry no
+ *   level — a writer either contributed in a given capacity or did not.
+ * - **`Custom` is the escape hatch.** The canonical variants cover the common
+ *   writing vocabulary; anything outside it is a `Custom(name)` whose name is
+ *   validated. Prefer a canonical variant when one fits.
+ * - **`name()` is the canonical identifier**, returned as a stable PascalCase
+ *   token (e.g. `"Songwriter"`). For `Custom`, `name()` returns the user-supplied
+ *   string.
+ * 
+ * These identifiers are Miso's own canonical vocabulary; any overlap with an
+ * external standard (e.g. DDEX) is coincidental, not a reproduction of it.
+ */
+
+import { MoveEnum, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/composition_credits::composition_party_role';
+/** Represents a party's role on a composition. */
+export const CompositionPartyRole = new MoveEnum({ name: `${$moduleName}::CompositionPartyRole`, fields: {
+        /** Adapted an existing work into this composition. */
+        Adapter: null,
+        /** Arranged the musical parts of the composition. */
+        Arranger: null,
+        /** Composed the music of the composition. */
+        Composer: null,
+        /** Wrote the lyrics of the composition. */
+        Lyricist: null,
+        /** Wrote both music and lyrics of the composition. */
+        Songwriter: null,
+        /** Translated the lyrics of the composition. */
+        Translator: null,
+        /**
+         * A user-defined role not covered by a canonical variant. Carries the role name
+         * (validated). An escape hatch — prefer a canonical variant when one fits.
+         */
+        Custom: bcs.string()
+    } });
+export interface NewAdapterRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Adapter role. */
+export function newAdapterRole(options: NewAdapterRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_adapter_role',
+    });
+}
+export interface NewArrangerRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Arranger role. */
+export function newArrangerRole(options: NewArrangerRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_arranger_role',
+    });
+}
+export interface NewComposerRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Composer role. */
+export function newComposerRole(options: NewComposerRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_composer_role',
+    });
+}
+export interface NewLyricistRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Lyricist role. */
+export function newLyricistRole(options: NewLyricistRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_lyricist_role',
+    });
+}
+export interface NewSongwriterRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Songwriter role. */
+export function newSongwriterRole(options: NewSongwriterRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_songwriter_role',
+    });
+}
+export interface NewTranslatorRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Translator role. */
+export function newTranslatorRole(options: NewTranslatorRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_translator_role',
+    });
+}
+export interface NewCustomRoleArguments {
+    roleName: RawTransactionArgument<string>;
+}
+export interface NewCustomRoleOptions {
+    package?: string;
+    arguments: NewCustomRoleArguments | [
+        roleName: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Creates a new Custom role with a user-defined name. The name freezes into
+ * credits, so it is validated here. Prefer a canonical variant when one fits.
+ */
+export function newCustomRole(options: NewCustomRoleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["roleName"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_custom_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface NameArguments {
+    self: TransactionArgument;
+}
+export interface NameOptions {
+    package?: string;
+    arguments: NameArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * Returns the canonical identifier of the role as a stable PascalCase token. For
+ * `Custom`, returns the user-supplied name.
+ */
+export function name(options: NameOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/composition_credits/deps/miso_credit/credit.ts

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Represents a party's credit on a work or activity. A credit pairs a display name
+ * with one or more roles, identifying how a party contributed to the work.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = 'miso_credit::credit';
+/**
+ * A credit attributing roles to a party on a work. Generic over the role type to
+ * support domain-specific roles.
+ */
+export function Credit<Role extends BcsType<any>>(...typeParameters: [
+    Role
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Credit<${typeParameters[0].name as Role['name']}>`, fields: {
+            /** Human-readable name to display for this credit. */
+            display_name: bcs.string(),
+            /** Roles assigned to the credited party. */
+            roles: bcs.vector(typeParameters[0])
+        } });
+}

package/src/contracts/composition_credits/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/src/contracts/composition_royalty_pool/composition_royalty_pool.ts

@@ -0,0 +1,135 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Cap-gated royalty-pool extension for `Composition`.
+ * 
+ * Royalty payers send `Coin<Currency>` directly to the composition's address — a
+ * stable, well-known inbox available from the composition's creation. The
+ * composition admin (cap holder) folds those funds into the underlying
+ * `royalty_pool::pool::RoyaltyPool` via `receive_and_deposit` (for direct coin
+ * transfers) or `redeem_and_deposit` (for funds-accumulator balances).
+ * 
+ * All three entry points require `&CompositionAdminCap`, so timing of fold
+ * operations stays under admin control.
+ */
+
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+export interface InitializePoolArguments {
+    composition: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface InitializePoolOptions {
+    package?: string;
+    arguments: InitializePoolArguments | [
+        composition: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Create a royalty pool for a composition. Pool address derives from
+ * `(composition_id, Currency)` — calling twice with the same Currency aborts
+ * because the address is already claimed.
+ */
+export function initializePool(options: InitializePoolOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["composition", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool',
+        function: 'initialize_pool',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ReceiveAndDepositArguments {
+    composition: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    coins: TransactionArgument;
+    pool: RawTransactionArgument<string>;
+}
+export interface ReceiveAndDepositOptions {
+    package?: string;
+    arguments: ReceiveAndDepositArguments | [
+        composition: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        coins: TransactionArgument,
+        pool: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Receive `Coin<Currency>` objects sent to the composition's address and fold them
+ * into the pool's accumulator.
+ */
+export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<null>',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["composition", "cap", "coins", "pool"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool',
+        function: 'receive_and_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RedeemAndDepositArguments {
+    composition: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
+    pool: RawTransactionArgument<string>;
+}
+export interface RedeemAndDepositOptions {
+    package?: string;
+    arguments: RedeemAndDepositArguments | [
+        composition: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>,
+        pool: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Redeem `value` base units from the composition's funds accumulator and fold the
+ * resulting balance into the pool's accumulator.
+ */
+export function redeemAndDeposit(options: RedeemAndDepositOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["composition", "cap", "value", "pool"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool',
+        function: 'redeem_and_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/cover_art/cover_art.ts

@@ -0,0 +1,99 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The evolvable cover art value used by the recording/release cover art
+ * extensions.
+ * 
+ * CoverArt format changes over time (static-only → +animated → future formats).
+ * Keeping it in an extension rather than immutable core means a new format is a
+ * republish of this small package (or a brand-new cover art standard), not of the
+ * frozen protocol. `CoverArt` references external storage via `ori::WalrusData`.
+ */
+
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as walrus_data from './deps/ori/walrus_data.js';
+const $moduleName = '@local-pkg/cover_art::cover_art';
+export const CoverArt = new MoveStruct({ name: `${$moduleName}::CoverArt`, fields: {
+        still: walrus_data.WalrusData,
+        animated: bcs.option(walrus_data.WalrusData)
+    } });
+export interface NewArguments {
+    still: TransactionArgument;
+    animated: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        still: TransactionArgument,
+        animated: TransactionArgument
+    ];
+}
+/**
+ * Creates cover art with a still image and optional animated version. Both
+ * references must be Walrus blobs.
+ */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/cover_art';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["still", "animated"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'cover_art',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface StillArguments {
+    self: TransactionArgument;
+}
+export interface StillOptions {
+    package?: string;
+    arguments: StillArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns a reference to the still image data. */
+export function still(options: StillOptions) {
+    const packageAddress = options.package ?? '@local-pkg/cover_art';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'cover_art',
+        function: 'still',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface AnimatedArguments {
+    self: TransactionArgument;
+}
+export interface AnimatedOptions {
+    package?: string;
+    arguments: AnimatedArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns a reference to the optional animated cover art data. */
+export function animated(options: AnimatedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/cover_art';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'cover_art',
+        function: 'animated',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}