@misofm/sdk 0.9.0 → 0.11.0

package/src/contracts/recording_language/recording_language.ts

@@ -0,0 +1,237 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The languages sung or spoken on a recording, stored as a dynamic field on the
+ * recording's UID and written through its cap-gated `uid_mut`.
+ * 
+ * Its own package, for the same reason the advisory rating is: language is set by
+ * different people, at different times, and governed by a standard (ISO 639) that
+ * has nothing to do with any other fact about the recording. A consumer
+ * implementing a metadata profile picks this extension up or leaves it, and
+ * replacing it never disturbs anything else attached to the work.
+ * 
+ * A `vector`, not a single code — bilingual and code-switching recordings are
+ * ordinary, and forcing one language would mean choosing which of them to erase.
+ * Order is the caller's: first is conventionally the predominant one.
+ * 
+ * **An empty vector means instrumental** — attached, and asserting there is no
+ * sung or spoken content at all. That is a genuine claim about the recording and
+ * is deliberately distinct from attaching nothing, which says only that nobody has
+ * looked. `set_instrumental` exists so that claim reads as intent at the call site
+ * rather than as an empty argument someone might mistake for an oversight.
+ * 
+ * `LanguageCode` is a valid ISO 639-1 code by construction, so this package checks
+ * only what construction cannot: how many, and whether any repeat.
+ */
+
+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 language_code from './deps/language_code/language_code.js';
+const $moduleName = '@local-pkg/recording_language::recording_language';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const LanguagesSetEvent = new MoveStruct({ name: `${$moduleName}::LanguagesSetEvent`, fields: {
+        recording_id: bcs.Address,
+        languages: bcs.vector(language_code.LanguageCode)
+    } });
+export const LanguagesUnsetEvent = new MoveStruct({ name: `${$moduleName}::LanguagesUnsetEvent`, fields: {
+        recording_id: bcs.Address
+    } });
+export interface SetLanguagesArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    languages: TransactionArgument;
+}
+export interface SetLanguagesOptions {
+    package?: string;
+    arguments: SetLanguagesArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        languages: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Sets (or replaces) the languages sung or spoken on the recording.
+ *
+ * Passing an empty vector asserts the recording is instrumental; prefer
+ * `set_instrumental`, which says so at the call site.
+ */
+export function setLanguages(options: SetLanguagesOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_language';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "languages"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_language',
+        function: 'set_languages',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface SetInstrumentalArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface SetInstrumentalOptions {
+    package?: string;
+    arguments: SetInstrumentalArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Asserts the recording has no sung or spoken content. */
+export function setInstrumental(options: SetInstrumentalOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_language';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_language',
+        function: 'set_instrumental',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnsetLanguagesArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetLanguagesOptions {
+    package?: string;
+    arguments: UnsetLanguagesArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the language record, if any. Idempotent. Leaves the recording having
+ * said nothing — which is not the same as asserting it is instrumental.
+ */
+export function unsetLanguages(options: UnsetLanguagesOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_language';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_language',
+        function: 'unset_languages',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasLanguagesArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasLanguagesOptions {
+    package?: string;
+    arguments: HasLanguagesArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Whether a language record is attached to this recording. */
+export function hasLanguages(options: HasLanguagesOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_language';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_language',
+        function: 'has_languages',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface LanguagesArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface LanguagesOptions {
+    package?: string;
+    arguments: LanguagesArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * The recording's languages, in the order given. Empty means instrumental. Aborts
+ * if nothing is attached — absence is a distinct state from an empty vector and
+ * must not collapse into it.
+ */
+export function languages(options: LanguagesOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_language';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_language',
+        function: 'languages',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsInstrumentalArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsInstrumentalOptions {
+    package?: string;
+    arguments: IsInstrumentalArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Whether the recording asserts it is instrumental: attached, and empty. False
+ * when nothing is attached, because that asserts nothing.
+ */
+export function isInstrumental(options: IsInstrumentalOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_language';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_language',
+        function: 'is_instrumental',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/recording_master_reference/deps/ori/walrus_data.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct, MoveTuple } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'ori::walrus_data';
+/**
+ * Confidentiality of a stored blob: cleartext, or encrypted with an access policy.
+ * Only applies to standalone blobs — a quilt patch is a slice of a shared quilt
+ * blob and can never be the direct product of an encryption.
+ */
+export const Confidentiality = new MoveEnum({ name: `${$moduleName}::Confidentiality`, fields: {
+        /** The blob is stored in the clear. */
+        Unencrypted: null,
+        /**
+         * The blob is AES-encrypted. `dek` is the AES data-encryption key sealed via Seal
+         * — a small ciphertext stored on-chain, not the blob bytes. The sealed DEK is
+         * itself a Seal `EncryptedObject`, which already carries the decryption-policy
+         * package id, so no separate policy field is stored here. Decryption is gated by
+         * that policy package's `seal_approve`, not by this library.
+         */
+        Encrypted: new MoveStruct({ name: `Confidentiality.Encrypted`, fields: {
+                dek: bcs.vector(bcs.u8())
+            } })
+    } });
+/** Represents either a standalone Walrus blob or a patch within a quilt. */
+export const WalrusData = new MoveEnum({ name: `${$moduleName}::WalrusData`, fields: {
+        /** A standalone Walrus blob. Fields: blob_id, confidentiality. */
+        Blob: new MoveTuple({ name: `WalrusData.Blob`, fields: [bcs.u256(), Confidentiality] }),
+        /**
+         * A patch within a Walrus quilt. Fields: quilt_id, version, start_index,
+         * end_index. Always a plaintext reference into a (possibly separately encrypted)
+         * quilt blob.
+         */
+        QuiltPatch: new MoveTuple({ name: `WalrusData.QuiltPatch`, fields: [bcs.u256(), bcs.u8(), bcs.u16(), bcs.u16()] })
+    } });

package/src/contracts/recording_master_reference/recording_master_reference.ts

@@ -0,0 +1,181 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A pointer to a recording's master audio — nothing more.
+ * 
+ * The value is a bare `ori::WalrusData` blob reference. This extension makes no
+ * claim about what the blob contains: not its codec, not its sample rate, not its
+ * duration, not that it is even audio. The only assertion is that the holder of
+ * the recording's admin cap says this blob is the master. Everything else is
+ * client-side convention.
+ * 
+ * That thinness is the point. Miso's attested path — the Nautilus-verified master
+ * flow (`audio_ingester` producing a `miso_audio::Audio`), deferred — carries
+ * channel count, bit depth, sample rate, sample count and a PCM digest, and every
+ * one of those is backed by a Nautilus enclave signature over the measured audio.
+ * Until that path is running, stating the same fields _unverified_ would dress an
+ * assertion up as a measurement. A pointer cannot be mistaken for a measurement.
+ * 
+ * # This extension is a holdover
+ * 
+ * It exists to carry the catalogue until enclave ingestion is ready, and it is
+ * meant to be removed rather than grown. When a recording's master is ingested for
+ * real, attach the attested master via the ingester's master flow and call
+ * `unset_master_reference` here. The two never need to coexist, and this package
+ * deliberately holds nothing the attested path cannot restate.
+ * 
+ * Resist adding fields. Anything worth asserting about the audio is worth
+ * attesting, and belongs in the ingested `Audio` rather than here.
+ */
+
+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 walrus_data from './deps/ori/walrus_data.js';
+const $moduleName = '@local-pkg/recording_master_reference::recording_master_reference';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const MasterReferenceSetEvent = new MoveStruct({ name: `${$moduleName}::MasterReferenceSetEvent`, fields: {
+        recording_id: bcs.Address,
+        reference: walrus_data.WalrusData
+    } });
+export const MasterReferenceUnsetEvent = new MoveStruct({ name: `${$moduleName}::MasterReferenceUnsetEvent`, fields: {
+        recording_id: bcs.Address
+    } });
+export interface SetMasterReferenceArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    reference: TransactionArgument;
+}
+export interface SetMasterReferenceOptions {
+    package?: string;
+    arguments: SetMasterReferenceArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        reference: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Sets (or replaces) the recording's master reference.
+ *
+ * The reference must be a standalone blob. A quilt patch is rejected: a master is
+ * addressed and fetched on its own, and batching it with unrelated files would
+ * make its identity depend on what it happened to be stored alongside. Encrypted
+ * blobs are accepted — a sealed master is the expected shape once access control
+ * lands, and the reference is the same either way.
+ */
+export function setMasterReference(options: SetMasterReferenceOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_master_reference';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "reference"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_master_reference',
+        function: 'set_master_reference',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnsetMasterReferenceArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetMasterReferenceOptions {
+    package?: string;
+    arguments: UnsetMasterReferenceArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the master reference, if any. Idempotent.
+ *
+ * The intended use is migration: once an attested master is attached via the
+ * Nautilus-verified master flow (deferred), this reference has nothing left to say
+ * and should go.
+ */
+export function unsetMasterReference(options: UnsetMasterReferenceOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_master_reference';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_master_reference',
+        function: 'unset_master_reference',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasMasterReferenceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasMasterReferenceOptions {
+    package?: string;
+    arguments: HasMasterReferenceArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Whether a master reference is attached to this recording. */
+export function hasMasterReference(options: HasMasterReferenceOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_master_reference';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_master_reference',
+        function: 'has_master_reference',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface MasterReferenceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MasterReferenceOptions {
+    package?: string;
+    arguments: MasterReferenceArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** The recording's master reference. Aborts if none is attached. */
+export function masterReference(options: MasterReferenceOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_master_reference';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_master_reference',
+        function: 'master_reference',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/recording_preview/deps/ori/walrus_data.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct, MoveTuple } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'ori::walrus_data';
+/**
+ * Confidentiality of a stored blob: cleartext, or encrypted with an access policy.
+ * Only applies to standalone blobs — a quilt patch is a slice of a shared quilt
+ * blob and can never be the direct product of an encryption.
+ */
+export const Confidentiality = new MoveEnum({ name: `${$moduleName}::Confidentiality`, fields: {
+        /** The blob is stored in the clear. */
+        Unencrypted: null,
+        /**
+         * The blob is AES-encrypted. `dek` is the AES data-encryption key sealed via Seal
+         * — a small ciphertext stored on-chain, not the blob bytes. The sealed DEK is
+         * itself a Seal `EncryptedObject`, which already carries the decryption-policy
+         * package id, so no separate policy field is stored here. Decryption is gated by
+         * that policy package's `seal_approve`, not by this library.
+         */
+        Encrypted: new MoveStruct({ name: `Confidentiality.Encrypted`, fields: {
+                dek: bcs.vector(bcs.u8())
+            } })
+    } });
+/** Represents either a standalone Walrus blob or a patch within a quilt. */
+export const WalrusData = new MoveEnum({ name: `${$moduleName}::WalrusData`, fields: {
+        /** A standalone Walrus blob. Fields: blob_id, confidentiality. */
+        Blob: new MoveTuple({ name: `WalrusData.Blob`, fields: [bcs.u256(), Confidentiality] }),
+        /**
+         * A patch within a Walrus quilt. Fields: quilt_id, version, start_index,
+         * end_index. Always a plaintext reference into a (possibly separately encrypted)
+         * quilt blob.
+         */
+        QuiltPatch: new MoveTuple({ name: `WalrusData.QuiltPatch`, fields: [bcs.u256(), bcs.u8(), bcs.u16(), bcs.u16()] })
+    } });

package/src/contracts/recording_preview/recording_preview.ts

@@ -0,0 +1,154 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Recording audio preview: a short, public teaser clip for a recording, stored as
+ * a dynamic field on the recording's UID, set/cleared via the recording's
+ * cap-gated `uid_mut`.
+ * 
+ * V1 is deliberately minimal: the value is a bare `ori::WalrusData` blob reference
+ * — no ingestion or attestation ties the preview to the recording's master. What
+ * the blob contains (codec, duration, clip offset) is client-side convention, not
+ * protocol state. An attested preview standard can ship later as its own extension
+ * without touching this one.
+ */
+
+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 walrus_data from './deps/ori/walrus_data.js';
+const $moduleName = '@local-pkg/recording_preview::recording_preview';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const PreviewSetEvent = new MoveStruct({ name: `${$moduleName}::PreviewSetEvent`, fields: {
+        recording_id: bcs.Address,
+        preview: walrus_data.WalrusData
+    } });
+export const PreviewUnsetEvent = new MoveStruct({ name: `${$moduleName}::PreviewUnsetEvent`, fields: {
+        recording_id: bcs.Address
+    } });
+export interface SetPreviewArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    preview: TransactionArgument;
+}
+export interface SetPreviewOptions {
+    package?: string;
+    arguments: SetPreviewArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        preview: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Sets (or replaces) the recording's preview. The reference must be a standalone
+ * Walrus blob.
+ */
+export function setPreview(options: SetPreviewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_preview';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "preview"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_preview',
+        function: 'set_preview',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnsetPreviewArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetPreviewOptions {
+    package?: string;
+    arguments: UnsetPreviewArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Removes the preview, if any. */
+export function unsetPreview(options: UnsetPreviewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_preview';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_preview',
+        function: 'unset_preview',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasPreviewArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasPreviewOptions {
+    package?: string;
+    arguments: HasPreviewArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns whether a preview is attached to this recording. */
+export function hasPreview(options: HasPreviewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_preview';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_preview',
+        function: 'has_preview',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PreviewArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface PreviewOptions {
+    package?: string;
+    arguments: PreviewArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows the preview's Walrus reference. Aborts if none is attached. */
+export function preview(options: PreviewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_preview';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_preview',
+        function: 'preview',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}