@typus/typus-perp-sdk 1.1.32-codegen-exp7 → 1.1.32-codegen-exp8

package/dist/src/generated/typus_perp/error.d.ts

@@ -0,0 +1,443 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * The `error` module defines the error codes used in the `typus_perp` module. The
+ * errors are grouped by the module they belong to.
+ */
+import { type Transaction } from "@mysten/sui/transactions";
+export interface PoolInactiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function poolInactive(options?: PoolInactiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PoolAlreadyActiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function poolAlreadyActive(options?: PoolAlreadyActiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TokenPoolInactiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tokenPoolInactive(options?: TokenPoolInactiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TokenPoolAlreadyActiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tokenPoolAlreadyActive(options?: TokenPoolAlreadyActiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LpTokenTypeMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function lpTokenTypeMismatched(options?: LpTokenTypeMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LiquidityTokenNotExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function liquidityTokenNotExisted(options?: LiquidityTokenNotExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositAmountInsufficientOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function depositAmountInsufficient(options?: DepositAmountInsufficientOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OracleMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function oracleMismatched(options?: OracleMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InsufficientAmountForMintFeeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function insufficientAmountForMintFee(options?: InsufficientAmountForMintFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ZeroTotalSupplyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function zeroTotalSupply(options?: ZeroTotalSupplyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TvlNotYetUpdatedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tvlNotYetUpdated(options?: TvlNotYetUpdatedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LiquidityNotEnoughOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function liquidityNotEnough(options?: LiquidityNotEnoughOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReachMaxCapacityOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function reachMaxCapacity(options?: ReachMaxCapacityOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReachSlippageThresholdOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function reachSlippageThreshold(options?: ReachSlippageThresholdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FrictionTooLargeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function frictionTooLarge(options?: FrictionTooLargeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidTokenTypeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidTokenType(options?: InvalidTokenTypeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DeactivatingSharesAlreadyExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function deactivatingSharesAlreadyExisted(options?: DeactivatingSharesAlreadyExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UserDeactivatingSharesNotExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function userDeactivatingSharesNotExisted(options?: UserDeactivatingSharesNotExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LiquidityTokenExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function liquidityTokenExisted(options?: LiquidityTokenExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidConfigRangeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidConfigRange(options?: InvalidConfigRangeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PoolIndexMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function poolIndexMismatched(options?: PoolIndexMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReserveBookkeepingErrorOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function reserveBookkeepingError(options?: ReserveBookkeepingErrorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RebalanceProcessFieldMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function rebalanceProcessFieldMismatched(options?: RebalanceProcessFieldMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExceedRebalanceCostThresholdOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function exceedRebalanceCostThreshold(options?: ExceedRebalanceCostThresholdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ProcessShouldRemovePositionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function processShouldRemovePosition(options?: ProcessShouldRemovePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ProcessShouldRemoveOrderOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function processShouldRemoveOrder(options?: ProcessShouldRemoveOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ProcessShouldSwapOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function processShouldSwap(options?: ProcessShouldSwapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ProcessShouldRepayLiquidityOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function processShouldRepayLiquidity(options?: ProcessShouldRepayLiquidityOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsupportedProcessStatusCodeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function unsupportedProcessStatusCode(options?: UnsupportedProcessStatusCodeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ZeroPriceOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function zeroPrice(options?: ZeroPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AuthorityAlreadyExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function authorityAlreadyExisted(options?: AuthorityAlreadyExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AuthorityDoestNotExistOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function authorityDoestNotExist(options?: AuthorityDoestNotExistOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AuthorityEmptyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function authorityEmpty(options?: AuthorityEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidVersionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidVersion(options?: InvalidVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnauthorizedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function unauthorized(options?: UnauthorizedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotReduceOnlyExecutionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notReduceOnlyExecution(options?: NotReduceOnlyExecutionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WrongCollateralTypeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function wrongCollateralType(options?: WrongCollateralTypeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidBidReceiptsInputOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidBidReceiptsInput(options?: InvalidBidReceiptsInputOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositTokenMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function depositTokenMismatched(options?: DepositTokenMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LinkedOrderIdNotExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function linkedOrderIdNotExisted(options?: LinkedOrderIdNotExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PortfolioIndexMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function portfolioIndexMismatched(options?: PortfolioIndexMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotOptionCollateralOrderOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notOptionCollateralOrder(options?: NotOptionCollateralOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotOptionCollateralPositionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notOptionCollateralPosition(options?: NotOptionCollateralPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotTokenCollateralPositionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notTokenCollateralPosition(options?: NotTokenCollateralPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TooManyLinkedOrdersOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tooManyLinkedOrders(options?: TooManyLinkedOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TradingSymbolExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tradingSymbolExisted(options?: TradingSymbolExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TradingSymbolNotExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tradingSymbolNotExisted(options?: TradingSymbolNotExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketsInactiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function marketsInactive(options?: MarketsInactiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TradingSymbolInactiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tradingSymbolInactive(options?: TradingSymbolInactiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActiveTradingSymbolOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function activeTradingSymbol(options?: ActiveTradingSymbolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderNotFoundOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function orderNotFound(options?: OrderNotFoundOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsupportedOrderTypeTagOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function unsupportedOrderTypeTag(options?: UnsupportedOrderTypeTagOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExceedMaxLeverageOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function exceedMaxLeverage(options?: ExceedMaxLeverageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CollateralTokenTypeMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function collateralTokenTypeMismatched(options?: CollateralTokenTypeMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BidReceiptHasBeenExpiredOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function bidReceiptHasBeenExpired(options?: BidReceiptHasBeenExpiredOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BidReceiptNotExpiredOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function bidReceiptNotExpired(options?: BidReceiptNotExpiredOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BidReceiptNotItmOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function bidReceiptNotItm(options?: BidReceiptNotItmOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidOrderSideOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidOrderSide(options?: InvalidOrderSideOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidOrderSizeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidOrderSize(options?: InvalidOrderSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddSizeNotAllowedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function addSizeNotAllowed(options?: AddSizeNotAllowedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BaseTokenMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function baseTokenMismatched(options?: BaseTokenMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UserMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function userMismatched(options?: UserMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TokenCollateralNotEnoughOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function tokenCollateralNotEnough(options?: TokenCollateralNotEnoughOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OptionCollateralNotEnoughOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function optionCollateralNotEnough(options?: OptionCollateralNotEnoughOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemainingCollateralNotEnoughOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function remainingCollateralNotEnough(options?: RemainingCollateralNotEnoughOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReachMaxSingleOrderReserveUsageOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function reachMaxSingleOrderReserveUsage(options?: ReachMaxSingleOrderReserveUsageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OptionCollateralOrderNotFilledOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function optionCollateralOrderNotFilled(options?: OptionCollateralOrderNotFilledOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderNotFilledImmediatelyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function orderNotFilledImmediately(options?: OrderNotFilledImmediatelyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LpPoolReserveNotEnoughOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function lpPoolReserveNotEnough(options?: LpPoolReserveNotEnoughOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PerpPositionLossesOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function perpPositionLosses(options?: PerpPositionLossesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidTradingFeeConfigOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidTradingFeeConfig(options?: InvalidTradingFeeConfigOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderOrPositionSizeNotZeroOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function orderOrPositionSizeNotZero(options?: OrderOrPositionSizeNotZeroOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BalanceNotEnoughForPayingFeeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function balanceNotEnoughForPayingFee(options?: BalanceNotEnoughForPayingFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionIdNeededWithReduceOnlyOrderOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function positionIdNeededWithReduceOnlyOrder(options?: PositionIdNeededWithReduceOnlyOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AuctionNotYetEndedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function auctionNotYetEnded(options?: AuctionNotYetEndedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BidTokenMismatchedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function bidTokenMismatched(options?: BidTokenMismatchedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExceedMaxOpenInterestOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function exceedMaxOpenInterest(options?: ExceedMaxOpenInterestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidOrderPriceOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidOrderPrice(options?: InvalidOrderPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidUserAccountOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidUserAccount(options?: InvalidUserAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotUserAccountOwnerOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notUserAccountOwner(options?: NotUserAccountOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NoBalanceOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function noBalance(options?: NoBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotUserAccountCapOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notUserAccountCap(options?: NotUserAccountCapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NotEmptySymbolsOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function notEmptySymbols(options?: NotEmptySymbolsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidBoostBpArrayLengthOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidBoostBpArrayLength(options?: InvalidBoostBpArrayLengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidIdxOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function invalidIdx(options?: InvalidIdxOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WhitelistAlreadyExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function whitelistAlreadyExisted(options?: WhitelistAlreadyExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WhitelistNotExistedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function whitelistNotExisted(options?: WhitelistNotExistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;