@waterx/predict-sdk 0.1.0

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

@@ -0,0 +1,382 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { bcs } from '@mysten/sui/bcs';
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+const $moduleName = '@bucket/framework::linked_table';
+export function LinkedTable(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::LinkedTable<${typeParameters[0].name}, phantom V>`, fields: {
+            /** the ID of this table */
+            id: bcs.Address,
+            /** the number of key-value pairs in the table */
+            size: bcs.u64(),
+            /** the front of the table, i.e. the key of the first entry */
+            head: bcs.option(typeParameters[0]),
+            /** the back of the table, i.e. the key of the last entry */
+            tail: bcs.option(typeParameters[0])
+        } });
+}
+export function Node(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Node<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            /** the previous key */
+            prev: bcs.option(typeParameters[0]),
+            /** the next key */
+            next: bcs.option(typeParameters[0]),
+            /** the value being stored */
+            value: typeParameters[1]
+        } });
+}
+/** Creates a new, empty table */
+export 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
+ */
+export 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: 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 */
+export 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: 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`.
+ */
+export 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: 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`.
+ */
+export 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: 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`.
+ */
+export 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: 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`.
+ */
+export 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: 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`
+ */
+export 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: 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`
+ */
+export 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: 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.
+ */
+export 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: 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
+ */
+export 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: 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
+ */
+export 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: 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>`
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the size of the table, the number of key-value pairs */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns true iff the table is empty (if `length` returns `0`) */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Destroys an empty table Aborts with `ETableNotEmpty` if the table still contains
+ * values
+ */
+export 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: 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
+ */
+export 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: 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
+ */
+export function insertFront(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `0x1::option::Option<${options.typeArguments[0]}>`,
+        `${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: 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
+ */
+export function insertBack(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        `0x1::option::Option<${options.typeArguments[0]}>`,
+        `${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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}