@gearbox-protocol/sdk 17.13.0-next.1 → 17.13.0-next.10

package/dist/types/model/errors/operation-errors.d.ts

@@ -6,17 +6,17 @@ import "../../onchain/index.js";
 import { Address } from "viem";
 //#region src/model/errors/operation-errors.d.ts
 /** Input amounts bounded by debt and borrowing capacity; quota is separate. */
-interface CollateralLimits {
+export interface CollateralLimits {
   min: TokenAmount;
   max: TokenAmount;
 }
 /** Target leverage in LEVERAGE_DECIMALS units. */
-interface LeverageLimits {
+export interface LeverageLimits {
   min: bigint;
   max: bigint;
 }
 /** Independent operation inputs imposed by the quota keeper. */
-type QuotaInputLimits = {
+export type QuotaInputLimits = {
   collateralMax: TokenAmount;
   leverageMax?: bigint;
 } | {
@@ -24,7 +24,7 @@ type QuotaInputLimits = {
   leverageMax: bigint;
 };
 /** Prepared operation-specific bounds passed to validation errors. */
-interface OperationLimitOptions {
+export interface OperationLimitOptions {
   collateralLimits?: CollateralLimits;
   leverageLimits?: LeverageLimits;
   quotaLimits?: QuotaInputLimits;
@@ -44,55 +44,55 @@ interface OperationLimitOptions {
  *   `maxDebtPerBlockMultiplier == 0` after a with-loss liquidation
  * - `poolDebtLimit` — pool-wide debt cap; used on account-opening only
  **/
-type BorrowLimitCause = "poolAvailableLiquidity" | "managerDebtAvailable" | "maxDebt" | "quotaAvailable" | "minDebt" | "debtPerBlockLimit" | "poolDebtLimit";
+export type BorrowLimitCause = "poolAvailableLiquidity" | "managerDebtAvailable" | "maxDebt" | "quotaAvailable" | "minDebt" | "debtPerBlockLimit" | "poolDebtLimit";
 /**
  * The credit manager is paused and takes no multicall at all.
  **/
-interface CreditManagerPausedError extends IGearboxError {
+export interface CreditManagerPausedError extends IGearboxError {
   code: "creditManagerPaused";
   creditManager: Address;
 }
 /** {@inheritDoc CreditManagerPausedError} */
-declare function creditManagerPaused(creditManager: Address): CreditManagerPausedError;
+export declare function creditManagerPaused(creditManager: Address): CreditManagerPausedError;
 /**
  * The pool is paused: it neither takes deposits nor serves withdrawals.
  *
  * @remarks Not solvable by changing this operation's parameters.
  **/
-interface PoolPausedError extends IGearboxError {
+export interface PoolPausedError extends IGearboxError {
   code: "poolPaused";
   pool: Address;
 }
 /** {@inheritDoc PoolPausedError} */
-declare function poolPaused(pool: Address): PoolPausedError;
+export declare function poolPaused(pool: Address): PoolPausedError;
 /**
  * The facade is past its expiration date and takes no more multicalls.
  *
  * @remarks Not solvable by changing this operation's parameters.
  **/
-interface MarketExpiredError extends IGearboxError {
+export interface MarketExpiredError extends IGearboxError {
   code: "marketExpired";
   creditManager: Address;
   /** Unix seconds, as the facade reports it. */
   expirationDate: number;
 }
 /** {@inheritDoc MarketExpiredError} */
-declare function marketExpired(creditManager: Address, expirationDate: number): MarketExpiredError;
+export declare function marketExpired(creditManager: Address, expirationDate: number): MarketExpiredError;
 /**
  * The pool is winding down: it still serves withdrawals, but takes no more deposits.
  *
  * @remarks Not solvable by changing this operation's parameters.
  **/
-interface PoolSunsetError extends IGearboxError {
+export interface PoolSunsetError extends IGearboxError {
   code: "poolSunset";
   pool: Address;
 }
 /** {@inheritDoc PoolSunsetError} */
-declare function poolSunset(pool: Address): PoolSunsetError;
+export declare function poolSunset(pool: Address): PoolSunsetError;
 /**
  * The pool cannot lend what the operation wants to borrow.
  **/
-interface InsufficientPoolLiquidityError extends IGearboxError, OperationLimitOptions {
+export interface InsufficientPoolLiquidityError extends IGearboxError, OperationLimitOptions {
   code: "insufficientPoolLiquidity";
   /** Both in the market's underlying. */
   requested: TokenAmount;
@@ -108,12 +108,12 @@ interface InsufficientPoolLiquidityError extends IGearboxError, OperationLimitOp
   maxBorrowAmount?: TokenAmount;
 }
 /** {@inheritDoc InsufficientPoolLiquidityError} */
-declare function insufficientPoolLiquidity(args: Omit<InsufficientPoolLiquidityError, "code" | "message">): InsufficientPoolLiquidityError;
+export declare function insufficientPoolLiquidity(args: Omit<InsufficientPoolLiquidityError, "code" | "message">): InsufficientPoolLiquidityError;
 /**
  * The debt the operation implies falls outside the facade's `debtLimits`
  * (`minDebt`/`maxDebt`).
  **/
-interface DebtOutOfRangeError extends IGearboxError, OperationLimitOptions {
+export interface DebtOutOfRangeError extends IGearboxError, OperationLimitOptions {
   code: "debtOutOfRange";
   /** All three in the market's underlying. */
   requested: TokenAmount;
@@ -123,11 +123,11 @@ interface DebtOutOfRangeError extends IGearboxError, OperationLimitOptions {
   maxBorrowAmount?: MaxBorrowAmount;
 }
 /** {@inheritDoc DebtOutOfRangeError} */
-declare function debtOutOfRange(args: Omit<DebtOutOfRangeError, "code" | "message">): DebtOutOfRangeError;
+export declare function debtOutOfRange(args: Omit<DebtOutOfRangeError, "code" | "message">): DebtOutOfRangeError;
 /**
  * The leverage asked for cannot be expressed as a plan at all.
  **/
-interface LeverageOutOfRangeError extends IGearboxError {
+export interface LeverageOutOfRangeError extends IGearboxError {
   code: "leverageOutOfRange";
   /**
    * Scaled by `LEVERAGE_DECIMALS` (`100n` = 1x), as the intent states it — not
@@ -138,12 +138,12 @@ interface LeverageOutOfRangeError extends IGearboxError {
   min?: bigint;
 }
 /** {@inheritDoc LeverageOutOfRangeError} */
-declare function leverageOutOfRange(args?: Omit<LeverageOutOfRangeError, "code" | "message">): LeverageOutOfRangeError;
+export declare function leverageOutOfRange(args?: Omit<LeverageOutOfRangeError, "code" | "message">): LeverageOutOfRangeError;
 /**
  * The account would end the operation owing more than its collateral is worth
  * under liquidation thresholds, which the facade refuses to allow.
  **/
-interface InsufficientCollateralError extends IGearboxError {
+export interface InsufficientCollateralError extends IGearboxError {
   code: "insufficientCollateral";
   /**
    * The factor that was compared, which for a call that hands funds over is
@@ -160,7 +160,7 @@ interface InsufficientCollateralError extends IGearboxError {
   safePrices: boolean;
 }
 /** {@inheritDoc InsufficientCollateralError} */
-declare function insufficientCollateral(args: Omit<InsufficientCollateralError, "code" | "message">): InsufficientCollateralError;
+export declare function insufficientCollateral(args: Omit<InsufficientCollateralError, "code" | "message">): InsufficientCollateralError;
 /**
  * The same failure as {@link InsufficientCollateralError}, traced to the
  * reserve price feed rather than to the size of the position.
@@ -173,7 +173,7 @@ declare function insufficientCollateral(args: Omit<InsufficientCollateralError,
  * requesting less, while this is a valuation the account does not control, and
  * requesting less only helps as far as {@link withdrawable} says it does.
  **/
-interface ReservePriceLimitedError extends IGearboxError {
+export interface ReservePriceLimitedError extends IGearboxError {
   code: "reservePriceLimited";
   /** The safe-price factor the operation would have ended at. */
   healthFactor: Bps;
@@ -200,22 +200,22 @@ interface ReservePriceLimitedError extends IGearboxError {
   withdrawable: TokenAmount;
 }
 /** {@inheritDoc ReservePriceLimitedError} */
-declare function reservePriceLimited(args: Omit<ReservePriceLimitedError, "code" | "message">): ReservePriceLimitedError;
+export declare function reservePriceLimited(args: Omit<ReservePriceLimitedError, "code" | "message">): ReservePriceLimitedError;
 /**
  * The operation would increase the balance of a token the market forbids.
  *
  * @remarks Not solvable by changing this operation's parameters.
  **/
-interface ForbiddenTokenError extends IGearboxError {
+export interface ForbiddenTokenError extends IGearboxError {
   code: "forbiddenToken";
   token: Token;
 }
 /** {@inheritDoc ForbiddenTokenError} */
-declare function forbiddenToken(token: Token): ForbiddenTokenError;
+export declare function forbiddenToken(token: Token): ForbiddenTokenError;
 /**
  * The market takes no more quota for a token the operation wants to hold.
  **/
-interface QuotaLimitReachedError extends IGearboxError, OperationLimitOptions {
+export interface QuotaLimitReachedError extends IGearboxError, OperationLimitOptions {
   code: "quotaLimitReached";
   /** The token whose quota is increased. */
   token: Token;
@@ -228,20 +228,58 @@ interface QuotaLimitReachedError extends IGearboxError, OperationLimitOptions {
   available: TokenAmount;
 }
 /** {@inheritDoc QuotaLimitReachedError} */
-declare function quotaLimitReached(args: Omit<QuotaLimitReachedError, "code" | "message">): QuotaLimitReachedError;
+export declare function quotaLimitReached(args: Omit<QuotaLimitReachedError, "code" | "message">): QuotaLimitReachedError;
 /**
  * The account would end up with more quoted tokens than the facade enables at
  * once. A count, not an amount — unlike {@link QuotaLimitReachedError}.
  *
  * @remarks Not solvable by changing this operation's parameters.
  **/
-interface QuotaCountExceededError extends IGearboxError {
+export interface QuotaCountExceededError extends IGearboxError {
   code: "quotaCountExceeded";
   count: number;
   max: number;
 }
 /** {@inheritDoc QuotaCountExceededError} */
-declare function quotaCountExceeded(count: number, max: number): QuotaCountExceededError;
+export declare function quotaCountExceeded(count: number, max: number): QuotaCountExceededError;
+/**
+ * The quota keeper charges no rate for this token, so its quota cannot be
+ * changed.
+ *
+ * @remarks Not solvable by changing this operation's parameters.
+ **/
+export interface QuotaInactiveError extends IGearboxError {
+  code: "quotaInactive";
+  token: Token;
+}
+/** {@inheritDoc QuotaInactiveError} */
+export declare function quotaInactive(token: Token): QuotaInactiveError;
+/**
+ * The requested quota rounds to the one the account already has, so there is
+ * nothing to send.
+ **/
+export interface QuotaUnchangedError extends IGearboxError {
+  code: "quotaUnchanged";
+  token: Token;
+  /** Both in the market's underlying. */
+  current: TokenAmount;
+  requested: TokenAmount;
+}
+/** {@inheritDoc QuotaUnchangedError} */
+export declare function quotaUnchanged(args: Omit<QuotaUnchangedError, "code" | "message">): QuotaUnchangedError;
+/**
+ * The requested quota exceeds the facade's per-token `maxQuota`
+ * (`maxQuotaMultiplier × maxDebt`).
+ **/
+export interface QuotaAboveMaxError extends IGearboxError {
+  code: "quotaAboveMax";
+  token: Token;
+  /** Both in the market's underlying. */
+  requested: TokenAmount;
+  maxQuota: TokenAmount;
+}
+/** {@inheritDoc QuotaAboveMaxError} */
+export declare function quotaAboveMax(args: Omit<QuotaAboveMaxError, "code" | "message">): QuotaAboveMaxError;
 /**
  * A balance is too small to fund the operation's step.
  *
@@ -249,7 +287,7 @@ declare function quotaCountExceeded(count: number, max: number): QuotaCountExcee
  * holder H lacks amount X of token T — and differ only in whose balance is
  * short.
  **/
-interface InsufficientBalanceError extends IGearboxError {
+export interface InsufficientBalanceError extends IGearboxError {
   code: "insufficientBalance";
   /**
    * Both absent where the operation was refused before any pair of amounts
@@ -264,11 +302,11 @@ interface InsufficientBalanceError extends IGearboxError {
   holder?: Address;
 }
 /** {@inheritDoc InsufficientBalanceError} */
-declare function insufficientBalance(args?: Omit<InsufficientBalanceError, "code" | "message">): InsufficientBalanceError;
+export declare function insufficientBalance(args?: Omit<InsufficientBalanceError, "code" | "message">): InsufficientBalanceError;
 /**
  * `owner` has not approved `spender` for what the operation pulls.
  **/
-interface InsufficientAllowanceError extends IGearboxError {
+export interface InsufficientAllowanceError extends IGearboxError {
   code: "insufficientAllowance";
   owner: Address;
   spender: Address;
@@ -278,12 +316,12 @@ interface InsufficientAllowanceError extends IGearboxError {
   allowed: TokenAmount;
 }
 /** {@inheritDoc InsufficientAllowanceError} */
-declare function insufficientAllowance(args: Omit<InsufficientAllowanceError, "code" | "message">): InsufficientAllowanceError;
+export declare function insufficientAllowance(args: Omit<InsufficientAllowanceError, "code" | "message">): InsufficientAllowanceError;
 /**
  * The RWA protocol still wants something from the borrower before this token
  * can be opened on.
  **/
-interface RWAOpenRequirementsError extends IGearboxError {
+export interface RWAOpenRequirementsError extends IGearboxError {
   code: "rwaOpenRequirementsNotMet";
   token: Token;
   creditManager: Address;
@@ -296,12 +334,12 @@ interface RWAOpenRequirementsError extends IGearboxError {
   missing?: RWAMissingOpenAccountRequirements;
 }
 /** {@inheritDoc RWAOpenRequirementsError} */
-declare function rwaOpenRequirementsNotMet(args: Omit<RWAOpenRequirementsError, "code" | "message">): RWAOpenRequirementsError;
+export declare function rwaOpenRequirementsNotMet(args: Omit<RWAOpenRequirementsError, "code" | "message">): RWAOpenRequirementsError;
 /**
  * The credit account does not hold the Midas greenlisted role this
  * permissioned mToken requires of its holder.
  **/
-interface AccountNotMidasGreenlistedError extends IGearboxError {
+export interface AccountNotMidasGreenlistedError extends IGearboxError {
   code: "accountNotMidasGreenlisted";
   token: Token;
   creditManager: Address;
@@ -309,6 +347,5 @@ interface AccountNotMidasGreenlistedError extends IGearboxError {
   creditAccount?: Address;
 }
 /** {@inheritDoc AccountNotMidasGreenlistedError} */
-declare function accountNotMidasGreenlisted(args: Omit<AccountNotMidasGreenlistedError, "code" | "message">): AccountNotMidasGreenlistedError;
-//#endregion
-export { AccountNotMidasGreenlistedError, BorrowLimitCause, CollateralLimits, CreditManagerPausedError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientAllowanceError, InsufficientBalanceError, InsufficientCollateralError, InsufficientPoolLiquidityError, LeverageLimits, LeverageOutOfRangeError, MarketExpiredError, OperationLimitOptions, PoolPausedError, PoolSunsetError, QuotaCountExceededError, QuotaInputLimits, QuotaLimitReachedError, RWAOpenRequirementsError, ReservePriceLimitedError, accountNotMidasGreenlisted, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet };
+export declare function accountNotMidasGreenlisted(args: Omit<AccountNotMidasGreenlistedError, "code" | "message">): AccountNotMidasGreenlistedError;
+//#endregion

package/dist/types/model/errors/oracle-errors.d.ts

@@ -6,7 +6,7 @@ import { Address } from "viem";
  *
  * @remarks Not solvable by changing this operation's parameters.
  **/
-interface UnpriceableTokenError extends IGearboxError {
+export interface UnpriceableTokenError extends IGearboxError {
   code: "unpriceableToken";
   /** Token the oracle could not price. */
   token: Address;
@@ -14,6 +14,5 @@ interface UnpriceableTokenError extends IGearboxError {
 /**
  * Builds an {@link UnpriceableTokenError} for `token`.
  **/
-declare function unpriceableTokenError(token: Address): UnpriceableTokenError;
-//#endregion
-export { UnpriceableTokenError, unpriceableTokenError };
+export declare function unpriceableTokenError(token: Address): UnpriceableTokenError;
+//#endregion

package/dist/types/model/errors/prepare-errors.d.ts

@@ -5,17 +5,17 @@ import { Address } from "viem";
 /**
  * Input token is not accepted by the flow (e.g. deposit of a non-underlying).
  **/
-interface UnsupportedCollateralTokenError extends IGearboxError {
+export interface UnsupportedCollateralTokenError extends IGearboxError {
   code: "unsupportedCollateralToken";
   token: Token;
 }
 /** {@inheritDoc UnsupportedCollateralTokenError} */
-declare function unsupportedCollateralToken(token: Token): UnsupportedCollateralTokenError;
+export declare function unsupportedCollateralToken(token: Token): UnsupportedCollateralTokenError;
 /**
  * No route for the trade the plan needs: no pool pair between the tokens,
  * several and none was picked, or the pathfinder found no path.
  **/
-interface UnsupportedTokenPairError extends IGearboxError {
+export interface UnsupportedTokenPairError extends IGearboxError {
   code: "unsupportedTokenPair";
   /**
    * `to` is absent where the market named no output for `from`; both are absent
@@ -25,43 +25,43 @@ interface UnsupportedTokenPairError extends IGearboxError {
   to?: Token;
 }
 /** {@inheritDoc UnsupportedTokenPairError} */
-declare function unsupportedTokenPair(args?: Omit<UnsupportedTokenPairError, "code" | "message">): UnsupportedTokenPairError;
+export declare function unsupportedTokenPair(args?: Omit<UnsupportedTokenPairError, "code" | "message">): UnsupportedTokenPairError;
 /**
  * The intent cannot settle with a delay: the source has no redemption config,
  * the chain has no compressor, or the tail cannot serve the token asked for.
  **/
-interface NoDelayedRouteError extends IGearboxError {
+export interface NoDelayedRouteError extends IGearboxError {
   code: "noDelayedRoute";
   /** Absent where the error is the intent's, not the token's. */
   token?: Token;
 }
 /** {@inheritDoc NoDelayedRouteError} */
-declare function noDelayedRoute(token?: Token): NoDelayedRouteError;
+export declare function noDelayedRoute(token?: Token): NoDelayedRouteError;
 /** Several redemption venues for the source, and nothing says which. */
-interface MultipleDelayedWithdrawalsError extends IGearboxError {
+export interface MultipleDelayedWithdrawalsError extends IGearboxError {
   code: "multipleDelayedWithdrawals";
   token: Token;
   venues: number;
 }
 /** {@inheritDoc MultipleDelayedWithdrawalsError} */
-declare function multipleDelayedWithdrawals(token: Token, venues: number): MultipleDelayedWithdrawalsError;
+export declare function multipleDelayedWithdrawals(token: Token, venues: number): MultipleDelayedWithdrawalsError;
 /** A redemption of the same asset is already in flight. */
-interface WithdrawalInProgressError extends IGearboxError {
+export interface WithdrawalInProgressError extends IGearboxError {
   code: "withdrawalInProgress";
   /** The phantom token standing for the redemption already in flight. */
   inFlight: TokenAmount;
 }
 /** {@inheritDoc WithdrawalInProgressError} */
-declare function withdrawalInProgress(inFlight: TokenAmount): WithdrawalInProgressError;
+export declare function withdrawalInProgress(inFlight: TokenAmount): WithdrawalInProgressError;
 /**
  * The claim names no operation to resume: requested without an intent, or read
  * through a compressor too old to report one.
  **/
-interface NoRecordedIntentError extends IGearboxError {
+export interface NoRecordedIntentError extends IGearboxError {
   code: "noRecordedIntent";
 }
 /** {@inheritDoc NoRecordedIntentError} */
-declare function noRecordedIntent(): NoRecordedIntentError;
+export declare function noRecordedIntent(): NoRecordedIntentError;
 /**
  * Opening asked for no target token and the market names none of its own, so
  * there is nothing to put the position into.
@@ -69,33 +69,33 @@ declare function noRecordedIntent(): NoRecordedIntentError;
  * A market fact, not a bad argument: pass a `targetToken` to open against a
  * manager that has no default one.
  **/
-interface NoStrategyTargetCollateralError extends IGearboxError {
+export interface NoStrategyTargetCollateralError extends IGearboxError {
   code: "noStrategyTargetCollateral";
   creditManager: Address;
 }
 /** {@inheritDoc NoStrategyTargetCollateralError} */
-declare function noStrategyTargetCollateral(creditManager: Address): NoStrategyTargetCollateralError;
+export declare function noStrategyTargetCollateral(creditManager: Address): NoStrategyTargetCollateralError;
 /**
  * No account at that address in the markets this SDK is connected to — closed
  * since it was listed, or read on the wrong chain.
  **/
-interface CreditAccountNotFoundError extends IGearboxError {
+export interface CreditAccountNotFoundError extends IGearboxError {
   code: "creditAccountNotFound";
   creditAccount: Address;
 }
 /** {@inheritDoc CreditAccountNotFoundError} */
-declare function creditAccountNotFound(creditAccount: Address): CreditAccountNotFoundError;
+export declare function creditAccountNotFound(creditAccount: Address): CreditAccountNotFoundError;
 /**
  * The account named to open a position on carries debt or quotas.
  *
  * Growing a position that already exists is `depositStrategy`.
  **/
-interface CreditAccountNotEmptyError extends IGearboxError {
+export interface CreditAccountNotEmptyError extends IGearboxError {
   code: "creditAccountNotEmpty";
   creditAccount: Address;
 }
 /** {@inheritDoc CreditAccountNotEmptyError} */
-declare function creditAccountNotEmpty(creditAccount: Address): CreditAccountNotEmptyError;
+export declare function creditAccountNotEmpty(creditAccount: Address): CreditAccountNotEmptyError;
 /**
  * The SDK could not answer at all: a read that failed, a chain it is not
  * connected to, a market or token address it knows nothing about, a contract
@@ -106,7 +106,7 @@ declare function creditAccountNotEmpty(creditAccount: Address): CreditAccountNot
  * prepare method or a check always answers: what used to escape as an
  * exception arrives here instead, whole, under `cause`.
  **/
-interface UnexpectedFailureError extends IGearboxError {
+export interface UnexpectedFailureError extends IGearboxError {
   code: "unexpectedFailure";
   /** What actually went wrong, for a log and a bug report. */
   cause: Error;
@@ -117,6 +117,5 @@ interface UnexpectedFailureError extends IGearboxError {
  * Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
  * `Error`, and `cause` promises one.
  **/
-declare function unexpectedFailure(thrown: unknown, action?: string): UnexpectedFailureError;
-//#endregion
-export { CreditAccountNotEmptyError, CreditAccountNotFoundError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithdrawalInProgressError, creditAccountNotEmpty, creditAccountNotFound, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, unexpectedFailure, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress };
+export declare function unexpectedFailure(thrown: unknown, action?: string): UnexpectedFailureError;
+//#endregion

package/dist/types/model/errors/preview-errors.d.ts

@@ -5,7 +5,7 @@ import { Address, Hex } from "viem";
  * Target of a transaction is not a known Gearbox contract
  * (pool/facade/etc.)
  */
-interface UnsupportedTargetError extends IGearboxError {
+export interface UnsupportedTargetError extends IGearboxError {
   code: "unsupportedTarget";
   /** Target address no known Gearbox contract answers for. */
   target: Address;
@@ -13,7 +13,7 @@ interface UnsupportedTargetError extends IGearboxError {
 /**
  * Pool call uses a function other than ERC4626 `deposit`/`redeem`.
  */
-interface UnsupportedPoolFunctionError extends IGearboxError {
+export interface UnsupportedPoolFunctionError extends IGearboxError {
   code: "unsupportedPoolFunction";
   /** Pool the call targets. */
   pool: Address;
@@ -23,7 +23,7 @@ interface UnsupportedPoolFunctionError extends IGearboxError {
 /**
  * Zapper call uses a function other than a known `deposit`/`redeem` variant.
  */
-interface UnsupportedZapperFunctionError extends IGearboxError {
+export interface UnsupportedZapperFunctionError extends IGearboxError {
   code: "unsupportedZapperFunction";
   /** Zapper contract the call targets. */
   zapper: Address;
@@ -34,7 +34,7 @@ interface UnsupportedZapperFunctionError extends IGearboxError {
  * Refusal answered by `previewOperation` for parsed operations it cannot
  * preview yet.
  */
-interface UnsupportedOperationError extends IGearboxError {
+export interface UnsupportedOperationError extends IGearboxError {
   code: "unsupportedOperation";
   /** The parsed operation kind (the `operation` discriminant). */
   operation: string;
@@ -43,7 +43,7 @@ interface UnsupportedOperationError extends IGearboxError {
  * Delayed-withdrawal request or redemption log carries
  * non-empty `extraData` that cannot be decoded as a `DelayedIntent`.
  */
-interface InvalidDelayedIntentError extends IGearboxError {
+export interface InvalidDelayedIntentError extends IGearboxError {
   code: "invalidDelayedIntent";
   /** Raw `extraData` that failed to decode. */
   extraData: Hex;
@@ -53,7 +53,7 @@ interface InvalidDelayedIntentError extends IGearboxError {
 /**
  * Pool operation preview read (ERC4626 preview/`balanceOf`) fails.
  */
-interface PoolOperationPreviewError extends IGearboxError {
+export interface PoolOperationPreviewError extends IGearboxError {
   code: "poolOperationPreviewError";
   /** Pool the operation targeted. */
   pool: Address;
@@ -63,10 +63,9 @@ interface PoolOperationPreviewError extends IGearboxError {
  * Facade multicalls theoretically allow many more combinations of calls,
  * but sdk generates and parses only certain combinations.
  */
-interface MalformedTransactionError extends IGearboxError {
+export interface MalformedTransactionError extends IGearboxError {
   code: "malformedTransaction";
 }
 /** {@inheritDoc MalformedTransactionError} */
-declare function malformedTransaction(detail: string, cause?: Error): MalformedTransactionError;
-//#endregion
-export { InvalidDelayedIntentError, MalformedTransactionError, PoolOperationPreviewError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError, malformedTransaction };
+export declare function malformedTransaction(detail: string, cause?: Error): MalformedTransactionError;
+//#endregion

package/dist/types/model/filters.d.ts

@@ -3,7 +3,7 @@ import { ChainId } from "./primitives.js";
 /**
  * The part of a filter that scopes it to chains, which every list filter has.
  **/
-interface ChainScopedFilter {
+export interface ChainScopedFilter {
   /**
    * Keep only entities from these chains.
    **/
@@ -12,11 +12,11 @@ interface ChainScopedFilter {
 /**
  * Sentinel a filter condition can be set to instead of being omitted.
  **/
-declare const FILTER_ALL = "all";
+export declare const FILTER_ALL = "all";
 /**
  * Type of {@link FILTER_ALL}.
  **/
-type FilterAll = typeof FILTER_ALL;
+export type FilterAll = typeof FILTER_ALL;
 /**
  * A filter condition: a value, the {@link FILTER_ALL} sentinel, or omitted.
  *
@@ -26,11 +26,10 @@ type FilterAll = typeof FILTER_ALL;
  * const anyKind: Filterable<OpportunityKind> = "all"; // pools and strategies
  * ```
  **/
-type Filterable<T> = T | FilterAll;
+export type Filterable<T> = T | FilterAll;
 /**
  * Whether a condition narrows anything. An omitted condition and one set to
  * {@link FILTER_ALL} both do not, so this is the only check a predicate needs.
  **/
-declare function isFilterSet<T>(condition: Filterable<T> | undefined): condition is T;
-//#endregion
-export { ChainScopedFilter, FILTER_ALL, FilterAll, Filterable, isFilterSet };
+export declare function isFilterSet<T>(condition: Filterable<T> | undefined): condition is T;
+//#endregion

package/dist/types/model/filters.schema.d.ts

@@ -8,12 +8,12 @@ import { z } from "zod/v4";
 /**
  * {@link FilterAll}
  **/
-declare const filterAllSchema: z.ZodLiteral<"all">;
+export declare const filterAllSchema: z.ZodLiteral<"all">;
 /**
  * {@link Filterable}
  **/
-declare function filterable<T extends z.ZodType>(schema: T): z.ZodUnion<[T, typeof filterAllSchema]>;
-declare const booleanParamSchema: z.ZodEnum<{
+export declare function filterable<T extends z.ZodType>(schema: T): z.ZodUnion<[T, typeof filterAllSchema]>;
+export declare const booleanParamSchema: z.ZodEnum<{
   false: "false";
   true: "true";
 }>;
@@ -21,6 +21,5 @@ declare const booleanParamSchema: z.ZodEnum<{
  * A boolean condition as a URL can carry it: a condition that does not narrow
  * is absent rather than spelled out, see {@link booleanParamSchema}.
  **/
-declare function encodeFlag(condition: Filterable<boolean> | undefined): "true" | "false" | undefined;
-//#endregion
-export { booleanParamSchema, encodeFlag, filterAllSchema, filterable };
+export declare function encodeFlag(condition: Filterable<boolean> | undefined): "true" | "false" | undefined;
+//#endregion