@zing-protocol/zing-sdk 0.0.1 → 0.0.2

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

@@ -0,0 +1,331 @@
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const File: MoveStruct<{
+    /**
+     * Whether the file is publicly accessible Index of the blob containing this file's
+     * data
+     */
+    blob_index: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** MIME type of the file */
+    mime_type: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    /** Size of the file in bytes */
+    size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::article::File">;
+export declare const PublishArticleEvent: MoveStruct<{
+    article_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    blob_ids: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    blob_sizes: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    blob_storage_sizes: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    blob_end_epochs: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    files: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: {
+                blob_index: string;
+                mime_type: string;
+                size: string;
+            };
+        }[], Iterable<{
+            key: string;
+            value: {
+                blob_index: string | number | bigint;
+                mime_type: string;
+                size: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, @local-pkg/zing_studio::article::File>">;
+    timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::article::PublishArticleEvent">;
+export declare const BurnArticleEvent: MoveStruct<{
+    article_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    blob_end_epochs: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::article::BurnArticleEvent">;
+export declare const RenewArticleEvent: MoveStruct<{
+    article_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    prev_blob_end_epochs: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    new_blob_end_epochs: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@local-pkg/zing_studio::article::RenewArticleEvent">;
+export declare const ARTICLE: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/zing_studio::article::ARTICLE">;
+export declare const Article: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    deleted: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+    created_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    subscription_level: import("@mysten/sui/bcs").BcsType<number | null, number | null | undefined, "Option<u8>">;
+    /**
+     * Storage blobs containing the article content (all blobs must have compatible
+     * properties)
+     */
+    blobs: import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: string;
+        };
+        registered_epoch: number;
+        blob_id: string;
+        size: string;
+        encoding_type: number;
+        certified_epoch: number | null;
+        storage: {
+            id: {
+                id: string;
+            };
+            start_epoch: number;
+            end_epoch: number;
+            storage_size: string;
+        };
+        deletable: boolean;
+    }[], Iterable<{
+        id: {
+            id: string | Uint8Array<ArrayBufferLike>;
+        };
+        registered_epoch: number;
+        blob_id: string | number | bigint;
+        size: string | number | bigint;
+        encoding_type: number;
+        certified_epoch: number | null | undefined;
+        storage: {
+            id: {
+                id: string | Uint8Array<ArrayBufferLike>;
+            };
+            start_epoch: number;
+            end_epoch: number;
+            storage_size: string | number | bigint;
+        };
+        deletable: boolean;
+    }> & {
+        length: number;
+    }, string>;
+    /** Maps file identifiers to their corresponding metadata */
+    files: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: {
+                blob_index: string;
+                mime_type: string;
+                size: string;
+            };
+        }[], Iterable<{
+            key: string;
+            value: {
+                blob_index: string | number | bigint;
+                mime_type: string;
+                size: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, @local-pkg/zing_studio::article::File>">;
+}, "@local-pkg/zing_studio::article::Article">;
+export interface OwnerArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+    package?: string;
+    arguments: OwnerArguments | [self: RawTransactionArgument<string>];
+}
+export declare function owner(options: OwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DeletedArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface DeletedOptions {
+    package?: string;
+    arguments: DeletedArguments | [self: RawTransactionArgument<string>];
+}
+export declare function deleted(options: DeletedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreatedAtArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CreatedAtOptions {
+    package?: string;
+    arguments: CreatedAtArguments | [self: RawTransactionArgument<string>];
+}
+export declare function createdAt(options: CreatedAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SubscriptionLevelArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface SubscriptionLevelOptions {
+    package?: string;
+    arguments: SubscriptionLevelArguments | [self: RawTransactionArgument<string>];
+}
+export declare function subscriptionLevel(options: SubscriptionLevelOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BlobsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface BlobsOptions {
+    package?: string;
+    arguments: BlobsArguments | [self: RawTransactionArgument<string>];
+}
+export declare function blobs(options: BlobsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FilesArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface FilesOptions {
+    package?: string;
+    arguments: FilesArguments | [self: RawTransactionArgument<string>];
+}
+export declare function files(options: FilesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EndEpochArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface EndEpochOptions {
+    package?: string;
+    arguments: EndEpochArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Returns the end epoch of the article (assumes all blobs have the same end epoch)
+ * SECURITY NOTE: This function assumes blobs[0] exists and all blobs have the same
+ * end epoch
+ */
+export declare function endEpoch(options: EndEpochOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TotalBlobSizeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TotalBlobSizeOptions {
+    package?: string;
+    arguments: TotalBlobSizeArguments | [self: RawTransactionArgument<string>];
+}
+/** Calculates the total size of all blobs in the article */
+export declare function totalBlobSize(options: TotalBlobSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsExpiredArguments {
+    self: RawTransactionArgument<string>;
+    walrusSystem: RawTransactionArgument<string>;
+}
+export interface IsExpiredOptions {
+    package?: string;
+    arguments: IsExpiredArguments | [
+        self: RawTransactionArgument<string>,
+        walrusSystem: RawTransactionArgument<string>
+    ];
+}
+export declare function isExpired(options: IsExpiredOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsPublicArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsPublicOptions {
+    package?: string;
+    arguments: IsPublicArguments | [self: RawTransactionArgument<string>];
+}
+export declare function isPublic(options: IsPublicOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BlobIndexArguments {
+    file: RawTransactionArgument<string>;
+}
+export interface BlobIndexOptions {
+    package?: string;
+    arguments: BlobIndexArguments | [file: RawTransactionArgument<string>];
+}
+export declare function blobIndex(options: BlobIndexOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MimeTypeArguments {
+    file: RawTransactionArgument<string>;
+}
+export interface MimeTypeOptions {
+    package?: string;
+    arguments: MimeTypeArguments | [file: RawTransactionArgument<string>];
+}
+export declare function mimeType(options: MimeTypeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FileSizeArguments {
+    file: RawTransactionArgument<string>;
+}
+export interface FileSizeOptions {
+    package?: string;
+    arguments: FileSizeArguments | [file: RawTransactionArgument<string>];
+}
+export declare function fileSize(options: FileSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArticleBlobAddMetadataArguments {
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+    blobIndex: RawTransactionArgument<number | bigint>;
+    metadata: RawTransactionArgument<string>;
+}
+export interface ArticleBlobAddMetadataOptions {
+    package?: string;
+    arguments: ArticleBlobAddMetadataArguments | [
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>,
+        blobIndex: RawTransactionArgument<number | bigint>,
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function articleBlobAddMetadata(options: ArticleBlobAddMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArticleBlobRemoveMetadataArguments {
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+    blobIndex: RawTransactionArgument<number | bigint>;
+    key: RawTransactionArgument<string>;
+}
+export interface ArticleBlobRemoveMetadataOptions {
+    package?: string;
+    arguments: ArticleBlobRemoveMetadataArguments | [
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>,
+        blobIndex: RawTransactionArgument<number | bigint>,
+        key: RawTransactionArgument<string>
+    ];
+}
+export declare function articleBlobRemoveMetadata(options: ArticleBlobRemoveMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArticleBlobInsertOrUpdateMetadataPairArguments {
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+    blobIndex: RawTransactionArgument<number | bigint>;
+    key: RawTransactionArgument<string>;
+    value: RawTransactionArgument<string>;
+}
+export interface ArticleBlobInsertOrUpdateMetadataPairOptions {
+    package?: string;
+    arguments: ArticleBlobInsertOrUpdateMetadataPairArguments | [
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>,
+        blobIndex: RawTransactionArgument<number | bigint>,
+        key: RawTransactionArgument<string>,
+        value: RawTransactionArgument<string>
+    ];
+}
+export declare function articleBlobInsertOrUpdateMetadataPair(options: ArticleBlobInsertOrUpdateMetadataPairOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CertifyArticleBlobArguments {
+    config: RawTransactionArgument<string>;
+    self: RawTransactionArgument<string>;
+    walrusSystem: RawTransactionArgument<string>;
+    blobIndex: RawTransactionArgument<number | bigint>;
+    signature: RawTransactionArgument<number[]>;
+    signersBitmap: RawTransactionArgument<number[]>;
+    message: RawTransactionArgument<number[]>;
+}
+export interface CertifyArticleBlobOptions {
+    package?: string;
+    arguments: CertifyArticleBlobArguments | [
+        config: RawTransactionArgument<string>,
+        self: RawTransactionArgument<string>,
+        walrusSystem: RawTransactionArgument<string>,
+        blobIndex: RawTransactionArgument<number | bigint>,
+        signature: RawTransactionArgument<number[]>,
+        signersBitmap: RawTransactionArgument<number[]>,
+        message: RawTransactionArgument<number[]>
+    ];
+}
+export declare function certifyArticleBlob(options: CertifyArticleBlobOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/article.js

@@ -0,0 +1,331 @@
+/**************************************************************
+ * 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 blob from "./deps/walrus/blob.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_studio::article";
+export const File = new MoveStruct({
+    name: `${$moduleName}::File`,
+    fields: {
+        /**
+         * Whether the file is publicly accessible Index of the blob containing this file's
+         * data
+         */
+        blob_index: bcs.u64(),
+        /** MIME type of the file */
+        mime_type: bcs.string(),
+        /** Size of the file in bytes */
+        size: bcs.u64(),
+    },
+});
+export const PublishArticleEvent = new MoveStruct({
+    name: `${$moduleName}::PublishArticleEvent`,
+    fields: {
+        article_id: bcs.Address,
+        owner: bcs.Address,
+        blob_ids: bcs.vector(bcs.u256()),
+        blob_sizes: bcs.vector(bcs.u64()),
+        blob_storage_sizes: bcs.vector(bcs.u64()),
+        blob_end_epochs: bcs.vector(bcs.u32()),
+        files: vec_map.VecMap(bcs.string(), File),
+        timestamp_ms: bcs.u64(),
+    },
+});
+export const BurnArticleEvent = new MoveStruct({
+    name: `${$moduleName}::BurnArticleEvent`,
+    fields: {
+        article_id: bcs.Address,
+        owner: bcs.Address,
+        current_epoch: bcs.u32(),
+        blob_end_epochs: bcs.vector(bcs.u32()),
+        timestamp_ms: bcs.u64(),
+    },
+});
+export const RenewArticleEvent = new MoveStruct({
+    name: `${$moduleName}::RenewArticleEvent`,
+    fields: {
+        article_id: bcs.Address,
+        owner: bcs.Address,
+        current_epoch: bcs.u32(),
+        prev_blob_end_epochs: bcs.vector(bcs.u32()),
+        new_blob_end_epochs: bcs.vector(bcs.u32()),
+    },
+});
+export const ARTICLE = new MoveStruct({
+    name: `${$moduleName}::ARTICLE`,
+    fields: {
+        dummy_field: bcs.bool(),
+    },
+});
+export const Article = new MoveStruct({
+    name: `${$moduleName}::Article`,
+    fields: {
+        id: object.UID,
+        owner: bcs.Address,
+        deleted: bcs.bool(),
+        created_at: bcs.u64(),
+        subscription_level: bcs.option(bcs.u8()),
+        /**
+         * Storage blobs containing the article content (all blobs must have compatible
+         * properties)
+         */
+        blobs: bcs.vector(blob.Blob),
+        /** Maps file identifiers to their corresponding metadata */
+        files: vec_map.VecMap(bcs.string(), File),
+    },
+});
+export function owner(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function deleted(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "deleted",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function createdAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "created_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function subscriptionLevel(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "subscription_level",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function blobs(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "blobs",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function files(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "files",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns the end epoch of the article (assumes all blobs have the same end epoch)
+ * SECURITY NOTE: This function assumes blobs[0] exists and all blobs have the same
+ * end epoch
+ */
+export function endEpoch(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "end_epoch",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Calculates the total size of all blobs in the article */
+export function totalBlobSize(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "total_blob_size",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isExpired(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+        `${packageAddress}::system::System`,
+    ];
+    const parameterNames = ["self", "walrusSystem"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "is_expired",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isPublic(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::Article`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "is_public",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function blobIndex(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::File`,
+    ];
+    const parameterNames = ["file"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "blob_index",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function mimeType(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::File`,
+    ];
+    const parameterNames = ["file"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "mime_type",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function fileSize(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::article::File`,
+    ];
+    const parameterNames = ["file"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "file_size",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function articleBlobAddMetadata(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::article::Article`,
+        "u64",
+        `${packageAddress}::metadata::Metadata`,
+    ];
+    const parameterNames = ["config", "self", "blobIndex", "metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "article_blob_add_metadata",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function articleBlobRemoveMetadata(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::article::Article`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    ];
+    const parameterNames = ["config", "self", "blobIndex", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "article_blob_remove_metadata",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function articleBlobInsertOrUpdateMetadataPair(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::article::Article`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    ];
+    const parameterNames = ["config", "self", "blobIndex", "key", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "article_blob_insert_or_update_metadata_pair",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function certifyArticleBlob(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::article::Article`,
+        `${packageAddress}::system::System`,
+        "u64",
+        "vector<u8>",
+        "vector<u8>",
+        "vector<u8>",
+    ];
+    const parameterNames = [
+        "config",
+        "self",
+        "walrusSystem",
+        "blobIndex",
+        "signature",
+        "signersBitmap",
+        "message",
+    ];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "article",
+        function: "certify_article_blob",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}