@sovryn-zero/lib-base 0.1.0

package/etc/lib-base.api.md

@@ -0,0 +1,788 @@
+## API Report File for "@sovryn-zero/lib-base"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @internal (undocumented)
+export class _CachedReadableLiquity<T extends unknown[]> implements _ReadableLiquityWithExtraParams<T> {
+    constructor(readable: _ReadableLiquityWithExtraParams<T>, cache: _LiquityReadCache<T>);
+    // (undocumented)
+    getCollateralSurplusBalance(address?: string, ...extraParams: T): Promise<Decimal>;
+    // (undocumented)
+    getFees(...extraParams: T): Promise<Fees>;
+    // (undocumented)
+    getFrontendStatus(address?: string, ...extraParams: T): Promise<FrontendStatus>;
+    // (undocumented)
+    getNumberOfTroves(...extraParams: T): Promise<number>;
+    // (undocumented)
+    getPrice(...extraParams: T): Promise<Decimal>;
+    // (undocumented)
+    getRemainingStabilityPoolZEROReward(...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)
+    getTotalStakedZERO(...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)
+    getZEROBalance(address?: string, ...extraParams: T): Promise<Decimal>;
+    // (undocumented)
+    getZEROStake(address?: string, ...extraParams: T): Promise<ZEROStake>;
+    // (undocumented)
+    getZUSDBalance(address?: string, ...extraParams: T): Promise<Decimal>;
+    // (undocumented)
+    getZUSDInStabilityPool(...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> = (_ZUSDBorrowing<T> & _NoZUSDRepayment) | (_ZUSDRepayment<T> & _NoZUSDBorrowing);
+
+// @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[];
+    totalLiquidated: Trove;
+    zusdGasCompensation: Decimal;
+}
+
+// @internal (undocumented)
+export interface _LiquityReadCache<T extends unknown[]> extends _LiquityReadCacheBase<T> {
+    // (undocumented)
+    getTroves(params: TroveListingParams & {
+        beforeRedistribution: true;
+    }, ...extraParams: T): TroveWithPendingRedistribution[] | undefined;
+    // (undocumented)
+    getTroves(params: TroveListingParams, ...extraParams: T): UserTrove[] | undefined;
+}
+
+// @internal (undocumented)
+export type _LiquityReadCacheBase<T extends unknown[]> = {
+    [P in keyof ReadableLiquity]: ReadableLiquity[P] extends (...args: infer A) => Promise<infer R> ? (...params: [...originalParams: A, ...extraParams: T]) => R | undefined : never;
+};
+
+// @public
+export type LiquityReceipt<R = unknown, D = unknown> = PendingReceipt | MinedReceipt<R, D>;
+
+// @public
+export abstract class LiquityStore<T = unknown> {
+    // @internal (undocumented)
+    protected abstract _doStart(): () => void;
+    // @internal (undocumented)
+    protected _load(baseState: LiquityStoreBaseState, 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(): LiquityStoreState<T>;
+    subscribe(listener: (params: LiquityStoreListenerParams<T>) => void): () => void;
+    // @internal (undocumented)
+    protected _update(baseStateUpdate?: Partial<LiquityStoreBaseState>, extraStateUpdate?: Partial<T>): void;
+    }
+
+// @public
+export interface LiquityStoreBaseState {
+    accountBalance: Decimal;
+    collateralSurplusBalance: Decimal;
+    // @internal (undocumented)
+    _feesInNormalMode: Fees;
+    frontend: FrontendStatus;
+    nueBalance: Decimal;
+    numberOfTroves: number;
+    ownFrontend: FrontendStatus;
+    price: Decimal;
+    remainingStabilityPoolZEROReward: Decimal;
+    // @internal (undocumented)
+    _riskiestTroveBeforeRedistribution: TroveWithPendingRedistribution;
+    stabilityDeposit: StabilityDeposit;
+    total: Trove;
+    totalRedistributed: Trove;
+    totalStakedZERO: Decimal;
+    troveBeforeRedistribution: TroveWithPendingRedistribution;
+    zeroBalance: Decimal;
+    zeroStake: ZEROStake;
+    zusdBalance: Decimal;
+    zusdInStabilityPool: Decimal;
+}
+
+// @public
+export interface LiquityStoreDerivedState {
+    borrowingRate: Decimal;
+    fees: Fees;
+    haveUndercollateralizedTroves: boolean;
+    redemptionRate: Decimal;
+    trove: UserTrove;
+}
+
+// @public
+export interface LiquityStoreListenerParams<T = unknown> {
+    newState: LiquityStoreState<T>;
+    oldState: LiquityStoreState<T>;
+    stateChange: Partial<LiquityStoreState<T>>;
+}
+
+// @public
+export type LiquityStoreState<T = unknown> = LiquityStoreBaseState & LiquityStoreDerivedState & 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 = _NoZUSDBorrowing & _NoZUSDRepayment;
+
+// @internal (undocumented)
+export const _normalizeTroveAdjustment: (params: Record<string, Decimalish | undefined>) => TroveAdjustmentParams<Decimal>;
+
+// @internal (undocumented)
+export const _normalizeTroveCreation: (params: Record<string, Decimalish | undefined>) => TroveCreationParams<Decimal>;
+
+// @internal (undocumented)
+export type _NoZUSDBorrowing = Partial<_ZUSDBorrowing<undefined>>;
+
+// @internal (undocumented)
+export type _NoZUSDRepayment = Partial<_ZUSDRepayment<undefined>>;
+
+// @alpha (undocumented)
+export interface ObservableLiquity {
+    // (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;
+    // (undocumented)
+    watchZUSDBalance(onZUSDBalanceChanged: (balance: Decimal) => void, address?: string): () => void;
+    // (undocumented)
+    watchZUSDInStabilityPool(onZUSDInStabilityPoolChanged: (zusdInStabilityPool: Decimal) => void): () => 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 SentLiquityTransaction ? (...args: A) => Promise<PopulatedLiquityTransaction<P, U>> : never : never;
+};
+
+// Warning: (ae-incompatible-release-tags) The symbol "PopulatableLiquity" is marked as @public, but its signature references "_PopulatableFrom" which is marked as @internal
+//
+// @public
+export interface PopulatableLiquity<R = unknown, S = unknown, P = unknown> extends _PopulatableFrom<SendableLiquity<R, S>, P> {
+    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>>;
+    borrowZUSD(amount: Decimalish, maxBorrowingRate?: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>>;
+    claimCollateralSurplus(): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    closeTrove(): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveClosureDetails>>>>;
+    depositCollateral(amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>>;
+    depositZUSDInStabilityPool(amount: Decimalish, frontendTag?: string): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>>>;
+    liquidate(address: string | string[]): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>>;
+    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>>;
+    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveCreationDetails>>>>;
+    redeemZUSD(amount: Decimalish, maxRedemptionRate?: Decimalish): Promise<PopulatedRedemption<P, S, R>>;
+    registerFrontend(kickbackRate: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    repayZUSD(amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>>;
+    sendZERO(toAddress: string, amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    sendZUSD(toAddress: string, amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    // @internal (undocumented)
+    setPrice(price: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    stakeZERO(amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    transferCollateralGainToTrove(): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, CollateralGainTransferDetails>>>>;
+    unstakeZERO(amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    withdrawCollateral(amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>>;
+    withdrawGainsFromStabilityPool(): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, StabilityPoolGainsWithdrawalDetails>>>>;
+    withdrawGainsFromStaking(): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+    withdrawZUSDFromStabilityPool(amount: Decimalish): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>>>;
+}
+
+// @public
+export interface PopulatedLiquityTransaction<P = unknown, T extends SentLiquityTransaction = SentLiquityTransaction> {
+    readonly rawPopulatedTransaction: P;
+    send(): Promise<T>;
+}
+
+// @public
+export interface PopulatedRedemption<P = unknown, S = unknown, R = unknown> extends PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, RedemptionDetails>>> {
+    readonly attemptedZUSDAmount: Decimal;
+    increaseAmountByMinimumNetDebt(maxRedemptionRate?: Decimalish): Promise<PopulatedRedemption<P, S, R>>;
+    readonly isTruncated: boolean;
+    readonly redeemableZUSDAmount: Decimal;
+}
+
+// @public
+export interface ReadableLiquity {
+    getCollateralSurplusBalance(address?: string): Promise<Decimal>;
+    getFees(): Promise<Fees>;
+    getFrontendStatus(address?: string): Promise<FrontendStatus>;
+    getNumberOfTroves(): Promise<number>;
+    getPrice(): Promise<Decimal>;
+    getRemainingStabilityPoolZEROReward(): Promise<Decimal>;
+    getStabilityDeposit(address?: string): Promise<StabilityDeposit>;
+    getTotal(): Promise<Trove>;
+    getTotalRedistributed(): Promise<Trove>;
+    getTotalStakedZERO(): 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[]>;
+    getZEROBalance(address?: string): Promise<Decimal>;
+    getZEROStake(address?: string): Promise<ZEROStake>;
+    getZUSDBalance(address?: string): Promise<Decimal>;
+    getZUSDInStabilityPool(): Promise<Decimal>;
+}
+
+// @internal (undocumented)
+export interface _ReadableLiquityWithExtraParams<T extends unknown[]> extends _ReadableLiquityWithExtraParamsBase<T> {
+    // (undocumented)
+    getTroves(params: TroveListingParams & {
+        beforeRedistribution: true;
+    }, ...extraParams: T): Promise<TroveWithPendingRedistribution[]>;
+    // (undocumented)
+    getTroves(params: TroveListingParams, ...extraParams: T): Promise<UserTrove[]>;
+}
+
+// @internal (undocumented)
+export type _ReadableLiquityWithExtraParamsBase<T extends unknown[]> = {
+    [P in keyof ReadableLiquity]: ReadableLiquity[P] extends (...params: infer A) => infer R ? (...params: [...originalParams: A, ...extraParams: T]) => R : never;
+};
+
+// @public
+export interface RedemptionDetails {
+    actualZUSDAmount: Decimal;
+    attemptedZUSDAmount: 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<SentLiquityTransaction<S, LiquityReceipt<R, D>>> : never;
+};
+
+// Warning: (ae-incompatible-release-tags) The symbol "SendableLiquity" is marked as @public, but its signature references "_SendableFrom" which is marked as @internal
+//
+// @public
+export interface SendableLiquity<R = unknown, S = unknown> extends _SendableFrom<TransactableLiquity, R, S> {
+    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+    borrowZUSD(amount: Decimalish, maxBorrowingRate?: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+    claimCollateralSurplus(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    closeTrove(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveClosureDetails>>>;
+    depositCollateral(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+    depositZUSDInStabilityPool(amount: Decimalish, frontendTag?: string): Promise<SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>>;
+    liquidate(address: string | string[]): Promise<SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>;
+    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number): Promise<SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>;
+    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveCreationDetails>>>;
+    redeemZUSD(amount: Decimalish, maxRedemptionRate?: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, RedemptionDetails>>>;
+    registerFrontend(kickbackRate: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    repayZUSD(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+    sendZERO(toAddress: string, amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    sendZUSD(toAddress: string, amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    // @internal (undocumented)
+    setPrice(price: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    stakeZERO(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    transferCollateralGainToTrove(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, CollateralGainTransferDetails>>>;
+    unstakeZERO(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    withdrawCollateral(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+    withdrawGainsFromStabilityPool(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, StabilityPoolGainsWithdrawalDetails>>>;
+    withdrawGainsFromStaking(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+    withdrawZUSDFromStabilityPool(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>>;
+}
+
+// @public
+export interface SentLiquityTransaction<S = unknown, T extends LiquityReceipt = LiquityReceipt> {
+    getReceipt(): Promise<T>;
+    readonly rawSentTransaction: S;
+    waitForReceipt(): Promise<Extract<T, MinedReceipt>>;
+}
+
+// @public
+export class StabilityDeposit {
+    // @internal
+    constructor(initialZUSD: Decimal, currentZUSD: Decimal, collateralGain: Decimal, zeroReward: Decimal, frontendTag: string);
+    apply(change: StabilityDepositChange<Decimalish> | undefined): Decimal;
+    readonly collateralGain: Decimal;
+    readonly currentZUSD: Decimal;
+    equals(that: StabilityDeposit): boolean;
+    readonly frontendTag: string;
+    readonly initialZUSD: Decimal;
+    // (undocumented)
+    get isEmpty(): boolean;
+    // @internal (undocumented)
+    toString(): string;
+    whatChanged(thatZUSD: Decimalish): StabilityDepositChange<Decimal> | undefined;
+    readonly zeroReward: Decimal;
+}
+
+// @public
+export type StabilityDepositChange<T> = {
+    depositZUSD: T;
+    withdrawZUSD?: undefined;
+} | {
+    depositZUSD?: undefined;
+    withdrawZUSD: T;
+    withdrawAllZUSD: boolean;
+};
+
+// @public
+export interface StabilityDepositChangeDetails extends StabilityPoolGainsWithdrawalDetails {
+    change: StabilityDepositChange<Decimal>;
+}
+
+// @public
+export interface StabilityPoolGainsWithdrawalDetails {
+    collateralGain: Decimal;
+    newZUSDDeposit: Decimal;
+    zeroReward: Decimal;
+    zusdLoss: Decimal;
+}
+
+// @public
+export type SuccessfulReceipt<R = unknown, D = unknown> = {
+    status: "succeeded";
+    rawReceipt: R;
+    details: D;
+};
+
+// @internal (undocumented)
+export const _successfulReceipt: <R, D>(rawReceipt: R, details: D, toString?: (() => string) | undefined) => SuccessfulReceipt<R, D>;
+
+// @public
+export interface TransactableLiquity {
+    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<TroveAdjustmentDetails>;
+    borrowZUSD(amount: Decimalish, maxBorrowingRate?: Decimalish): Promise<TroveAdjustmentDetails>;
+    claimCollateralSurplus(): Promise<void>;
+    closeTrove(): Promise<TroveClosureDetails>;
+    depositCollateral(amount: Decimalish): Promise<TroveAdjustmentDetails>;
+    depositZUSDInStabilityPool(amount: Decimalish, frontendTag?: string): Promise<StabilityDepositChangeDetails>;
+    liquidate(address: string | string[]): Promise<LiquidationDetails>;
+    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number): Promise<LiquidationDetails>;
+    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish): Promise<TroveCreationDetails>;
+    redeemZUSD(amount: Decimalish, maxRedemptionRate?: Decimalish): Promise<RedemptionDetails>;
+    registerFrontend(kickbackRate: Decimalish): Promise<void>;
+    repayZUSD(amount: Decimalish): Promise<TroveAdjustmentDetails>;
+    sendZERO(toAddress: string, amount: Decimalish): Promise<void>;
+    sendZUSD(toAddress: string, amount: Decimalish): Promise<void>;
+    // @internal (undocumented)
+    setPrice(price: Decimalish): Promise<void>;
+    stakeZERO(amount: Decimalish): Promise<void>;
+    transferCollateralGainToTrove(): Promise<CollateralGainTransferDetails>;
+    unstakeZERO(amount: Decimalish): Promise<void>;
+    withdrawCollateral(amount: Decimalish): Promise<TroveAdjustmentDetails>;
+    withdrawGainsFromStabilityPool(): Promise<StabilityPoolGainsWithdrawalDetails>;
+    withdrawGainsFromStaking(): Promise<void>;
+    withdrawZUSDFromStabilityPool(amount: Decimalish): Promise<StabilityDepositChangeDetails>;
+}
+
+// @public
+export class TransactionFailedError<T extends FailedReceipt = FailedReceipt> extends Error {
+    // @internal
+    constructor(name: string, message: string, failedReceipt: T);
+    // (undocumented)
+    readonly failedReceipt: T;
+}
+
+// @public
+export class Trove {
+    // @internal
+    constructor(collateral?: Decimal, debt?: Decimal);
+    // (undocumented)
+    add(that: Trove): Trove;
+    // (undocumented)
+    addCollateral(collateral: Decimalish): Trove;
+    // (undocumented)
+    addDebt(debt: Decimalish): Trove;
+    adjust(params: TroveAdjustmentParams<Decimalish>, borrowingRate?: Decimalish): Trove;
+    adjustTo(that: Trove, borrowingRate?: Decimalish): TroveAdjustmentParams<Decimal>;
+    apply(change: TroveChange<Decimal> | undefined, borrowingRate?: Decimalish): Trove;
+    readonly collateral: Decimal;
+    collateralRatio(price: Decimalish): Decimal;
+    collateralRatioIsBelowCritical(price: Decimalish): boolean;
+    collateralRatioIsBelowMinimum(price: Decimalish): boolean;
+    static create(params: TroveCreationParams<Decimalish>, borrowingRate?: Decimalish): Trove;
+    readonly debt: Decimal;
+    // (undocumented)
+    equals(that: Trove): boolean;
+    // (undocumented)
+    get isEmpty(): boolean;
+    isOpenableInRecoveryMode(price: Decimalish): boolean;
+    // (undocumented)
+    multiply(multiplier: Decimalish): Trove;
+    get netDebt(): Decimal;
+    // @internal (undocumented)
+    get _nominalCollateralRatio(): Decimal;
+    static recreate(that: Trove, borrowingRate?: Decimalish): TroveCreationParams<Decimal>;
+    // (undocumented)
+    setCollateral(collateral: Decimalish): Trove;
+    // (undocumented)
+    setDebt(debt: Decimalish): Trove;
+    // (undocumented)
+    subtract(that: Trove): Trove;
+    // (undocumented)
+    subtractCollateral(collateral: Decimalish): Trove;
+    // (undocumented)
+    subtractDebt(debt: Decimalish): Trove;
+    // @internal (undocumented)
+    toString(): string;
+    whatChanged(that: Trove, borrowingRate?: Decimalish): TroveChange<Decimal> | undefined;
+}
+
+// @public
+export interface TroveAdjustmentDetails {
+    fee: Decimal;
+    newTrove: Trove;
+    params: TroveAdjustmentParams<Decimal>;
+}
+
+// Warning: (ae-incompatible-release-tags) The symbol "TroveAdjustmentParams" is marked as @public, but its signature references "_CollateralChange" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveAdjustmentParams" is marked as @public, but its signature references "_NoDebtChange" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveAdjustmentParams" is marked as @public, but its signature references "_DebtChange" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveAdjustmentParams" is marked as @public, but its signature references "_NoCollateralChange" which is marked as @internal
+//
+// @public
+export type TroveAdjustmentParams<T = unknown> = (_CollateralChange<T> & _NoDebtChange) | (_DebtChange<T> & _NoCollateralChange) | (_CollateralChange<T> & _DebtChange<T>);
+
+// @public
+export type TroveChange<T> = {
+    type: "invalidCreation";
+    invalidTrove: Trove;
+    error: TroveCreationError;
+} | {
+    type: "creation";
+    params: TroveCreationParams<T>;
+} | {
+    type: "closure";
+    params: TroveClosureParams<T>;
+} | {
+    type: "adjustment";
+    params: TroveAdjustmentParams<T>;
+    setToZero?: "collateral" | "debt";
+};
+
+// @public
+export interface TroveClosureDetails {
+    params: TroveClosureParams<Decimal>;
+}
+
+// Warning: (ae-incompatible-release-tags) The symbol "TroveClosureParams" is marked as @public, but its signature references "_CollateralWithdrawal" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveClosureParams" is marked as @public, but its signature references "_NoCollateralDeposit" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveClosureParams" is marked as @public, but its signature references "_ZUSDRepayment" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveClosureParams" is marked as @public, but its signature references "_NoZUSDBorrowing" which is marked as @internal
+//
+// @public
+export type TroveClosureParams<T> = _CollateralWithdrawal<T> & _NoCollateralDeposit & Partial<_ZUSDRepayment<T>> & _NoZUSDBorrowing;
+
+// @public
+export interface TroveCreationDetails {
+    fee: Decimal;
+    newTrove: Trove;
+    params: TroveCreationParams<Decimal>;
+}
+
+// @public
+export type TroveCreationError = "missingLiquidationReserve";
+
+// Warning: (ae-incompatible-release-tags) The symbol "TroveCreationParams" is marked as @public, but its signature references "_CollateralDeposit" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveCreationParams" is marked as @public, but its signature references "_NoCollateralWithdrawal" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveCreationParams" is marked as @public, but its signature references "_ZUSDBorrowing" which is marked as @internal
+// Warning: (ae-incompatible-release-tags) The symbol "TroveCreationParams" is marked as @public, but its signature references "_NoZUSDRepayment" which is marked as @internal
+//
+// @public
+export type TroveCreationParams<T = unknown> = _CollateralDeposit<T> & _NoCollateralWithdrawal & _ZUSDBorrowing<T> & _NoZUSDRepayment;
+
+// @public
+export interface TroveListingParams {
+    readonly beforeRedistribution?: boolean;
+    readonly first: number;
+    readonly sortedBy: "ascendingCollateralRatio" | "descendingCollateralRatio";
+    readonly startingAt?: number;
+}
+
+// @public
+export class TroveWithPendingRedistribution extends UserTrove {
+    // @internal
+    constructor(ownerAddress: string, status: UserTroveStatus, collateral?: Decimal, debt?: Decimal, stake?: Decimal, snapshotOfTotalRedistributed?: Trove);
+    // (undocumented)
+    applyRedistribution(totalRedistributed: Trove): UserTrove;
+    // (undocumented)
+    equals(that: TroveWithPendingRedistribution): boolean;
+    }
+
+// @public
+export class UserTrove extends Trove {
+    // @internal
+    constructor(ownerAddress: string, status: UserTroveStatus, collateral?: Decimal, debt?: Decimal);
+    // (undocumented)
+    equals(that: UserTrove): boolean;
+    readonly ownerAddress: string;
+    readonly status: UserTroveStatus;
+    // @internal (undocumented)
+    toString(): string;
+}
+
+// @public
+export type UserTroveStatus = "nonExistent" | "open" | "closedByOwner" | "closedByLiquidation" | "closedByRedemption";
+
+// @public
+export class ZEROStake {
+    // @internal
+    constructor(stakedZERO?: Decimal, collateralGain?: Decimal, zusdGain?: Decimal);
+    apply(change: ZEROStakeChange<Decimalish> | undefined): Decimal;
+    readonly collateralGain: Decimal;
+    equals(that: ZEROStake): boolean;
+    // (undocumented)
+    get isEmpty(): boolean;
+    readonly stakedZERO: Decimal;
+    // @internal (undocumented)
+    toString(): string;
+    whatChanged(thatStakedZERO: Decimalish): ZEROStakeChange<Decimal> | undefined;
+    readonly zusdGain: Decimal;
+}
+
+// @public
+export type ZEROStakeChange<T> = {
+    stakeZERO: T;
+    unstakeZERO?: undefined;
+} | {
+    stakeZERO?: undefined;
+    unstakeZERO: T;
+    unstakeAllZERO: boolean;
+};
+
+// @public
+export const ZUSD_LIQUIDATION_RESERVE: Decimal;
+
+// @public
+export const ZUSD_MINIMUM_DEBT: Decimal;
+
+// @public
+export const ZUSD_MINIMUM_NET_DEBT: Decimal;
+
+// @internal (undocumented)
+export type _ZUSDBorrowing<T> = {
+    borrowZUSD: T;
+};
+
+// @internal (undocumented)
+export type _ZUSDRepayment<T> = {
+    repayZUSD: T;
+};
+
+
+// (No @packageDocumentation comment for this package)
+
+```