## API Report File for "@sovryn-zero/lib-ethers"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { BigNumberish } from '@ethersproject/bignumber';
import { BlockTag } from '@ethersproject/abstract-provider';
import { BytesLike } from '@ethersproject/bytes';
import { CollateralGainTransferDetails } from '@sovryn-zero/lib-base';
import { Decimal } from '@sovryn-zero/lib-base';
import { Decimalish } from '@sovryn-zero/lib-base';
import { FailedReceipt } from '@sovryn-zero/lib-base';
import { Fees } from '@sovryn-zero/lib-base';
import { FrontendStatus } from '@sovryn-zero/lib-base';
import { LiquidationDetails } from '@sovryn-zero/lib-base';
import { LiquityReceipt } from '@sovryn-zero/lib-base';
import { LiquityStore } from '@sovryn-zero/lib-base';
import { LiquityStoreState } from '@sovryn-zero/lib-base';
import { MinedReceipt } from '@sovryn-zero/lib-base';
import { ObservableLiquity } from '@sovryn-zero/lib-base';
import { PopulatableLiquity } from '@sovryn-zero/lib-base';
import { PopulatedLiquityTransaction } from '@sovryn-zero/lib-base';
import { PopulatedRedemption } from '@sovryn-zero/lib-base';
import { PopulatedTransaction } from '@ethersproject/contracts';
import { Provider } from '@ethersproject/abstract-provider';
import { ReadableLiquity } from '@sovryn-zero/lib-base';
import { RedemptionDetails } from '@sovryn-zero/lib-base';
import { SendableLiquity } from '@sovryn-zero/lib-base';
import { SentLiquityTransaction } from '@sovryn-zero/lib-base';
import { Signer } from '@ethersproject/abstract-signer';
import { StabilityDeposit } from '@sovryn-zero/lib-base';
import { StabilityDepositChangeDetails } from '@sovryn-zero/lib-base';
import { StabilityPoolGainsWithdrawalDetails } from '@sovryn-zero/lib-base';
import { TransactableLiquity } from '@sovryn-zero/lib-base';
import { TransactionFailedError } from '@sovryn-zero/lib-base';
import { TransactionReceipt } from '@ethersproject/abstract-provider';
import { TransactionResponse } from '@ethersproject/abstract-provider';
import { Trove } from '@sovryn-zero/lib-base';
import { TroveAdjustmentDetails } from '@sovryn-zero/lib-base';
import { TroveAdjustmentParams } from '@sovryn-zero/lib-base';
import { TroveClosureDetails } from '@sovryn-zero/lib-base';
import { TroveCreationDetails } from '@sovryn-zero/lib-base';
import { TroveCreationParams } from '@sovryn-zero/lib-base';
import { TroveListingParams } from '@sovryn-zero/lib-base';
import { TroveWithPendingRedistribution } from '@sovryn-zero/lib-base';
import { UserTrove } from '@sovryn-zero/lib-base';
import { ZEROStake } from '@sovryn-zero/lib-base';

// @public
export class BlockPolledLiquityStore extends LiquityStore<BlockPolledLiquityStoreExtraState> {
    constructor(readable: ReadableEthersLiquity);
    // (undocumented)
    readonly connection: EthersLiquityConnection;
    // @internal @override (undocumented)
    protected _doStart(): () => void;
    // @internal @override (undocumented)
    protected _reduceExtra(oldState: BlockPolledLiquityStoreExtraState, stateUpdate: Partial<BlockPolledLiquityStoreExtraState>): BlockPolledLiquityStoreExtraState;
}

// @public
export interface BlockPolledLiquityStoreExtraState {
    blockTag?: number;
    blockTimestamp: number;
}

// @public
export type BlockPolledLiquityStoreState = LiquityStoreState<BlockPolledLiquityStoreExtraState>;

// @internal (undocumented)
export function _connectByChainId<T>(provider: EthersProvider, signer: EthersSigner | undefined, chainId: number, optionalParams: EthersLiquityConnectionOptionalParams & {
    useStore: T;
}): EthersLiquityConnection & {
    useStore: T;
};

// @internal (undocumented)
export function _connectByChainId(provider: EthersProvider, signer: EthersSigner | undefined, chainId: number, optionalParams?: EthersLiquityConnectionOptionalParams): EthersLiquityConnection;

