@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/bucket_v2_framework/linked_table.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedTable = LinkedTable;
+exports.Node = Node;
+exports._new = _new;
+exports.front = front;
+exports.back = back;
+exports.pushFront = pushFront;
+exports.pushBack = pushBack;
+exports.borrow = borrow;
+exports.borrowMut = borrowMut;
+exports.prev = prev;
+exports.next = next;
+exports.remove = remove;
+exports.popFront = popFront;
+exports.popBack = popBack;
+exports.contains = contains;
+exports.length = length;
+exports.isEmpty = isEmpty;
+exports.destroyEmpty = destroyEmpty;
+exports.drop = drop;
+exports.insertFront = insertFront;
+exports.insertBack = insertBack;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const bcs_1 = require("@mysten/sui/bcs");
+const index_ts_1 = require("../utils/index.js");
+const $moduleName = '@bucket/framework::linked_table';
+function LinkedTable(...typeParameters) {
+    return new index_ts_1.MoveStruct({ name: `${$moduleName}::LinkedTable<${typeParameters[0].name}, phantom V>`, fields: {
+            /** the ID of this table */
+            id: bcs_1.bcs.Address,
+            /** the number of key-value pairs in the table */
+            size: bcs_1.bcs.u64(),
+            /** the front of the table, i.e. the key of the first entry */
+            head: bcs_1.bcs.option(typeParameters[0]),
+            /** the back of the table, i.e. the key of the last entry */
+            tail: bcs_1.bcs.option(typeParameters[0])
+        } });
+}
+function Node(...typeParameters) {
+    return new index_ts_1.MoveStruct({ name: `${$moduleName}::Node<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            /** the previous key */
+            prev: bcs_1.bcs.option(typeParameters[0]),
+            /** the next key */
+            next: bcs_1.bcs.option(typeParameters[0]),
+            /** the value being stored */
+            value: typeParameters[1]
+        } });
+}
+/** Creates a new, empty table */
+function _new(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'new',
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns the key for the first element in the table, or None if the table is
+ * empty
+ */
+function front(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the key for the last element in the table, or None if the table is empty */
+function back(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Inserts a key-value pair at the front of the table, i.e. the newly inserted pair
+ * will be the first element in the table Aborts with
+ * `sui::dynamic_df::EFieldAlreadyExists` if the table already has an entry with
+ * that key `k: K`.
+ */
+function pushFront(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["table", "k", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'push_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Inserts a key-value pair at the back of the table, i.e. the newly inserted pair
+ * will be the last element in the table Aborts with
+ * `sui::dynamic_df::EFieldAlreadyExists` if the table already has an entry with
+ * that key `k: K`.
+ */
+function pushBack(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["table", "k", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'push_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Immutable borrows the value associated with the key in the table
+ * `table: &LinkedTable<K, V>`. Aborts with `sui::dynamic_df::EFieldDoesNotExist`
+ * if the table does not have an entry with that key `k: K`.
+ */
+function borrow(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'borrow',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Mutably borrows the value associated with the key in the table
+ * `table: &mut LinkedTable<K, V>`. Aborts with
+ * `sui::dynamic_df::EFieldDoesNotExist` if the table does not have an entry with
+ * that key `k: K`.
+ */
+function borrowMut(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'borrow_mut',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Borrows the key for the previous entry of the specified key `k: K` in the table
+ * `table: &LinkedTable<K, V>`. Returns None if the entry does not have a
+ * predecessor. Aborts with `sui::dynamic_df::EFieldDoesNotExist` if the table does
+ * not have an entry with that key `k: K`
+ */
+function prev(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'prev',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Borrows the key for the next entry of the specified key `k: K` in the table
+ * `table: &LinkedTable<K, V>`. Returns None if the entry does not have a
+ * predecessor. Aborts with `sui::dynamic_df::EFieldDoesNotExist` if the table does
+ * not have an entry with that key `k: K`
+ */
+function next(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'next',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Removes the key-value pair in the table `table: &mut LinkedTable<K, V>` and
+ * returns the value. This splices the element out of the ordering. Aborts with
+ * `sui::dynamic_df::EFieldDoesNotExist` if the table does not have an entry with
+ * that key `k: K`. Note: this is also what happens when the table is empty.
+ */
+function remove(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'remove',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Removes the front of the table `table: &mut LinkedTable<K, V>` and returns the
+ * value. Aborts with `ETableIsEmpty` if the table is empty
+ */
+function popFront(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'pop_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Removes the back of the table `table: &mut LinkedTable<K, V>` and returns the
+ * value. Aborts with `ETableIsEmpty` if the table is empty
+ */
+function popBack(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'pop_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns true iff there is a value associated with the key `k: K` in table
+ * `table: &LinkedTable<K, V>`
+ */
+function contains(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'contains',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the size of the table, the number of key-value pairs */
+function length(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'length',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns true iff the table is empty (if `length` returns `0`) */
+function isEmpty(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'is_empty',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Destroys an empty table Aborts with `ETableNotEmpty` if the table still contains
+ * values
+ */
+function destroyEmpty(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'destroy_empty',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Drop a possibly non-empty table. Usable only if the value type `V` has the
+ * `drop` ability
+ */
+function drop(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'drop',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Insert a key-value pair in front of the given key If the given key is none, then
+ * set the key-value pair as back
+ */
+function insertFront(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["table", "nextK", "k", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'insert_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Insert a key-value pair behind the given key If the given key is none, then set
+ * the key-value pair as front
+ */
+function insertBack(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["table", "prevK", "k", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'linked_table',
+        function: 'insert_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}