API Report File for "@mosaic/lib-base"

Do not edit this file. It is a report generated by API Extractor.

// @internal (undocumented)
export class _CachedReadableMosaic<T extends unknown[]> implements _ReadableMosaicWithExtraParams<T> {
    constructor(readable: _ReadableMosaicWithExtraParams<T>, cache: _MosaicReadCache<T>);
    // (undocumented)
    getCollateralSurplusBalance(address?: string, ...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getFees(...extraParams: T): Promise<Fees>;
    // (undocumented)
    getFrontendStatus(address?: string, ...extraParams: T): Promise<FrontendStatus>;
    // (undocumented)
    getLiquidityMiningMSICReward(address?: string, ...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getLiquidityMiningStake(address?: string, ...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getMSICBalance(address?: string, ...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getMSICStake(address?: string, ...extraParams: T): Promise<MSICStake>;
    // (undocumented)
    getMoUSDBalance(address?: string, ...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getMoUSDInStabilityPool(...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getNumberOfTroves(...extraParams: T): Promise<number>;
    // (undocumented)
    getPrice(...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getRemainingLiquidityMiningMSICReward(...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getRemainingStabilityPoolMSICReward(...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getStabilityDeposit(address?: string, ...extraParams: T): Promise<StabilityDeposit>;
    // (undocumented)
    getTotal(...extraParams: T): Promise<Trove>;
    // (undocumented)
    getTotalRedistributed(...extraParams: T): Promise<Trove>;
    // (undocumented)
    getTotalStakedMSIC(...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getTotalStakedUniTokens(...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getTrove(address?: string, ...extraParams: T): Promise<UserTrove>;
    // (undocumented)
    getTroveBeforeRedistribution(address?: string, ...extraParams: T): Promise<TroveWithPendingRedistribution>;
    // (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, ...extraParams: T): Promise<TroveWithPendingRedistribution[]>;
    // (undocumented)
    getTroves(params: TroveListingParams, ...extraParams: T): Promise<UserTrove[]>;
    // (undocumented)
    getUniTokenAllowance(address?: string, ...extraParams: T): Promise<Decimal>;
    // (undocumented)
    getUniTokenBalance(address?: string, ...extraParams: T): Promise<Decimal>;
    }

// @internal (undocumented)
export type _CollateralChange<T> = (_CollateralDeposit<T> & _NoCollateralWithdrawal) | (_CollateralWithdrawal<T> & _NoCollateralDeposit);

// @internal (undocumented)
export type _CollateralDeposit<T> = {
    depositCollateral: T;
};

// @public
export interface CollateralGainTransferDetails extends StabilityPoolGainsWithdrawalDetails {
    newTrove: Trove;
}

// @internal (undocumented)
export type _CollateralWithdrawal<T> = {
    withdrawCollateral: T;
};

// @public
export const CRITICAL_COLLATERAL_RATIO: Decimal;

// @internal (undocumented)
export type _DebtChange<T> = (_MoUSDBorrowing<T> & _NoMoUSDRepayment) | (_MoUSDRepayment<T> & _NoMoUSDBorrowing);

// @public
export class Decimal {
    // @internal (undocumented)
    get absoluteValue(): this;
    // (undocumented)
    add(addend: Decimalish): Decimal;
    // @internal (undocumented)
    get bigNumber(): string;
    // (undocumented)
    div(divider: Decimalish): Decimal;
    // @internal (undocumented)
    _divCeil(divider: Decimalish): Decimal;
    // (undocumented)
    eq(that: Decimalish): boolean;
    // (undocumented)
    get finite(): this | undefined;
    // (undocumented)
    static from(decimalish: Decimalish): Decimal;
    // (undocumented)
    static fromBigNumberString(bigNumberString: string): Decimal;
    // (undocumented)
    gt(that: Decimalish): boolean;
    // (undocumented)
    gte(that: Decimalish): boolean;
    // (undocumented)
    static readonly HALF: Decimal;
    // @internal (undocumented)
    get hex(): string;
    // (undocumented)
    get infinite(): this | undefined;
    // (undocumented)
    static readonly INFINITY: Decimal;
    // (undocumented)
    get isZero(): boolean;
    // (undocumented)
    lt(that: Decimalish): boolean;
    // (undocumented)
    lte(that: Decimalish): boolean;
    // (undocumented)
    static max(a: Decimalish, b: Decimalish): Decimal;
    // (undocumented)
    static min(a: Decimalish, b: Decimalish): Decimal;
    // (undocumented)
    mul(multiplier: Decimalish): Decimal;
    // (undocumented)
    mulDiv(multiplier: Decimalish, divider: Decimalish): Decimal;
    // (undocumented)
    get nonZero(): this | undefined;
    // (undocumented)
    static readonly ONE: Decimal;
    // (undocumented)
    pow(exponent: number): Decimal;
    // (undocumented)
    prettify(precision?: number): string;
    // (undocumented)
    shorten(): string;
    // (undocumented)
    sub(subtrahend: Decimalish): Decimal;
    // (undocumented)
    toString(precision?: number): string;
    // (undocumented)
    static readonly ZERO: Decimal;
    // (undocumented)
    get zero(): this | undefined;
}

// @public
export type Decimalish = Decimal | number | string;

// @alpha (undocumented)
export class Difference {
    // (undocumented)
    get absoluteValue(): Decimal | undefined;
    // (undocumented)
    static between(d1: Decimalish | undefined, d2: Decimalish | undefined): Difference;
    // (undocumented)
    get finite(): this | undefined;
    // (undocumented)
    get infinite(): this | undefined;
    // (undocumented)
    mul(multiplier: Decimalish): Difference;
    // (undocumented)
    get negative(): this | undefined;
    // (undocumented)
    get nonZero(): this | undefined;
    // (undocumented)
    get positive(): this | undefined;
    // (undocumented)
    prettify(precision?: number): string;
    // (undocumented)
    toString(precision?: number): string;
}

// @internal (undocumented)
export const _emptyTrove: Trove;

// @public
export type FailedReceipt<R = unknown> = {
    status: "failed";
    rawReceipt: R;
};

// @internal (undocumented)
export const _failedReceipt: <R>(rawReceipt: R) => FailedReceipt<R>;

// @public
export class Fees {
    // @internal
    constructor(baseRateWithoutDecay: Decimalish, minuteDecayFactor: Decimalish, beta: Decimalish, lastFeeOperation: Date, timeOfLatestBlock: Date, recoveryMode: boolean);
    // @internal (undocumented)
    baseRate(when?: Date): Decimal;
    borrowingRate(when?: Date): Decimal;
    equals(that: Fees): boolean;
    redemptionRate(redeemedFractionOfSupply?: Decimalish, when?: Date): Decimal;
    // @internal (undocumented)
    _setRecoveryMode(recoveryMode: boolean): Fees;
    // @internal (undocumented)
    toString(): string;
}

// @public
export type FrontendStatus = {
    status: "unregistered";
} | {
    status: "registered";
    kickbackRate: Decimal;
};

// @public
export interface LiquidationDetails {
    collateralGasCompensation: Decimal;
    liquidatedAddresses: string[];
    msicGasCompensation: Decimal;
    totalLiquidated: Trove;
}

// @internal (undocumented)
export interface _MosaicReadCache<T extends unknown[]> extends _MosaicReadCacheBase<T> {
    // (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, ...extraParams: T): TroveWithPendingRedistribution[] | undefined;
    // (undocumented)
    getTroves(params: TroveListingParams, ...extraParams: T): UserTrove[] | undefined;
}

// @internal (undocumented)
export type _MosaicReadCacheBase<T extends unknown[]> = {
    [P in keyof ReadableMosaic]: ReadableMosaic[P] extends (...args: infer A) => Promise<infer R> ? (...params: [...originalParams: A, ...extraParams: T]) => R | undefined : never;
};

// @public
export type MosaicReceipt<R = unknown, D = unknown> = PendingReceipt | MinedReceipt<R, D>;

// @public
export abstract class MosaicStore<T = unknown> {
    // @internal (undocumented)
    protected abstract _doStart(): () => void;
    // @internal (undocumented)
    protected _load(baseState: MosaicStoreBaseState, extraState?: T): void;
    // @internal (undocumented)
    protected _loaded: boolean;
    logging: boolean;
    onLoaded?: () => void;
    // @internal (undocumented)
    protected abstract _reduceExtra(extraState: T, extraStateUpdate: Partial<T>): T;
    start(): () => void;
    get state(): MosaicStoreState<T>;
    subscribe(listener: (params: MosaicStoreListenerParams<T>) => void): () => void;
    // @internal (undocumented)
    protected _update(baseStateUpdate?: Partial<MosaicStoreBaseState>, extraStateUpdate?: Partial<T>): void;
    }

// @public
export interface MosaicStoreBaseState {
    accountBalance: Decimal;
    collateralSurplusBalance: Decimal;
    // @internal (undocumented)
    _feesInNormalMode: Fees;
    frontend: FrontendStatus;
    liquidityMiningMSICReward: Decimal;
    liquidityMiningStake: Decimal;
    msicBalance: Decimal;
    msicStake: MSICStake;
    msicBalance: Decimal;
    msicInStabilityPool: Decimal;
    numberOfTroves: number;
    ownFrontend: FrontendStatus;
    price: Decimal;
    remainingLiquidityMiningMSICReward: Decimal;
    remainingStabilityPoolMSICReward: Decimal;
    // @internal (undocumented)
    _riskiestTroveBeforeRedistribution: TroveWithPendingRedistribution;
    stabilityDeposit: StabilityDeposit;
    total: Trove;
    totalRedistributed: Trove;
    totalStakedMSIC: Decimal;
    totalStakedUniTokens: Decimal;
    troveBeforeRedistribution: TroveWithPendingRedistribution;
    uniTokenAllowance: Decimal;
    uniTokenBalance: Decimal;
}

// @public
export interface MosaicStoreDerivedState {
    borrowingRate: Decimal;
    fees: Fees;
    haveUndercollateralizedTroves: boolean;
    redemptionRate: Decimal;
    trove: UserTrove;
}

// @public
export interface MosaicStoreListenerParams<T = unknown> {
    newState: MosaicStoreState<T>;
    oldState: MosaicStoreState<T>;
    stateChange: Partial<MosaicStoreState<T>>;
}

// @public
export type MosaicStoreState<T = unknown> = MosaicStoreBaseState & MosaicStoreDerivedState & T;

// @public
export class MSICStake {
    // @internal
    constructor(stakedMSIC?: Decimal, collateralGain?: Decimal, msicGain?: Decimal);
    apply(change: MSICStakeChange<Decimalish> | undefined): Decimal;
    readonly collateralGain: Decimal;
    equals(that: MSICStake): boolean;
    // (undocumented)
    get isEmpty(): boolean;
    readonly msicGain: Decimal;
    readonly stakedMSIC: Decimal;
    // @internal (undocumented)
    toString(): string;
    whatChanged(thatStakedMSIC: Decimalish): MSICStakeChange<Decimal> | undefined;
}

// @public
export type MSICStakeChange<T> = {
    stakeMSIC: T;
    unstakeMSIC?: undefined;
} | {
    stakeMSIC?: undefined;
    unstakeMSIC: T;
    unstakeAllMSIC: boolean;
};

// @public
export const MoUSD_LIQUIDATION_RESERVE: Decimal;

// @public
export const MoUSD_MINIMUM_DEBT: Decimal;

// @public
export const MoUSD_MINIMUM_NET_DEBT: Decimal;

// @internal (undocumented)
export type _MoUSDBorrowing<T> = {
    borrowMoUSD: T;
};

// @internal (undocumented)
export type _MoUSDRepayment<T> = {
    repayMoUSD: T;
};

// @public
export const MAXIMUM_BORROWING_RATE: Decimal;

// @public
export type MinedReceipt<R = unknown, D = unknown> = FailedReceipt<R> | SuccessfulReceipt<R, D>;

// @public
export const MINIMUM_BORROWING_RATE: Decimal;

// @public
export const MINIMUM_COLLATERAL_RATIO: Decimal;

// @public
export const MINIMUM_REDEMPTION_RATE: Decimal;

// @internal (undocumented)
export type _NoCollateralChange = _NoCollateralDeposit & _NoCollateralWithdrawal;

// @internal (undocumented)
export type _NoCollateralDeposit = Partial<_CollateralDeposit<undefined>>;

// @internal (undocumented)
export type _NoCollateralWithdrawal = Partial<_CollateralWithdrawal<undefined>>;

// @internal (undocumented)
export type _NoDebtChange = _NoMoUSDBorrowing & _NoMoUSDRepayment;

// @internal (undocumented)
export type _NoMoUSDBorrowing = Partial<_MoUSDBorrowing<undefined>>;

// @internal (undocumented)
export type _NoMoUSDRepayment = Partial<_MoUSDRepayment<undefined>>;

// @internal (undocumented)
export const _normalizeTroveAdjustment: (params: Record<string, Decimalish | undefined>) => TroveAdjustmentParams<Decimal>;

// @internal (undocumented)
export const _normalizeTroveCreation: (params: Record<string, Decimalish | undefined>) => TroveCreationParams<Decimal>;

// @alpha (undocumented)
export interface ObservableMosaic {
    // (undocumented)
    watchMoUSDBalance(onMoUSDBalanceChanged: (balance: Decimal) => void, address?: string): () => void;
    // (undocumented)
    watchMoUSDInStabilityPool(onMoUSDInStabilityPoolChanged: (msicInStabilityPool: Decimal) => void): () => void;
    // (undocumented)
    watchNumberOfTroves(onNumberOfTrovesChanged: (numberOfTroves: number) => void): () => void;
    // (undocumented)
    watchPrice(onPriceChanged: (price: Decimal) => void): () => void;
    // (undocumented)
    watchStabilityDeposit(onStabilityDepositChanged: (stabilityDeposit: StabilityDeposit) => void, address?: string): () => void;
    // (undocumented)
    watchTotal(onTotalChanged: (total: Trove) => void): () => void;
    // (undocumented)
    watchTotalRedistributed(onTotalRedistributedChanged: (totalRedistributed: Trove) => void): () => void;
    // (undocumented)
    watchTroveWithoutRewards(onTroveChanged: (trove: TroveWithPendingRedistribution) => void, address?: string): () => void;
}

// @public
export type PendingReceipt = {
    status: "pending";
};

// @internal (undocumented)
export const _pendingReceipt: PendingReceipt;

// @alpha (undocumented)
export class Percent<T extends {
    infinite?: T | undefined;
    absoluteValue?: A | undefined;
    mul?(hundred: 100): T;
    toString(precision?: number): string;
}, A extends {
    gte(n: string): boolean;
}> {
    constructor(ratio: T);
    // (undocumented)
    nonZeroish(precision: number): this | undefined;
    // (undocumented)
    prettify(): string;
    // (undocumented)
    toString(precision: number): string;
}

// @internal (undocumented)
export type _PopulatableFrom<T, P> = {
    [M in keyof T]: T[M] extends (...args: infer A) => Promise<infer U> ? U extends SentMosaicTransaction ? (...args: A) => Promise<PopulatedMosaicTransaction<P, U>> : never : never;
};

// Warning: (ae-incompatible-release-tags) The symbol "PopulatableMosaic" is marked as @public, but its signature references "_PopulatableFrom" which is marked as @internal
//
// @public
export interface PopulatableMosaic<R = unknown, S = unknown, P = unknown> extends _PopulatableFrom<SendableMosaic<R, S>, P> {
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>>;
    approveUniTokens(allowance?: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    borrowMoUSD(amount: Decimalish, maxBorrowingRate?: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>>;
    claimCollateralSurplus(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    closeTrove(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveClosureDetails>>>>;
    depositCollateral(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>>;
    depositMoUSDInStabilityPool(amount: Decimalish, frontendTag?: string): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, StabilityDepositChangeDetails>>>>;
    exitLiquidityMining(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    liquidate(address: string | string[]): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, LiquidationDetails>>>>;
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, LiquidationDetails>>>>;
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveCreationDetails>>>>;
    redeemMoUSD(amount: Decimalish, maxRedemptionRate?: Decimalish): Promise<PopulatedRedemption<P, S, R>>;
    registerFrontend(kickbackRate: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    repayMoUSD(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>>;
    sendMSIC(toAddress: string, amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    sendMoUSD(toAddress: string, amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    // @internal (undocumented)
    setPrice(price: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    stakeMSIC(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    stakeUniTokens(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    transferCollateralGainToTrove(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, CollateralGainTransferDetails>>>>;
    unstakeMSIC(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    unstakeUniTokens(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    withdrawCollateral(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>>;
    withdrawGainsFromStabilityPool(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, StabilityPoolGainsWithdrawalDetails>>>>;
    withdrawGainsFromStaking(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    withdrawMSICRewardFromLiquidityMining(): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, void>>>>;
    withdrawMoUSDFromStabilityPool(amount: Decimalish): Promise<PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, StabilityDepositChangeDetails>>>>;
}

// @public
export interface PopulatedMosaicTransaction<P = unknown, T extends SentMosaicTransaction = SentMosaicTransaction> {
    readonly rawPopulatedTransaction: P;
    send(): Promise<T>;
}

// @public
export interface PopulatedRedemption<P = unknown, S = unknown, R = unknown> extends PopulatedMosaicTransaction<P, SentMosaicTransaction<S, MosaicReceipt<R, RedemptionDetails>>> {
    readonly attemptedMoUSDAmount: Decimal;
    increaseAmountByMinimumNetDebt(maxRedemptionRate?: Decimalish): Promise<PopulatedRedemption<P, S, R>>;
    readonly isTruncated: boolean;
    readonly redeemableMoUSDAmount: Decimal;
}

// @public
export interface ReadableMosaic {
    getCollateralSurplusBalance(address?: string): Promise<Decimal>;
    getFees(): Promise<Fees>;
    getFrontendStatus(address?: string): Promise<FrontendStatus>;
    getLiquidityMiningMSICReward(address?: string): Promise<Decimal>;
    getLiquidityMiningStake(address?: string): Promise<Decimal>;
    getMSICBalance(address?: string): Promise<Decimal>;
    getMSICStake(address?: string): Promise<MSICStake>;
    getMoUSDBalance(address?: string): Promise<Decimal>;
    getMoUSDInStabilityPool(): Promise<Decimal>;
    getNumberOfTroves(): Promise<number>;
    getPrice(): Promise<Decimal>;
    getRemainingLiquidityMiningMSICReward(): Promise<Decimal>;
    getRemainingStabilityPoolMSICReward(): Promise<Decimal>;
    getStabilityDeposit(address?: string): Promise<StabilityDeposit>;
    getTotal(): Promise<Trove>;
    getTotalRedistributed(): Promise<Trove>;
    getTotalStakedMSIC(): Promise<Decimal>;
    getTotalStakedUniTokens(): Promise<Decimal>;
    getTrove(address?: string): Promise<UserTrove>;
    getTroveBeforeRedistribution(address?: string): Promise<TroveWithPendingRedistribution>;
    // @internal (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }): Promise<TroveWithPendingRedistribution[]>;
    getTroves(params: TroveListingParams): Promise<UserTrove[]>;
    getUniTokenAllowance(address?: string): Promise<Decimal>;
    getUniTokenBalance(address?: string): Promise<Decimal>;
}

// @internal (undocumented)
export interface _ReadableMosaicWithExtraParams<T extends unknown[]> extends _ReadableMosaicWithExtraParamsBase<T> {
    // (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, ...extraParams: T): Promise<TroveWithPendingRedistribution[]>;
    // (undocumented)
    getTroves(params: TroveListingParams, ...extraParams: T): Promise<UserTrove[]>;
}

// @internal (undocumented)
export type _ReadableMosaicWithExtraParamsBase<T extends unknown[]> = {
    [P in keyof ReadableMosaic]: ReadableMosaic[P] extends (...params: infer A) => infer R ? (...params: [...originalParams: A, ...extraParams: T]) => R : never;
};

// @public
export interface RedemptionDetails {
    actualMoUSDAmount: Decimal;
    attemptedMoUSDAmount: Decimal;
    collateralTaken: Decimal;
    fee: Decimal;
}

// @internal (undocumented)
export type _SendableFrom<T, R, S> = {
    [M in keyof T]: T[M] extends (...args: infer A) => Promise<infer D> ? (...args: A) => Promise<SentMosaicTransaction<S, MosaicReceipt<R, D>>> : never;
};

// Warning: (ae-incompatible-release-tags) The symbol "SendableMosaic" is marked as @public, but its signature references "_SendableFrom" which is marked as @internal
//
// @public
export interface SendableMosaic<R = unknown, S = unknown> extends _SendableFrom<TransactableMosaic, R, S> {
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>;
    approveUniTokens(allowance?: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    borrowMoUSD(amount: Decimalish, maxBorrowingRate?: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>;
    claimCollateralSurplus(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    closeTrove(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveClosureDetails>>>;
    depositCollateral(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>;
    depositMoUSDInStabilityPool(amount: Decimalish, frontendTag?: string): Promise<SentMosaicTransaction<S, MosaicReceipt<R, StabilityDepositChangeDetails>>>;
    exitLiquidityMining(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    liquidate(address: string | string[]): Promise<SentMosaicTransaction<S, MosaicReceipt<R, LiquidationDetails>>>;
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number): Promise<SentMosaicTransaction<S, MosaicReceipt<R, LiquidationDetails>>>;
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveCreationDetails>>>;
    redeemMoUSD(amount: Decimalish, maxRedemptionRate?: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, RedemptionDetails>>>;
    registerFrontend(kickbackRate: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    repayMoUSD(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>;
    sendMSIC(toAddress: string, amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    sendMoUSD(toAddress: string, amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    // @internal (undocumented)
    setPrice(price: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    stakeMSIC(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    stakeUniTokens(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    transferCollateralGainToTrove(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, CollateralGainTransferDetails>>>;
    unstakeMSIC(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    unstakeUniTokens(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    withdrawCollateral(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, TroveAdjustmentDetails>>>;
    withdrawGainsFromStabilityPool(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, StabilityPoolGainsWithdrawalDetails>>>;
    withdrawGainsFromStaking(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    withdrawMSICRewardFromLiquidityMining(): Promise<SentMosaicTransaction<S, MosaicReceipt<R, void>>>;
    withdrawMoUSDFromStabilityPool(amount: Decimalish): Promise<SentMosaicTransaction<S, MosaicReceipt<R, StabilityDepositChangeDetails>>>;
}

// @public
export interface SentMosaicTransaction<S = unknown, T extends MosaicReceipt = MosaicReceipt> {
    getReceipt(): Promise<T>;
    readonly rawSentTransaction: S;
    waitForReceipt(): Promise<Extract<T, MinedReceipt>>;
}

// @public
export class StabilityDeposit {
    // @internal