@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/dist/_generated/zing_studio/studio.d.ts

@@ -0,0 +1,282 @@
+import { MoveTuple, MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const Period: MoveTuple<import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">[], "@local-pkg/zing_studio::studio::Period">;
+export declare const NewStudioEvent: MoveStruct<{
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    studio_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@local-pkg/zing_studio::studio::NewStudioEvent">;
+export declare const STUDIO: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/zing_studio::studio::STUDIO">;
+export declare const Studio: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** The owner of this studio - only they can add/remove works */
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    period: MoveTuple<import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">[], "@local-pkg/zing_studio::studio::Period">;
+    /**
+     * The fee amount charged by creators for fans to access their content. (quoted in
+     * USD)
+     */
+    monthly_subscription_fee: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: string;
+        }[], Iterable<{
+            key: number;
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u8, u64>">;
+    /** membership of your studio and expired timestamp; none means permanent membership */
+    membership: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "zing_framework::derived_table::DerivedTable">;
+    /** Bag containing the actual asset objects, indexed by their IDs */
+    works: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "zing_framework::derived_object_bag::DerivedObjectBag">;
+    encrypted_file_key: import("@mysten/sui/bcs").BcsType<number[] | null, (Iterable<number> & {
+        length: number;
+    }) | null | undefined, "Option<vector<u8>>">;
+}, "@local-pkg/zing_studio::studio::Studio">;
+export declare const Member: MoveStruct<{
+    level: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    expired_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::studio::Member">;
+export interface OwnerArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+    package?: string;
+    arguments: OwnerArguments | [self: RawTransactionArgument<string>];
+}
+/** Returns the owner address of this studio */
+export declare function owner(options: OwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PeriodArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface PeriodOptions {
+    package?: string;
+    arguments: PeriodArguments | [self: RawTransactionArgument<string>];
+}
+export declare function period(options: PeriodOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StartAtArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface StartAtOptions {
+    package?: string;
+    arguments: StartAtArguments | [self: RawTransactionArgument<string>];
+}
+export declare function startAt(options: StartAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EndAtArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface EndAtOptions {
+    package?: string;
+    arguments: EndAtArguments | [self: RawTransactionArgument<string>];
+}
+export declare function endAt(options: EndAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MemberLevelArguments {
+    member: RawTransactionArgument<string>;
+}
+export interface MemberLevelOptions {
+    package?: string;
+    arguments: MemberLevelArguments | [member: RawTransactionArgument<string>];
+}
+export declare function memberLevel(options: MemberLevelOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MemberExpiredAtArguments {
+    member: RawTransactionArgument<string>;
+}
+export interface MemberExpiredAtOptions {
+    package?: string;
+    arguments: MemberExpiredAtArguments | [member: RawTransactionArgument<string>];
+}
+export declare function memberExpiredAt(options: MemberExpiredAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MonthlySubscriptionFeeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MonthlySubscriptionFeeOptions {
+    package?: string;
+    arguments: MonthlySubscriptionFeeArguments | [self: RawTransactionArgument<string>];
+}
+export declare function monthlySubscriptionFee(options: MonthlySubscriptionFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MembershipArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MembershipOptions {
+    package?: string;
+    arguments: MembershipArguments | [self: RawTransactionArgument<string>];
+}
+export declare function membership(options: MembershipOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssetOfArguments {
+    self: RawTransactionArgument<string>;
+    assetId: RawTransactionArgument<string>;
+}
+export interface AssetOfOptions {
+    package?: string;
+    arguments: AssetOfArguments | [
+        self: RawTransactionArgument<string>,
+        assetId: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+/**
+ * Returns an immutable reference to a specific asset by its ID Panics if the asset
+ * doesn't exist or has wrong type
+ */
+export declare function assetOf(options: AssetOfOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WorksArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface WorksOptions {
+    package?: string;
+    arguments: WorksArguments | [self: RawTransactionArgument<string>];
+}
+export declare function works(options: WorksOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EncryptedFileKeyArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface EncryptedFileKeyOptions {
+    package?: string;
+    arguments: EncryptedFileKeyArguments | [self: RawTransactionArgument<string>];
+}
+export declare function encryptedFileKey(options: EncryptedFileKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SealApproveStudioOwnerArguments {
+    id: RawTransactionArgument<number[]>;
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+}
+export interface SealApproveStudioOwnerOptions {
+    package?: string;
+    arguments: SealApproveStudioOwnerArguments | [
+        id: RawTransactionArgument<number[]>,
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>
+    ];
+}
+export declare function sealApproveStudioOwner(options: SealApproveStudioOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SealApproveRegisteredEnclaveArguments {
+    id: RawTransactionArgument<number[]>;
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+    enclave: RawTransactionArgument<string>;
+}
+export interface SealApproveRegisteredEnclaveOptions {
+    package?: string;
+    arguments: SealApproveRegisteredEnclaveArguments | [
+        id: RawTransactionArgument<number[]>,
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>,
+        enclave: RawTransactionArgument<string>
+    ];
+}
+export declare function sealApproveRegisteredEnclave(options: SealApproveRegisteredEnclaveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SealApproveManagerArguments {
+    id: RawTransactionArgument<number[]>;
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+}
+export interface SealApproveManagerOptions {
+    package?: string;
+    arguments: SealApproveManagerArguments | [
+        id: RawTransactionArgument<number[]>,
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>
+    ];
+}
+export declare function sealApproveManager(options: SealApproveManagerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StudioOfArguments {
+    config: RawTransactionArgument<string>;
+    owner: RawTransactionArgument<string>;
+}
+export interface StudioOfOptions {
+    package?: string;
+    arguments: StudioOfArguments | [
+        config: RawTransactionArgument<string>,
+        owner: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Calculates the expected ID of a studio for a given owner Uses deterministic
+ * address derivation based on config and owner
+ */
+export declare function studioOf(options: StudioOfOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StudioExistsArguments {
+    config: RawTransactionArgument<string>;
+    owner: RawTransactionArgument<string>;
+}
+export interface StudioExistsOptions {
+    package?: string;
+    arguments: StudioExistsArguments | [
+        config: RawTransactionArgument<string>,
+        owner: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Checks if a studio already exists for the given owner Returns true if the studio
+ * has been created, false otherwise
+ */
+export declare function studioExists(options: StudioExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsInValidPeriodArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsInValidPeriodOptions {
+    package?: string;
+    arguments: IsInValidPeriodArguments | [self: RawTransactionArgument<string>];
+}
+export declare function isInValidPeriod(options: IsInValidPeriodOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MembershipLevelArguments {
+    self: RawTransactionArgument<string>;
+    member: RawTransactionArgument<string>;
+}
+export interface MembershipLevelOptions {
+    package?: string;
+    arguments: MembershipLevelArguments | [
+        self: RawTransactionArgument<string>,
+        member: RawTransactionArgument<string>
+    ];
+}
+export declare function membershipLevel(options: MembershipLevelOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsMembershipArguments {
+    self: RawTransactionArgument<string>;
+    member: RawTransactionArgument<string>;
+}
+export interface IsMembershipOptions {
+    package?: string;
+    arguments: IsMembershipArguments | [
+        self: RawTransactionArgument<string>,
+        member: RawTransactionArgument<string>
+    ];
+}
+export declare function isMembership(options: IsMembershipOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewArguments {
+    config: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [config: RawTransactionArgument<string>];
+}
+/**
+ * Creates a new personal studio as a shared object Each user can only have one
+ * studio, enforced by derived object mechanism The studio is immediately shared so
+ * others can view (but not modify) the works
+ */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ShareStudioArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ShareStudioOptions {
+    package?: string;
+    arguments: ShareStudioArguments | [self: RawTransactionArgument<string>];
+}
+export declare function shareStudio(options: ShareStudioOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/studio.js

@@ -0,0 +1,360 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as derived_object_bag from "./deps/zing_framework/derived_object_bag.js";
+import * as derived_table from "./deps/zing_framework/derived_table.js";
+import { MoveTuple, MoveStruct, normalizeMoveArguments, } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_studio::studio";
+export const Period = new MoveTuple({
+    name: `${$moduleName}::Period`,
+    fields: [bcs.u64(), bcs.u64()],
+});
+export const NewStudioEvent = new MoveStruct({
+    name: `${$moduleName}::NewStudioEvent`,
+    fields: {
+        owner: bcs.Address,
+        studio_id: bcs.Address,
+    },
+});
+export const STUDIO = new MoveStruct({
+    name: `${$moduleName}::STUDIO`,
+    fields: {
+        dummy_field: bcs.bool(),
+    },
+});
+export const Studio = new MoveStruct({
+    name: `${$moduleName}::Studio`,
+    fields: {
+        id: object.UID,
+        /** The owner of this studio - only they can add/remove works */
+        owner: bcs.Address,
+        period: Period,
+        /**
+         * The fee amount charged by creators for fans to access their content. (quoted in
+         * USD)
+         */
+        monthly_subscription_fee: vec_map.VecMap(bcs.u8(), bcs.u64()),
+        /** membership of your studio and expired timestamp; none means permanent membership */
+        membership: derived_table.DerivedTable,
+        /** Bag containing the actual asset objects, indexed by their IDs */
+        works: derived_object_bag.DerivedObjectBag,
+        encrypted_file_key: bcs.option(bcs.vector(bcs.u8())),
+    },
+});
+export const Member = new MoveStruct({
+    name: `${$moduleName}::Member`,
+    fields: {
+        level: bcs.u8(),
+        expired_at: bcs.u64(),
+    },
+});
+/** Returns the owner address of this studio */
+export function owner(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function period(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "period",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function startAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "start_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function endAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "end_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function memberLevel(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Member`,
+    ];
+    const parameterNames = ["member"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "member_level",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function memberExpiredAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Member`,
+    ];
+    const parameterNames = ["member"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "member_expired_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function monthlySubscriptionFee(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "monthly_subscription_fee",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function membership(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "membership",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns an immutable reference to a specific asset by its ID Panics if the asset
+ * doesn't exist or has wrong type
+ */
+export function assetOf(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::object::ID",
+    ];
+    const parameterNames = ["self", "assetId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "asset_of",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function works(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "works",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function encryptedFileKey(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "encrypted_file_key",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function sealApproveStudioOwner(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        "vector<u8>",
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["id", "config", "self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "seal_approve_studio_owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function sealApproveRegisteredEnclave(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        "vector<u8>",
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::studio::Studio`,
+        `${packageAddress}::enclave::Enclave`,
+    ];
+    const parameterNames = ["id", "config", "self", "enclave"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "seal_approve_registered_enclave",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function sealApproveManager(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        "vector<u8>",
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["id", "config", "self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "seal_approve_manager",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Calculates the expected ID of a studio for a given owner Uses deterministic
+ * address derivation based on config and owner
+ */
+export function studioOf(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        "address",
+    ];
+    const parameterNames = ["config", "owner"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "studio_of",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Checks if a studio already exists for the given owner Returns true if the studio
+ * has been created, false otherwise
+ */
+export function studioExists(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        "address",
+    ];
+    const parameterNames = ["config", "owner"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "studio_exists",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isInValidPeriod(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "is_in_valid_period",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function membershipLevel(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+        "address",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["self", "member"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "membership_level",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isMembership(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+        "address",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["self", "member"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "is_membership",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Creates a new personal studio as a shared object Each user can only have one
+ * studio, enforced by derived object mechanism The studio is immediately shared so
+ * others can view (but not modify) the works
+ */
+export function _new(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "new",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function shareStudio(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "share_studio",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}