@waterx/sdk 2.1.0

package/dist/src/generated/waterx_perp/keyed_big_vector.d.ts

@@ -0,0 +1,553 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * This module implements a `KeyedBigVector`, a data structure that combines the
+ * features of a `BigVector` and a `Table`. It allows for both indexed and keyed
+ * access to a large number of elements by storing them in slices, while
+ * maintaining a mapping from keys to indices in a `Table`.
+ */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type BcsType } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const KeyedBigVector: MoveStruct<{
+    /** The unique identifier of the KeyedBigVector object. */
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** The type name of the keys. */
+    key_type: MoveStruct<{
+        name: BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+    /** The type name of the values. */
+    value_type: MoveStruct<{
+        name: BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+    /** The index of the latest slice. */
+    slice_idx: BcsType<number, number, "u16">;
+    /** The maximum size of each slice. */
+    slice_size: BcsType<number, number, "u32">;
+    /** The total number of elements in the KeyedBigVector. */
+    length: BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+/** An element in the KeyedBigVector, containing a key-value pair. */
+export declare function Element<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    /** The key of the element. */
+    key: K;
+    /** The value of the element. */
+    value: V;
+}, `@waterx/perp::keyed_big_vector::Element<${K["name"]}, ${V["name"]}>`>;
+/** A slice of the KeyedBigVector, containing a vector of elements. */
+export declare function Slice<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    /** The index of the slice. */
+    idx: BcsType<number, number, "u16">;
+    /** The vector that stores the elements. */
+    vector: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `@waterx/perp::keyed_big_vector::Slice<${K["name"]}, ${V["name"]}>`>;
+export interface DuplicateKeyOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Error for a duplicate key. */
+export declare function duplicateKey(options?: DuplicateKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IndexOutOfBoundsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Error for an out-of-bounds index. */
+export declare function indexOutOfBounds(options?: IndexOutOfBoundsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidSliceSizeOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Error for an invalid slice size. */
+export declare function invalidSliceSize(options?: InvalidSliceSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface KeyNotFoundOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Error when a key is not found. */
+export declare function keyNotFound(options?: KeyNotFoundOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MaxSliceAmountReachedOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Error when the maximum number of slices is reached. */
+export declare function maxSliceAmountReached(options?: MaxSliceAmountReachedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotEmptyOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Error when trying to destroy a non-empty KeyedBigVector. */
+export declare function notEmpty(options?: NotEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewArguments {
+    sliceSize: RawTransactionArgument<number>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        sliceSize: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Creates a new `KeyedBigVector`. The `slice_size` determines the maximum number
+ * of elements in each slice.
+ */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SliceIdxArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface SliceIdxOptions {
+    package?: string;
+    arguments: SliceIdxArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+}
+/** Returns the index of the latest slice in the KeyedBigVector. */
+export declare function sliceIdx(options: SliceIdxOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SliceSizeArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface SliceSizeOptions {
+    package?: string;
+    arguments: SliceSizeArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+}
+/** Returns the maximum size of each slice in the KeyedBigVector. */
+export declare function sliceSize(options: SliceSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LengthArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface LengthOptions {
+    package?: string;
+    arguments: LengthArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+}
+/** Returns the total number of elements in the KeyedBigVector. */
+export declare function length(options: LengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsEmptyArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface IsEmptyOptions {
+    package?: string;
+    arguments: IsEmptyArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+}
+/** Returns `true` if the KeyedBigVector is empty. */
+export declare function isEmpty(options: IsEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ContainsArguments<K extends BcsType<any>> {
+    kbv: RawTransactionArgument<string>;
+    key: RawTransactionArgument<K>;
+}
+export interface ContainsOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: ContainsArguments<K> | [
+        kbv: RawTransactionArgument<string>,
+        key: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Returns `true` if there is a value associated with the key `key` in the
+ * KeyedBigVector.
+ */
+export declare function contains<K extends BcsType<any>>(options: ContainsOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetSliceIdxArguments {
+    slice: RawTransactionArgument<string>;
+}
+export interface GetSliceIdxOptions {
+    package?: string;
+    arguments: GetSliceIdxArguments | [
+        slice: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the index of the slice. */
+export declare function getSliceIdx(options: GetSliceIdxOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetSliceLengthArguments {
+    slice: RawTransactionArgument<string>;
+}
+export interface GetSliceLengthOptions {
+    package?: string;
+    arguments: GetSliceLengthArguments | [
+        slice: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the number of elements in the slice. */
+export declare function getSliceLength(options: GetSliceLengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PushBackArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    kbv: RawTransactionArgument<string>;
+    key: RawTransactionArgument<K>;
+    value: RawTransactionArgument<V>;
+}
+export interface PushBackOptions<K extends BcsType<any>, V extends BcsType<any>> {
+    package?: string;
+    arguments: PushBackArguments<K, V> | [
+        kbv: RawTransactionArgument<string>,
+        key: RawTransactionArgument<K>,
+        value: RawTransactionArgument<V>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Pushes a new element to the end of the KeyedBigVector. Aborts if the key already
+ * exists or if the maximum number of slices is reached.
+ */
+export declare function pushBack<K extends BcsType<any>, V extends BcsType<any>>(options: PushBackOptions<K, V>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PopBackArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface PopBackOptions {
+    package?: string;
+    arguments: PopBackArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Pops an element from the end of the KeyedBigVector and returns its key and
+ * value. Aborts if the KeyedBigVector is empty.
+ */
+export declare function popBack(options: PopBackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowSliceArguments {
+    kbv: RawTransactionArgument<string>;
+    sliceIdx: RawTransactionArgument<number>;
+}
+export interface BorrowSliceOptions {
+    package?: string;
+    arguments: BorrowSliceArguments | [
+        kbv: RawTransactionArgument<string>,
+        sliceIdx: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows a slice from the KeyedBigVector at `slice_idx`. */
+export declare function borrowSlice(options: BorrowSliceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowSlice_Arguments {
+    id: RawTransactionArgument<string>;
+    sliceIdx: RawTransactionArgument<number>;
+}
+export interface BorrowSlice_Options {
+    package?: string;
+    arguments: BorrowSlice_Arguments | [
+        id: RawTransactionArgument<string>,
+        sliceIdx: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowSlice_(options: BorrowSlice_Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowSliceMutArguments {
+    kbv: RawTransactionArgument<string>;
+    sliceIdx: RawTransactionArgument<number>;
+}
+export interface BorrowSliceMutOptions {
+    package?: string;
+    arguments: BorrowSliceMutArguments | [
+        kbv: RawTransactionArgument<string>,
+        sliceIdx: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows a mutable slice from the KeyedBigVector at `slice_idx`. */
+export declare function borrowSliceMut(options: BorrowSliceMutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowSliceMut_Arguments {
+    id: RawTransactionArgument<string>;
+    sliceIdx: RawTransactionArgument<number>;
+}
+export interface BorrowSliceMut_Options {
+    package?: string;
+    arguments: BorrowSliceMut_Arguments | [
+        id: RawTransactionArgument<string>,
+        sliceIdx: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowSliceMut_(options: BorrowSliceMut_Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowArguments {
+    kbv: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowOptions {
+    package?: string;
+    arguments: BorrowArguments | [
+        kbv: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows an element at index `i` from the KeyedBigVector. */
+export declare function borrow(options: BorrowOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface Borrow_Arguments {
+    kbv: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface Borrow_Options {
+    package?: string;
+    arguments: Borrow_Arguments | [
+        kbv: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrow_(options: Borrow_Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMutArguments {
+    kbv: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowMutOptions {
+    package?: string;
+    arguments: BorrowMutArguments | [
+        kbv: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows a mutable element at index `i` from the KeyedBigVector. */
+export declare function borrowMut(options: BorrowMutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMut_Arguments {
+    kbv: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowMut_Options {
+    package?: string;
+    arguments: BorrowMut_Arguments | [
+        kbv: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowMut_(options: BorrowMut_Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowByKeyArguments<K extends BcsType<any>> {
+    kbv: RawTransactionArgument<string>;
+    key: RawTransactionArgument<K>;
+}
+export interface BorrowByKeyOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowByKeyArguments<K> | [
+        kbv: RawTransactionArgument<string>,
+        key: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows an element by its key from the KeyedBigVector. */
+export declare function borrowByKey<K extends BcsType<any>>(options: BorrowByKeyOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowByKeyMutArguments<K extends BcsType<any>> {
+    kbv: RawTransactionArgument<string>;
+    key: RawTransactionArgument<K>;
+}
+export interface BorrowByKeyMutOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowByKeyMutArguments<K> | [
+        kbv: RawTransactionArgument<string>,
+        key: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows a mutable element by its key from the KeyedBigVector. */
+export declare function borrowByKeyMut<K extends BcsType<any>>(options: BorrowByKeyMutOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowFromSliceArguments {
+    slice: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowFromSliceOptions {
+    package?: string;
+    arguments: BorrowFromSliceArguments | [
+        slice: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows an element at index `i` from a slice. */
+export declare function borrowFromSlice(options: BorrowFromSliceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowFromSliceMutArguments {
+    slice: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowFromSliceMutOptions {
+    package?: string;
+    arguments: BorrowFromSliceMutArguments | [
+        slice: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Borrows a mutable element at index `i` from a slice. */
+export declare function borrowFromSliceMut(options: BorrowFromSliceMutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SwapRemoveArguments {
+    kbv: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface SwapRemoveOptions {
+    package?: string;
+    arguments: SwapRemoveArguments | [
+        kbv: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Swaps the element at index `i` with the last element and removes it. */
+export declare function swapRemove(options: SwapRemoveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SwapRemove_Arguments {
+    kbv: RawTransactionArgument<string>;
+    i: RawTransactionArgument<number | bigint>;
+}
+export interface SwapRemove_Options {
+    package?: string;
+    arguments: SwapRemove_Arguments | [
+        kbv: RawTransactionArgument<string>,
+        i: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function swapRemove_(options: SwapRemove_Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SwapRemoveByKeyArguments<K extends BcsType<any>> {
+    kbv: RawTransactionArgument<string>;
+    key: RawTransactionArgument<K>;
+}
+export interface SwapRemoveByKeyOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: SwapRemoveByKeyArguments<K> | [
+        kbv: RawTransactionArgument<string>,
+        key: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Swaps the element with the given key with the last element and removes it. */
+export declare function swapRemoveByKey<K extends BcsType<any>>(options: SwapRemoveByKeyOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyEmptyArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface DestroyEmptyOptions {
+    package?: string;
+    arguments: DestroyEmptyArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+}
+/** Destroys an empty KeyedBigVector. Aborts if the KeyedBigVector is not empty. */
+export declare function destroyEmpty(options: DestroyEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DropArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface DropOptions {
+    package?: string;
+    arguments: DropArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+}
+/** Destroys a KeyedBigVector. */
+export declare function drop(options: DropOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CompletelyDropArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface CompletelyDropOptions {
+    package?: string;
+    arguments: CompletelyDropArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Destroys a KeyedBigVector and its elements completely. */
+export declare function completelyDrop(options: CompletelyDropOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TrimSliceArguments {
+    kbv: RawTransactionArgument<string>;
+}
+export interface TrimSliceOptions {
+    package?: string;
+    arguments: TrimSliceArguments | [
+        kbv: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Removes an empty slice after an element has been removed from it. */
+export declare function trimSlice(options: TrimSliceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;