// @public
export interface EthersCallOverrides {
    // (undocumented)
    blockTag?: BlockTag;
}

// @public
export class EthersLiquity implements ReadableEthersLiquity, TransactableLiquity {
    // @internal
    constructor(readable: ReadableEthersLiquity);
    // (undocumented)
    adjustNueTrove(params: TroveAdjustmentParams<Decimalish>, permitParams: PermitParams, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    borrowZUSD(amount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    claimCollateralSurplus(overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    closeNueTrove(permitParams: PermitParams, overrides?: EthersTransactionOverrides): Promise<TroveClosureDetails>;
    // (undocumented)
    closeTrove(overrides?: EthersTransactionOverrides): Promise<TroveClosureDetails>;
    // @internal (undocumented)
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams: EthersLiquityConnectionOptionalParams & {
        useStore: "blockPolled";
    }): Promise<EthersLiquityWithStore<BlockPolledLiquityStore>>;
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams?: EthersLiquityConnectionOptionalParams): Promise<EthersLiquity>;
    readonly connection: EthersLiquityConnection;
    // (undocumented)
    depositCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    depositZUSDInStabilityPool(amount: Decimalish, frontendTag?: string, overrides?: EthersTransactionOverrides): Promise<StabilityDepositChangeDetails>;
    // @internal (undocumented)
    static _from(connection: EthersLiquityConnection & {
        useStore: "blockPolled";
    }): EthersLiquityWithStore<BlockPolledLiquityStore>;
    // @internal (undocumented)
    static _from(connection: EthersLiquityConnection): EthersLiquity;
    // @internal (undocumented)
    _getActivePool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getCollateralSurplusBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // @internal (undocumented)
    _getDefaultPool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getFees(overrides?: EthersCallOverrides): Promise<Fees>;
    // @internal (undocumented)
    _getFeesFactory(overrides?: EthersCallOverrides): Promise<(blockTimestamp: number, recoveryMode: boolean) => Fees>;
    // (undocumented)
    getFrontendStatus(address?: string, overrides?: EthersCallOverrides): Promise<FrontendStatus>;
    // (undocumented)
    getNumberOfTroves(overrides?: EthersCallOverrides): Promise<number>;
    // (undocumented)
    getPrice(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getStabilityDeposit(address?: string, overrides?: EthersCallOverrides): Promise<StabilityDeposit>;
    // (undocumented)
    getTotal(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTotalRedistributed(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTotalStakedZERO(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getTrove(address?: string, overrides?: EthersCallOverrides): Promise<UserTrove>;
    // (undocumented)
    getTroveBeforeRedistribution(address?: string, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution>;
    // @internal (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution[]>;
    // (undocumented)
    getTroves(params: TroveListingParams, overrides?: EthersCallOverrides): Promise<UserTrove[]>;
    // (undocumented)
    getZEROBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getZEROStake(address?: string, overrides?: EthersCallOverrides): Promise<ZEROStake>;
    // (undocumented)
    getZUSDBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getZUSDInStabilityPool(overrides?: EthersCallOverrides): Promise<Decimal>;
    hasStore(): this is EthersLiquityWithStore;
    hasStore(store: "blockPolled"): this is EthersLiquityWithStore<BlockPolledLiquityStore>;
    // (undocumented)
    liquidate(address: string | string[], overrides?: EthersTransactionOverrides): Promise<LiquidationDetails>;
    // (undocumented)
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number, overrides?: EthersTransactionOverrides): Promise<LiquidationDetails>;
    // (undocumented)
    openNueTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveCreationDetails>;
    // (undocumented)
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveCreationDetails>;
    readonly populate: PopulatableEthersLiquity;
    // (undocumented)
    provideToSpFromDLLR(dllrAmount: Decimalish, permitParams: PermitParams, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    redeemCollateralViaDLLR(dllrAmount: Decimalish, permitParams: PermitParams, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<RedemptionDetails>;
    // (undocumented)
    redeemZUSD(amount: Decimalish, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<RedemptionDetails>;
    // (undocumented)
    registerFrontend(kickbackRate: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    repayZUSD(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    repayZusdFromDLLR(zusdAmount: Decimalish, permitParams: PermitParams, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    readonly send: SendableEthersLiquity;
    // (undocumented)
    sendZERO(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    sendZUSD(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // @internal (undocumented)
    setPrice(price: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    stakeZERO(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    transferCollateralGainToTrove(overrides?: EthersTransactionOverrides): Promise<CollateralGainTransferDetails>;
    // (undocumented)
    unstakeZERO(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    withdrawCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    withdrawFromSpAndConvertToDLLR(spAmount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    withdrawGainsFromStabilityPool(overrides?: EthersTransactionOverrides): Promise<StabilityPoolGainsWithdrawalDetails>;
    // (undocumented)
    withdrawGainsFromStaking(overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    withdrawZusdAndConvertToDLLR(zusdAmount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    withdrawZUSDFromStabilityPool(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<StabilityDepositChangeDetails>;
}

// @public
export interface EthersLiquityConnection extends EthersLiquityConnectionOptionalParams {
    // @internal (undocumented)
    readonly [brand]: unique symbol;
    readonly addresses: Record<string, string>;
    readonly bootstrapPeriod: number;
    readonly chainId: number;
    readonly deploymentDate: Date;
    // @internal (undocumented)
    readonly _isDev: boolean;
    // @internal (undocumented)
    readonly _priceFeedIsTestnet: boolean;
    readonly provider: EthersProvider;
    readonly signer?: EthersSigner;
    readonly startBlock: number;
    readonly version: string;
}

// @public
export interface EthersLiquityConnectionOptionalParams {
    readonly frontendTag?: string;
    readonly userAddress?: string;
    readonly useStore?: EthersLiquityStoreOption;
}

// @public
export type EthersLiquityStoreOption = "blockPolled";

// @public
export interface EthersLiquityWithStore<T extends LiquityStore = LiquityStore> extends EthersLiquity {
    readonly store: T;
}

// @public
export type EthersPopulatedTransaction = PopulatedTransaction;

// @public
export type EthersProvider = Provider;

// @public
export type EthersSigner = Signer;

// @public
export class EthersTransactionFailedError extends TransactionFailedError<FailedReceipt<EthersTransactionReceipt>> {
    constructor(message: string, failedReceipt: FailedReceipt<EthersTransactionReceipt>);
}

// @public
export interface EthersTransactionOverrides {
    // (undocumented)
    from?: string;
    // (undocumented)
    gasLimit?: BigNumberish;
    // (undocumented)
    gasPrice?: BigNumberish;
    // (undocumented)
    nonce?: BigNumberish;
}

// @public
export type EthersTransactionReceipt = TransactionReceipt;

// @public
export type EthersTransactionResponse = TransactionResponse;

// @alpha (undocumented)
export class ObservableEthersLiquity implements ObservableLiquity {
    constructor(readable: ReadableEthersLiquity);
    // (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 PermitParams = {
    deadline: BigNumberish;
    v: BigNumberish;
    r: BytesLike;
    s: BytesLike;
};

// @public
export class PopulatableEthersLiquity implements PopulatableLiquity<EthersTransactionReceipt, EthersTransactionResponse, EthersPopulatedTransaction> {
    constructor(readable: ReadableEthersLiquity);
    // (undocumented)
    adjustNueTrove(params: TroveAdjustmentParams<Decimalish>, permitParams: PermitParams, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    borrowZUSD(amount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    claimCollateralSurplus(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    closeNueTrove(_permitParams: PermitParams, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveClosureDetails>>;
    // (undocumented)
    closeTrove(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveClosureDetails>>;
    // (undocumented)
    depositCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    depositZUSDInStabilityPool(amount: Decimalish, frontendTag?: string, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<StabilityDepositChangeDetails>>;
    // (undocumented)
    findHints(trove: Trove): Promise<[string, string]>;
    // (undocumented)
    liquidate(address: string | string[], overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<LiquidationDetails>>;
    // (undocumented)
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<LiquidationDetails>>;
    // (undocumented)
    openNueTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveCreationDetails>>;
    // (undocumented)
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveCreationDetails>>;
    // (undocumented)
    provideToSpFromDLLR(dllrAmount: Decimalish, permitParams: PermitParams, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    redeemCollateralViaDLLR(amount: Decimalish, permitParams: PermitParams, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersRedemption>;
    // (undocumented)
    redeemZUSD(amount: Decimalish, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersRedemption>;
    // (undocumented)
    registerFrontend(kickbackRate: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    repayZUSD(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    sendZERO(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    sendZUSD(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // @internal (undocumented)
    setPrice(price: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    stakeZERO(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    transferCollateralGainToTrove(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<CollateralGainTransferDetails>>;
    // (undocumented)
    unstakeZERO(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    withdrawFromSpAndConvertToDLLR(zusdAmountRequested: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawGainsFromStabilityPool(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<StabilityPoolGainsWithdrawalDetails>>;
    // (undocumented)
    withdrawGainsFromStaking(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawZusdAndConvertToDLLR(zusdAmount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawZUSDFromStabilityPool(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersLiquityTransaction<StabilityDepositChangeDetails>>;
    }

// @public
export class PopulatedEthersLiquityTransaction<T = unknown> implements PopulatedLiquityTransaction<EthersPopulatedTransaction, SentEthersLiquityTransaction<T>> {
    // @internal
    constructor(rawPopulatedTransaction: EthersPopulatedTransaction, connection: EthersLiquityConnection, parse: (rawReceipt: EthersTransactionReceipt) => T);
    readonly rawPopulatedTransaction: EthersPopulatedTransaction;
    // (undocumented)
    send(): Promise<SentEthersLiquityTransaction<T>>;
}

// @public (undocumented)
export class PopulatedEthersRedemption extends PopulatedEthersLiquityTransaction<RedemptionDetails> implements PopulatedRedemption<EthersPopulatedTransaction, EthersTransactionResponse, EthersTransactionReceipt> {
    // @internal
    constructor(rawPopulatedTransaction: EthersPopulatedTransaction, connection: EthersLiquityConnection, attemptedZUSDAmount: Decimal, redeemableZUSDAmount: Decimal, increaseAmountByMinimumNetDebt?: (maxRedemptionRate?: Decimalish) => Promise<PopulatedEthersRedemption>);
    // (undocumented)
    readonly attemptedZUSDAmount: Decimal;
    // (undocumented)
    increaseAmountByMinimumNetDebt(maxRedemptionRate?: Decimalish): Promise<PopulatedEthersRedemption>;
    // (undocumented)
    readonly isTruncated: boolean;
    // (undocumented)
    readonly redeemableZUSDAmount: Decimal;
}

// @public
export class ReadableEthersLiquity implements ReadableLiquity {
    // @internal
    constructor(connection: EthersLiquityConnection);
    // @internal (undocumented)
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams: EthersLiquityConnectionOptionalParams & {
        useStore: "blockPolled";
    }): Promise<ReadableEthersLiquityWithStore<BlockPolledLiquityStore>>;
    // (undocumented)
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams?: EthersLiquityConnectionOptionalParams): Promise<ReadableEthersLiquity>;
    // (undocumented)
    readonly connection: EthersLiquityConnection;
    // @internal (undocumented)
    static _from(connection: EthersLiquityConnection & {
        useStore: "blockPolled";
    }): ReadableEthersLiquityWithStore<BlockPolledLiquityStore>;
    // @internal (undocumented)
    static _from(connection: EthersLiquityConnection): ReadableEthersLiquity;
    // @internal (undocumented)
    _getActivePool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getCollateralSurplusBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // @internal (undocumented)
    _getDefaultPool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getFees(overrides?: EthersCallOverrides): Promise<Fees>;
    // @internal (undocumented)
    _getFeesFactory(overrides?: EthersCallOverrides): Promise<(blockTimestamp: number, recoveryMode: boolean) => Fees>;
    // (undocumented)
    getFrontendStatus(address?: string, overrides?: EthersCallOverrides): Promise<FrontendStatus>;
    // (undocumented)
    getNumberOfTroves(overrides?: EthersCallOverrides): Promise<number>;
    // (undocumented)
    getPrice(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getStabilityDeposit(address?: string, overrides?: EthersCallOverrides): Promise<StabilityDeposit>;
    // (undocumented)
    getTotal(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTotalRedistributed(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTotalStakedZERO(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getTrove(address?: string, overrides?: EthersCallOverrides): Promise<UserTrove>;
    // (undocumented)
    getTroveBeforeRedistribution(address?: string, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution>;
    // @internal (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution[]>;
    // (undocumented)
    getTroves(params: TroveListingParams, overrides?: EthersCallOverrides): Promise<UserTrove[]>;
    // (undocumented)
    getZEROBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getZEROStake(address?: string, overrides?: EthersCallOverrides): Promise<ZEROStake>;
    // (undocumented)
    getZUSDBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getZUSDInStabilityPool(overrides?: EthersCallOverrides): Promise<Decimal>;
    hasStore(): this is ReadableEthersLiquityWithStore;
    hasStore(store: "blockPolled"): this is ReadableEthersLiquityWithStore<BlockPolledLiquityStore>;
}

// @public
export interface ReadableEthersLiquityWithStore<T extends LiquityStore = LiquityStore> extends ReadableEthersLiquity {
    readonly store: T;
}

// @internal (undocumented)
export const _redeemMaxIterations = 70;

// @public
export class SendableEthersLiquity implements SendableLiquity<EthersTransactionReceipt, EthersTransactionResponse> {
    constructor(populatable: PopulatableEthersLiquity);
    // (undocumented)
    adjustNueTrove(params: TroveAdjustmentParams<Decimalish>, permitParams: PermitParams, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    borrowZUSD(amount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    claimCollateralSurplus(overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    closeNueTrove(permitParams: PermitParams, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveClosureDetails>>;
    // (undocumented)
    closeTrove(overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveClosureDetails>>;
    // (undocumented)
    depositCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    depositZUSDInStabilityPool(amount: Decimalish, frontendTag?: string, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<StabilityDepositChangeDetails>>;
    // (undocumented)
    liquidate(address: string | string[], overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<LiquidationDetails>>;
    // (undocumented)
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<LiquidationDetails>>;
    // (undocumented)
    openNueTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveCreationDetails>>;
    // (undocumented)
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveCreationDetails>>;
    // (undocumented)
    provideToSpFromDLLR(dllrAmount: Decimalish, permitParams: PermitParams, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    redeemCollateralViaDLLR(dllrAmount: Decimalish, permitParams: PermitParams, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<RedemptionDetails>>;
    // (undocumented)
    redeemZUSD(amount: Decimalish, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<RedemptionDetails>>;
    // (undocumented)
    registerFrontend(kickbackRate: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    repayZUSD(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    repayZusdFromDLLR(zusdAmount: Decimalish, permitParams: PermitParams, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    sendZERO(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    sendZUSD(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // @internal (undocumented)
    setPrice(price: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    stakeZERO(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    transferCollateralGainToTrove(overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<CollateralGainTransferDetails>>;
    // (undocumented)
    unstakeZERO(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    withdrawFromSpAndConvertToDLLR(zusdAmountRequested: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawGainsFromStabilityPool(overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<StabilityPoolGainsWithdrawalDetails>>;
    // (undocumented)
    withdrawGainsFromStaking(overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawZusdAndConvertToDLLR(zusdAmount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<void>>;
    // (undocumented)
    withdrawZUSDFromStabilityPool(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersLiquityTransaction<StabilityDepositChangeDetails>>;
}

// @public
export class SentEthersLiquityTransaction<T = unknown> implements SentLiquityTransaction<EthersTransactionResponse, LiquityReceipt<EthersTransactionReceipt, T>> {
    // @internal
    constructor(rawSentTransaction: EthersTransactionResponse, connection: EthersLiquityConnection, parse: (rawReceipt: EthersTransactionReceipt) => T);
    // (undocumented)
    getReceipt(): Promise<LiquityReceipt<EthersTransactionReceipt, T>>;
    readonly rawSentTransaction: EthersTransactionResponse;
    // (undocumented)
    waitForReceipt(): Promise<MinedReceipt<EthersTransactionReceipt, T>>;
}

// @internal (undocumented)
export interface _TroveChangeWithFees<T> {
    // (undocumented)
    fee: Decimal;
    // (undocumented)
    newTrove: Trove;
    // (undocumented)
    params: T;
}

// @public
export class UnsupportedNetworkError extends Error {
    // @internal
    constructor(chainId: number);
    readonly chainId: number;
}


// (No @packageDocumentation comment for this package)

```