@misonetwork/sdk 0.7.0 → 0.8.0

package/dist/contracts/recording_credits/recording_party_role.js

@@ -0,0 +1,692 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Defines the roles that parties can hold on a recording. Recordings are audio
+ * performances of compositions, and these roles represent the various production
+ * and performance contributions.
+ *
+ * ### Design
+ *
+ * `RecordingPartyRole` 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.
+ *
+ * - **Seniority is a separate axis.** Most roles carry an optional
+ *   `RecordingPartyRoleLevel` (Lead, Assistant, Additional, …). Industry variants
+ *   like "Second Engineer" or "Additional Producer" are expressed as a base role
+ *   plus a level, not as their own variants — this keeps the role set compact
+ *   without losing the distinction.
+ * - **`Custom` is the escape hatch.** The canonical variants cover the common
+ *   vocabulary; anything outside it is a `Custom(name, level)` whose name is
+ *   validated like an instrument name. Prefer a canonical variant when one fits.
+ * - **`name()` is the canonical identifier**, returned as a stable PascalCase
+ *   token (e.g. `"MixingEngineer"`). It doubles as an on-chain match key and as
+ *   the seed for off-chain display/localization. For `Custom`, `name()` returns
+ *   the user-supplied string; for `Instrumentalist`, it returns
+ *   `"Instrumentalist"` (the instrument itself is read off-chain).
+ *
+ * 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, MoveTuple, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import {} from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/recording_credits::recording_party_role';
+/** Indicates the seniority or prominence level of a party. */
+export const RecordingPartyRoleLevel = new MoveEnum({ name: `${$moduleName}::RecordingPartyRoleLevel`, fields: {
+        /** Additional/supplementary party. */
+        Additional: null,
+        /** Assistant to the primary party. */
+        Assistant: null,
+        /** Associate-level party. */
+        Associate: null,
+        /** Backing/support role (e.g., backing vocals). */
+        Backing: null,
+        /** Executive-level oversight role. */
+        Executive: null,
+        /** Featured prominently on the recording. */
+        Featured: null,
+        /** Lead/primary party in this role. */
+        Lead: null,
+        /** Primary artist on the recording. */
+        Primary: null,
+        /** Principal party with primary responsibility. */
+        Principal: null
+    } });
+/**
+ * Represents a party's role on a recording. Most roles carry an optional level to
+ * indicate seniority/prominence; `ArtistsAndRepertoire` and `Copyist` are
+ * clerical/business roles that do not.
+ */
+export const RecordingPartyRole = new MoveEnum({ name: `${$moduleName}::RecordingPartyRole`, fields: {
+        /** Performed voice acting or spoken-word performance. */
+        Actor: bcs.option(RecordingPartyRoleLevel),
+        /** Arranged the musical parts for the recording. */
+        Arranger: bcs.option(RecordingPartyRoleLevel),
+        /** A&R representative who discovered or developed the artist. */
+        ArtistsAndRepertoire: null,
+        /** Led the band or backing ensemble. */
+        BandLeader: bcs.option(RecordingPartyRoleLevel),
+        /** Performed as part of a choir. */
+        Choir: bcs.option(RecordingPartyRoleLevel),
+        /** Directed the choir performance. */
+        ChoirMaster: bcs.option(RecordingPartyRoleLevel),
+        /** Lead performer of an orchestra/ensemble (e.g. first-chair). */
+        ConcertMaster: bcs.option(RecordingPartyRoleLevel),
+        /** Conducted the orchestra or ensemble. */
+        Conductor: bcs.option(RecordingPartyRoleLevel),
+        /** Hired and managed session musicians. */
+        Contractor: bcs.option(RecordingPartyRoleLevel),
+        /** Prepared written music parts for performers. */
+        Copyist: null,
+        /** Performed/assembled the recording as a disc jockey. */
+        DJ: bcs.option(RecordingPartyRoleLevel),
+        /** Edited and compiled audio takes. */
+        Editor: bcs.option(RecordingPartyRoleLevel),
+        /** General engineering contribution not covered by a specific engineer role. */
+        Engineer: bcs.option(RecordingPartyRoleLevel),
+        /** Performed as part of a musical ensemble. */
+        Ensemble: bcs.option(RecordingPartyRoleLevel),
+        /** Played an instrument on the recording. Carries the instrument name. */
+        Instrumentalist: new MoveTuple({ name: `RecordingPartyRole.Instrumentalist`, fields: [bcs.string(), bcs.option(RecordingPartyRoleLevel)] }),
+        /** Mastered the final audio for distribution. */
+        MasteringEngineer: bcs.option(RecordingPartyRoleLevel),
+        /** Mixed the multitrack recording into stereo/surround. */
+        MixingEngineer: bcs.option(RecordingPartyRoleLevel),
+        /** Directed the musical performance. */
+        MusicDirector: bcs.option(RecordingPartyRoleLevel),
+        /** Oversaw music selection and licensing. */
+        MusicSupervisor: bcs.option(RecordingPartyRoleLevel),
+        /** Narrated spoken content. */
+        Narrator: bcs.option(RecordingPartyRoleLevel),
+        /** Performed as part of an orchestra. */
+        Orchestra: bcs.option(RecordingPartyRoleLevel),
+        /** Created orchestral arrangements. */
+        Orchestrator: bcs.option(RecordingPartyRoleLevel),
+        /** Performed on the recording (general performer). */
+        Performer: bcs.option(RecordingPartyRoleLevel),
+        /** Oversaw the creative and technical aspects of the recording. */
+        Producer: bcs.option(RecordingPartyRoleLevel),
+        /** Programmed beats, synths, or electronic elements. */
+        Programmer: bcs.option(RecordingPartyRoleLevel),
+        /** Operated recording equipment during sessions. */
+        RecordingEngineer: bcs.option(RecordingPartyRoleLevel),
+        /** Created a remix of the recording. */
+        RemixingEngineer: bcs.option(RecordingPartyRoleLevel),
+        /** Performed a solo part. */
+        Soloist: bcs.option(RecordingPartyRoleLevel),
+        /** Created sound effects or sonic textures. */
+        SoundDesigner: bcs.option(RecordingPartyRoleLevel),
+        /** Delivered spoken-word or presentation content. */
+        Speaker: bcs.option(RecordingPartyRoleLevel),
+        /** Provided vocals on the recording. */
+        Vocalist: bcs.option(RecordingPartyRoleLevel),
+        /**
+         * A user-defined role not covered by a canonical variant. Carries the role name
+         * (validated like an instrument name) and an optional level. An escape hatch —
+         * prefer a canonical variant when one fits.
+         */
+        Custom: new MoveTuple({ name: `RecordingPartyRole.Custom`, fields: [bcs.string(), bcs.option(RecordingPartyRoleLevel)] })
+    } });
+/** Creates a new Actor role with optional level. */
+export function newActorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_actor_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Arranger role with optional level. */
+export function newArrangerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_arranger_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Artists & Repertoire role. */
+export function newArtistsAndRepertoireRole(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_artists_and_repertoire_role',
+    });
+}
+/** Creates a new Band Leader role with optional level. */
+export function newBandLeaderRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_band_leader_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Choir role with optional level. */
+export function newChoirRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_choir_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Choir Master role with optional level. */
+export function newChoirMasterRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_choir_master_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Concert Master role with optional level. */
+export function newConcertMasterRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_concert_master_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Conductor role with optional level. */
+export function newConductorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_conductor_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Contractor role with optional level. */
+export function newContractorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_contractor_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Copyist role. */
+export function newCopyistRole(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_copyist_role',
+    });
+}
+/** Creates a new DJ role with optional level. */
+export function newDjRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_dj_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Editor role with optional level. */
+export function newEditorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_editor_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new (general) Engineer role with optional level. */
+export function newEngineerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_engineer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Ensemble role with optional level. */
+export function newEnsembleRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_ensemble_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Creates a new Instrumentalist role with instrument name and optional level. The
+ * instrument name freezes into credits, so it is validated here.
+ */
+export function newInstrumentalistRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        '0x1::string::String',
+        null
+    ];
+    const parameterNames = ["instrument", "level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_instrumentalist_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Mastering Engineer role with optional level. */
+export function newMasteringEngineerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_mastering_engineer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Mixing Engineer role with optional level. */
+export function newMixingEngineerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_mixing_engineer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Music Director role with optional level. */
+export function newMusicDirectorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_music_director_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Music Supervisor role with optional level. */
+export function newMusicSupervisorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_music_supervisor_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Narrator role with optional level. */
+export function newNarratorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_narrator_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Orchestra role with optional level. */
+export function newOrchestraRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_orchestra_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Orchestrator role with optional level. */
+export function newOrchestratorRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_orchestrator_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Performer role with optional level. */
+export function newPerformerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_performer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Producer role with optional level. */
+export function newProducerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_producer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Programmer role with optional level. */
+export function newProgrammerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_programmer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Recording Engineer role with optional level. */
+export function newRecordingEngineerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_recording_engineer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Remixing Engineer role with optional level. */
+export function newRemixingEngineerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_remixing_engineer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Soloist role with optional level. */
+export function newSoloistRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_soloist_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Sound Designer role with optional level. */
+export function newSoundDesignerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_sound_designer_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Speaker role with optional level. */
+export function newSpeakerRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_speaker_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new Vocalist role with optional level. */
+export function newVocalistRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_vocalist_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Creates a new Custom role with a user-defined name and optional level. The name
+ * freezes into credits, so it is validated like an instrument name. Prefer a
+ * canonical variant when one fits.
+ */
+export function newCustomRole(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        '0x1::string::String',
+        null
+    ];
+    const parameterNames = ["roleName", "level"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_custom_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates an Additional level. */
+export function newAdditionalRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_additional_role_level',
+    });
+}
+/** Creates an Assistant level. */
+export function newAssistantRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_assistant_role_level',
+    });
+}
+/** Creates an Associate level. */
+export function newAssociateRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_associate_role_level',
+    });
+}
+/** Creates a Backing level. */
+export function newBackingRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_backing_role_level',
+    });
+}
+/** Creates an Executive level. */
+export function newExecutiveRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_executive_role_level',
+    });
+}
+/** Creates a Featured level. */
+export function newFeaturedRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_featured_role_level',
+    });
+}
+/** Creates a Lead level. */
+export function newLeadRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_lead_role_level',
+    });
+}
+/** Creates a Primary level. */
+export function newPrimaryRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_primary_role_level',
+    });
+}
+/** Creates a Principal level. */
+export function newPrincipalRoleLevel(options = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'new_principal_role_level',
+    });
+}
+/** Returns the optional level associated with this role. */
+export function level(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'level',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns the canonical identifier of the role as a stable PascalCase token. For
+ * `Custom`, returns the user-supplied name; for `Instrumentalist`, returns
+ * `"Instrumentalist"` (the instrument is read off-chain).
+ */
+export function name(options) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_party_role',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+//# sourceMappingURL=recording_party_role.js.map