@gearbox-protocol/sdk 16.0.0-next.9 → 16.1.0

package/dist/esm/sdk/prepare/errors.js

@@ -0,0 +1,89 @@
+//#region src/sdk/prepare/errors.ts
+/**
+* One sentence per refusal, naming what was ruled out rather than restating the
+* numbers the error already carries.
+*
+* English and loggable, not a string to put on a screen: a form renders the
+* code and the amounts in its own words, see {@link IGearboxError.message}.
+**/
+const MESSAGES = {
+	debtOutOfRange: "The debt this request implies is outside the market's band.",
+	leverageOutOfRange: "The leverage asked for cannot be expressed as a plan.",
+	insufficientSourceBalance: "Neither the account nor the wallet holds enough to fund this request.",
+	unsupportedCollateralToken: "This flow does not accept that token.",
+	unsupportedTokenPair: "No route exists between these two tokens.",
+	noDelayedRoute: "This request cannot be served as a delayed redemption.",
+	multipleDelayedWithdrawals: "The source asset has several redemption venues and none was named.",
+	withdrawalInProgress: "A redemption of this asset is already in flight on the account.",
+	noRecordedIntent: "The claim names no operation to resume.",
+	marketPaused: "The market is paused.",
+	marketExpired: "The market is past its expiration date.",
+	insufficientPoolLiquidity: "The pool cannot lend what this plan draws.",
+	quotaLimitReached: "The market takes no more quota for a token this plan holds.",
+	forbiddenToken: "This plan would increase the balance of a forbidden token.",
+	insufficientCollateral: "The account would end this transaction under-collateralised.",
+	poolSunset: "The pool is winding down and takes no more deposits.",
+	quotaCountExceeded: "The account would hold more quoted tokens than the facade enables at once.",
+	malformedTransaction: "The transaction could not be replayed."
+};
+/**
+* The engine's refusal, as the error the namespace answers with.
+*
+* One place does the lifting, so the two shapes cannot drift: `reason` becomes
+* `code`, the detail is spread onto the error, and the sentence comes from
+* {@link MESSAGES}. A malformed transaction is spelled out rather than spread,
+* because its detail names a `code` and a `message` of its own and they are not
+* the envelope's.
+*
+* Generic over the issue it is handed, so a call site that already knows the
+* reason gets that reason's error back rather than a union to narrow again.
+**/
+function toRefusalError(issue) {
+	if (issue.reason === "malformedTransaction") return {
+		code: "malformedTransaction",
+		message: MESSAGES.malformedTransaction,
+		previewCode: issue.detail.code,
+		detail: issue.detail.message
+	};
+	return {
+		code: issue.reason,
+		message: MESSAGES[issue.reason],
+		...issue.detail
+	};
+}
+/**
+* {@inheritDoc NoStrategyTargetCollateralError}
+**/
+function noStrategyTargetCollateral(creditManager) {
+	return {
+		code: "noStrategyTargetCollateral",
+		message: `Credit manager ${creditManager} has no strategy target collateral, and none was named.`,
+		creditManager
+	};
+}
+/**
+* {@inheritDoc CreditAccountNotFoundError}
+**/
+function creditAccountNotFound(creditAccount) {
+	return {
+		code: "creditAccountNotFound",
+		message: `Credit account not found: ${creditAccount}.`,
+		creditAccount
+	};
+}
+/**
+* {@inheritDoc UnexpectedFailureError}
+*
+* Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
+* `Error`, and `cause` promises one.
+**/
+function unexpectedFailure(thrown) {
+	const cause = thrown instanceof Error ? thrown : new Error(String(thrown));
+	return {
+		code: "unexpectedFailure",
+		message: `The SDK could not prepare this operation: ${cause.message}`,
+		cause
+	};
+}
+//#endregion
+export { creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };

package/dist/esm/sdk/prepare/index.js

@@ -1,3 +1,5 @@
+import { IntentPreviewError, raise, refuse } from "../../onchain/validation/refusal.js";
+import { creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
 import { PrepareApi } from "./PrepareApi.js";
 import "./types.js";
-export { PrepareApi };
+export { IntentPreviewError, PrepareApi, creditAccountNotFound, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };

package/dist/esm/sdk/prepare/types.js

@@ -1 +1,2 @@
-export {};
+import { IntentPreviewError, raise, refuse } from "../../onchain/validation/refusal.js";
+export { IntentPreviewError, raise, refuse };

package/dist/esm/sdk/prepare/withdrawable-collaterals.js

@@ -0,0 +1,22 @@
+import { isPhantomToken } from "../../onchain/accounts/intents/utils/pick-token.js";
+import "../../onchain/index.js";
+//#region src/sdk/prepare/withdrawable-collaterals.ts
+/**
+* {@inheritDoc IOpportunitiesPrepare.withdrawableCollaterals}
+**/
+function withdrawableCollaterals(sdk, position) {
+	return position.collaterals.filter((c) => !isPhantomToken(sdk, c.collateral.token.address)).sort(byValueThenAddress);
+}
+/**
+* Most valuable first. Address breaks a tie so the order is stable: two
+* collaterals can share a value — a pair of unpriced ones share `null` — and a
+* picker that seeds its default from the first row would otherwise change it
+* between reads.
+*/
+function byValueThenAddress(a, b) {
+	const byValue = (b.collateral.valueUsd ?? 0) - (a.collateral.valueUsd ?? 0);
+	if (byValue !== 0) return byValue;
+	return a.collateral.token.address < b.collateral.token.address ? -1 : 1;
+}
+//#endregion
+export { withdrawableCollaterals };

package/dist/esm/sdk/preview/PreviewNamespace.js

@@ -2,7 +2,7 @@ import { previewOperation } from "../../preview/preview/previewOperation.js";
 import "../../preview/index.js";
 //#region src/sdk/preview/PreviewNamespace.ts
 /**
-* {@inheritDoc Preview}
+* {@inheritDoc IPreview}
 **/
 var PreviewNamespace = class {
 	#onchain;
@@ -14,7 +14,7 @@ var PreviewNamespace = class {
 		this.#logger = options.logger?.child?.({ name: "Preview" }) ?? options.logger;
 	}
 	/**
-	* {@inheritDoc Preview.previewOperation}
+	* {@inheritDoc IPreview.previewOperation}
 	**/
 	async previewOperation(input, options) {
 		await this.#ensureFresh?.([input.chainId]);

package/dist/types/abi/compressors/subcompressors/withdrawal/mellowWithdrawalSubcompressor.d.ts

@@ -67,6 +67,10 @@ declare const mellowWithdrawalSubcompressorAbi: readonly [{
         readonly type: "bytes";
         readonly internalType: "bytes";
       }];
+    }, {
+      readonly name: "redeemer";
+      readonly type: "address";
+      readonly internalType: "address";
     }, {
       readonly name: "extraData";
       readonly type: "bytes";
@@ -105,6 +109,10 @@ declare const mellowWithdrawalSubcompressorAbi: readonly [{
       readonly name: "claimableAt";
       readonly type: "uint256";
       readonly internalType: "uint256";
+    }, {
+      readonly name: "redeemer";
+      readonly type: "address";
+      readonly internalType: "address";
     }, {
       readonly name: "extraData";
       readonly type: "bytes";
@@ -170,6 +178,10 @@ declare const mellowWithdrawalSubcompressorAbi: readonly [{
         readonly type: "bytes";
         readonly internalType: "bytes";
       }];
+    }, {
+      readonly name: "redeemer";
+      readonly type: "address";
+      readonly internalType: "address";
     }, {
       readonly name: "extraData";
       readonly type: "bytes";
@@ -208,6 +220,10 @@ declare const mellowWithdrawalSubcompressorAbi: readonly [{
       readonly name: "claimableAt";
       readonly type: "uint256";
       readonly internalType: "uint256";
+    }, {
+      readonly name: "redeemer";
+      readonly type: "address";
+      readonly internalType: "address";
     }, {
       readonly name: "extraData";
       readonly type: "bytes";

package/dist/types/dev/mode-parity/compareOpportunities.d.ts

@@ -36,14 +36,10 @@ interface OpportunityMatch {
    **/
   onchainName: string;
   offchainName: string;
-  /**
-   * No diffs at all, including the documented offchain-only ones.
-   **/
-  identical: boolean;
   /**
    * No unexpected diffs: every disagreement is mode-scoped or within tolerance.
    **/
-  clean: boolean;
+  similar: boolean;
   diffs: FieldDiff[];
 }
 /**
@@ -93,8 +89,8 @@ interface CompareOpportunitiesInput {
  *
  * Nothing is filtered out. A field only the backend can fill, or a USD value
  * that drifted within snapshot-lag noise, is still reported — tagged
- * {@link FieldDiff.expected} so that {@link CompareCounts.clean} can ignore it
- * while {@link CompareCounts.identical} stays strict.
+ * {@link FieldDiff.expected} so that {@link CompareCounts.similar} can ignore
+ * it.
  **/
 declare function compareOpportunities(input: CompareOpportunitiesInput): OpportunityCompareReport;
 /**

package/dist/types/dev/mode-parity/comparePositions.d.ts

@@ -35,13 +35,10 @@ interface PositionMatch {
   onchainName: string;
   offchainName: string;
   /**
-   * No diffs at all, including the documented mode-scoped ones.
+   * No unexpected diffs: every disagreement is mode-scoped, backend-preferred,
+   * or within tolerance.
    **/
-  identical: boolean;
-  /**
-   * No unexpected diffs: every disagreement is mode-scoped or within tolerance.
-   **/
-  clean: boolean;
+  similar: boolean;
   diffs: FieldDiff[];
 }
 /**
@@ -77,7 +74,7 @@ interface PositionsCompareSummary extends CompareCounts {
    * Wallets whose listings were read and that have no membership gaps and no
    * unexpected field diffs.
    **/
-  walletsClean: number;
+  walletsSimilar: number;
   walletsFailed: number;
   byChain: ChainCompareCounts[];
   byWallet: WalletCompareCounts[];
@@ -135,10 +132,11 @@ interface ComparePositionsInput {
  * Matches two position listings per wallet by {@link positionId} and reports
  * every field the two sources disagree on.
  *
- * Nothing is filtered out. A field only one mode can fill, or a USD value that
- * drifted within snapshot-lag noise, is still reported — tagged
- * {@link FieldDiff.expected} so that {@link CompareCounts.clean} can ignore it
- * while {@link CompareCounts.identical} stays strict.
+ * Nothing is filtered out. A field only one mode can fill, a strategy field
+ * both-mode merge overlays from the backend, or a USD value that drifted
+ * within snapshot-lag noise, is still reported — tagged
+ * {@link FieldDiff.expected} so that {@link CompareCounts.similar} can ignore
+ * it.
  **/
 declare function comparePositions(input: ComparePositionsInput): PositionsCompareReport;
 /**

package/dist/types/dev/mode-parity/fieldDiff.d.ts

@@ -16,10 +16,12 @@ type DiffKind = "presence" | "usd" | "numeric" | "other";
  *
  * - `"mode-scoped"` — a field documented `@mode offchain` or `@mode onchain`,
  *   so the other source has nothing to put there.
+ * - `"backend-preferred"` — both sources fill the field, but both-mode merge
+ *   overlays the backend value.
  * - `"tolerance"` — snapshot lag or float-path noise within the thresholds
  *   below, not a formula or membership mismatch.
  **/
-type ExpectedDiffReason = "mode-scoped" | "tolerance";
+type ExpectedDiffReason = "mode-scoped" | "backend-preferred" | "tolerance";
 /**
  * One field of one row where the two sources disagree.
  **/
@@ -40,7 +42,7 @@ interface FieldDiff {
   kind: DiffKind;
   /**
    * Present when this disagreement is documented or within snapshot-lag noise,
-   * so it does not keep the row from being counted as clean.
+   * so it does not keep the row from being counted as similar.
    **/
   expected?: true;
   reason?: ExpectedDiffReason;
@@ -100,12 +102,14 @@ interface CompareCounts {
   onchainRows: number;
   offchainRows: number;
   matched: number;
-  identical: number;
   /**
-   * Matched rows with no unexpected diffs, including the identical ones.
+   * Matched rows with no unexpected diffs.
    **/
-  clean: number;
-  differing: number;
+  similar: number;
+  /**
+   * Matched rows with at least one unexpected diff.
+   **/
+  different: number;
   onlyOnchain: number;
   onlyOffchain: number;
 }
@@ -155,7 +159,7 @@ declare function diffValue(path: string, onchain: unknown, offchain: unknown, ou
  **/
 declare function diffObjects(onchain: unknown, offchain: unknown, options?: DiffOptions): FieldDiff[];
 /**
- * Mark a diff expected, so a later `clean` count can ignore it.
+ * Mark a diff expected, so a later `similar` count can ignore it.
  **/
 declare function withExpected(diff: FieldDiff, reason: ExpectedDiffReason): FieldDiff;
 /**
@@ -172,8 +176,7 @@ declare function collapseArrayKeys(path: string): string;
  * Membership and match totals of one comparison, from already-built lists.
  **/
 declare function toCompareCounts(onchainRows: number, offchainRows: number, onlyOnchain: number, onlyOffchain: number, matched: ReadonlyArray<{
-  identical: boolean;
-  clean: boolean;
+  similar: boolean;
 }>): CompareCounts;
 /**
  * USD floats within {@link USD_RELATIVE_EPSILON}.

package/dist/types/dev/mode-parity/scriptUtils.d.ts

@@ -16,6 +16,10 @@ declare const TIMEOUT = 480000;
 interface PrintableCompareSummary extends CompareCounts {
   byChain: ChainCompareCounts[];
   diffsByPath: DiffPathCount[];
+  /**
+   * Present on position reports: wallets whose listings could not be read.
+   **/
+  walletsFailed?: number;
 }
 /**
  * Per-source chain metadata both compare reports carry.
@@ -38,10 +42,31 @@ declare function mapPool<T>(items: readonly T[], concurrency: number, fn: (item:
  * Formats a relative difference in bps as a percent, e.g. 12.5 → `"0.125%"`.
  **/
 declare function formatBpsAsPercent(bps: number): string;
+/**
+ * Reasons a compare run should fail CI: unexpected membership or field diffs,
+ * both sources empty, a chain that could not be read, or wallets that failed
+ * to list. Expected diffs (mode-scoped, backend-preferred, tolerance) do not
+ * fail the run.
+ **/
+declare function evaluateCompareFailure(report: PrintableCompareReport): string[];
 /**
  * Prints the shared membership table, the fields that differed most often,
  * and any chain that failed to answer.
  **/
 declare function printCompareSummary(noun: string, report: PrintableCompareReport, extraLines?: string[]): void;
+/**
+ * Markdown of the same summary printed to the console, for GitHub job summaries.
+ **/
+declare function formatCompareMarkdown(noun: string, report: PrintableCompareReport, extraLines?: string[], reasons?: string[]): string;
+/**
+ * Appends {@link formatCompareMarkdown} to `GITHUB_STEP_SUMMARY` when running
+ * in GitHub Actions. No-op locally.
+ **/
+declare function writeGithubJobSummary(noun: string, report: PrintableCompareReport, extraLines?: string[], reasons?: string[]): void;
+/**
+ * Console + job-summary output for a compare run. Returns the failure reasons
+ * so the caller can exit 1 when the report is not similar.
+ **/
+declare function reportCompare(noun: string, report: PrintableCompareReport, extraLines?: string[]): string[];
 //#endregion
-export { BACKEND_URL, ComparedNetwork, NETWORKS, PrintableCompareReport, PrintableCompareSummary, TIMEOUT, createLogger, errorMessage, formatBpsAsPercent, mapPool, printCompareSummary, requireEnv, rpcUrls };
+export { BACKEND_URL, ComparedNetwork, NETWORKS, PrintableCompareReport, PrintableCompareSummary, TIMEOUT, createLogger, errorMessage, evaluateCompareFailure, formatBpsAsPercent, formatCompareMarkdown, mapPool, printCompareSummary, reportCompare, requireEnv, rpcUrls, writeGithubJobSummary };

package/dist/types/history/classifyMulticallOperations.d.ts

@@ -1,6 +1,6 @@
 import { AddressMap } from "../onchain/utils/AddressMap.js";
 import { ParsedCallV2 } from "../onchain/base/types.js";
-import { CallTrace } from "../common-utils/utils/trace.js";
+import { CallTrace } from "../onchain/utils/trace.js";
 import { ChainContractsRegister } from "../onchain/base/ChainContractsRegister.js";
 import "../onchain/index.js";
 import { TokenTransfer } from "../preview/parse/types-adapters.js";

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

@@ -0,0 +1,83 @@
+import { ChartRange, ProtocolChartMetric } from "./charts.js";
+import { ChainScopedFilter } from "./filters.js";
+import { PoolPosition, PositionFilter, StrategyPosition } from "./positions.js";
+import { LiquidationPosition } from "./liquidations.js";
+import { Address } from "viem";
+//#region src/model/analytics.d.ts
+/**
+ * A protocol-wide position row together with the wallet that owns it.
+ *
+ * The position fields stay flat, so consumers can render this row exactly as
+ * they render a wallet-scoped {@link Position}; `borrower` is the only extra
+ * identity the protocol-wide list needs.
+ **/
+type AnalyticsPosition = AnalyticsPoolPosition | AnalyticsStrategyPosition | AnalyticsLiquidationPosition;
+/** Pool position with its owner on the protocol-wide list. */
+type AnalyticsPoolPosition = PoolPosition & AnalyticsPositionOwner;
+/** Strategy position with its borrower on the protocol-wide list. */
+type AnalyticsStrategyPosition = StrategyPosition & AnalyticsPositionOwner;
+/** Liquidation position with its owner on the protocol-wide list. */
+type AnalyticsLiquidationPosition = LiquidationPosition & AnalyticsPositionOwner;
+/** Ownership added to every protocol-wide position row. */
+interface AnalyticsPositionOwner {
+  /** Wallet that owns the pool shares or opened the credit account. */
+  borrower: Address;
+}
+/** Fields the protocol-wide position list can order by. */
+type AnalyticsPositionSortField = "netValueUsd" | "totalValueUsd" | "totalDebtUsd" | "pnlUsd" | "apy" | "healthFactor" | "leverage" | "chainId" | "name" | "borrower";
+/** Direction of one analytics list ordering. */
+type AnalyticsSortDirection = "asc" | "desc";
+/**
+ * Filtering, ordering and offset pagination of the protocol-wide position
+ * list. Omitted position criteria have the same meaning as they do on
+ * {@link PositionFilter}.
+ **/
+interface AnalyticsPositionListOptions extends PositionFilter {
+  /** Keep only positions owned by this wallet. */
+  borrower?: Address;
+  /**
+   * Field to order by. Values that do not apply to a position kind, and USD
+   * values that cannot be priced, are always placed after concrete values.
+   *
+   * @defaultValue `"netValueUsd"`
+   */
+  sortBy?: AnalyticsPositionSortField;
+  /** @defaultValue `"desc"` */
+  sortDirection?: AnalyticsSortDirection;
+  /** Number of matching rows to skip. @defaultValue `0` */
+  offset?: number;
+  /** Number of rows to return, from 1 through 100. @defaultValue `25` */
+  limit?: number;
+}
+/** One page of the protocol-wide position list. */
+interface AnalyticsPositionPage {
+  /** Requested slice after filtering and ordering. */
+  items: AnalyticsPosition[];
+  /** Number of rows matching the filter before pagination. */
+  total: number;
+  /** Effective number of rows skipped. */
+  offset: number;
+  /** Effective maximum number of rows returned. */
+  limit: number;
+}
+/**
+ * What one protocol-wide chart read asks for.
+ *
+ * A {@link ChartQuery} that also carries its chain scope: the series is a sum
+ * over chains rather than a property of one subject, so which chains are in it
+ * is part of the question and not something a path segment already answered.
+ * Omitting `chainIds` asks for every chain the backend serves.
+ **/
+interface AnalyticsChartQuery extends ChainScopedFilter {
+  /**
+   * Metrics to chart, at least one and each named once. They become the keys of
+   * {@link ChartBundle.series}.
+   **/
+  metrics: readonly ProtocolChartMetric[];
+  /**
+   * Window to cover, echoed back in {@link ChartWindow.range}.
+   **/
+  range: ChartRange;
+}
+//#endregion
+export { AnalyticsChartQuery, AnalyticsLiquidationPosition, AnalyticsPoolPosition, AnalyticsPosition, AnalyticsPositionListOptions, AnalyticsPositionOwner, AnalyticsPositionPage, AnalyticsPositionSortField, AnalyticsSortDirection, AnalyticsStrategyPosition };

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

@@ -0,0 +1,213 @@
+import { AnalyticsPosition } from "./analytics.js";
+import { z } from "zod/v4";
+//#region src/model/analytics.schema.d.ts
+/** Default page size of the protocol-wide positions list. */
+declare const ANALYTICS_POSITIONS_DEFAULT_LIMIT = 25;
+/** Largest page the protocol-wide positions list accepts. */
+declare const ANALYTICS_POSITIONS_MAX_LIMIT = 100;
+/** {@link AnalyticsPositionSortField} */
+declare const analyticsPositionSortFieldSchema: z.ZodEnum<{
+  apy: "apy";
+  borrower: "borrower";
+  chainId: "chainId";
+  healthFactor: "healthFactor";
+  leverage: "leverage";
+  name: "name";
+  netValueUsd: "netValueUsd";
+  pnlUsd: "pnlUsd";
+  totalDebtUsd: "totalDebtUsd";
+  totalValueUsd: "totalValueUsd";
+}>;
+/** {@link AnalyticsSortDirection} */
+declare const analyticsSortDirectionSchema: z.ZodEnum<{
+  asc: "asc";
+  desc: "desc";
+}>;
+/** {@link AnalyticsPosition} */
+declare const analyticsPositionSchema: z.ZodType<AnalyticsPosition>;
+/** {@link AnalyticsPositionListOptions} */
+declare const analyticsPositionListOptionsSchema: z.ZodObject<{
+  borrower: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  kind: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>, z.ZodLiteral<"all">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  underlyingType: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>, z.ZodLiteral<"all">]>>;
+  sortBy: z.ZodOptional<z.ZodEnum<{
+    apy: "apy";
+    borrower: "borrower";
+    chainId: "chainId";
+    healthFactor: "healthFactor";
+    leverage: "leverage";
+    name: "name";
+    netValueUsd: "netValueUsd";
+    pnlUsd: "pnlUsd";
+    totalDebtUsd: "totalDebtUsd";
+    totalValueUsd: "totalValueUsd";
+  }>>;
+  sortDirection: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+  offset: z.ZodOptional<z.ZodNumber>;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * {@link AnalyticsPositionListOptions} as URL query parameters.
+ **/
+declare const analyticsPositionListQueryParamsSchema: z.ZodObject<{
+  borrower: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+  kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodEnum<{
+    false: "false";
+    true: "true";
+  }>>;
+  chainIds: z.ZodOptional<z.ZodString>;
+  underlyingType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>>;
+  sortBy: z.ZodOptional<z.ZodEnum<{
+    apy: "apy";
+    borrower: "borrower";
+    chainId: "chainId";
+    healthFactor: "healthFactor";
+    leverage: "leverage";
+    name: "name";
+    netValueUsd: "netValueUsd";
+    pnlUsd: "pnlUsd";
+    totalDebtUsd: "totalDebtUsd";
+    totalValueUsd: "totalValueUsd";
+  }>>;
+  sortDirection: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+  offset: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Codec for an analytics position-list query. It is shared by the SDK client
+ * and backend controller so both sides interpret every parameter identically.
+ **/
+declare const analyticsPositionListQuerySchema: z.ZodCodec<z.ZodObject<{
+  borrower: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+  kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodEnum<{
+    false: "false";
+    true: "true";
+  }>>;
+  chainIds: z.ZodOptional<z.ZodString>;
+  underlyingType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>>;
+  sortBy: z.ZodOptional<z.ZodEnum<{
+    apy: "apy";
+    borrower: "borrower";
+    chainId: "chainId";
+    healthFactor: "healthFactor";
+    leverage: "leverage";
+    name: "name";
+    netValueUsd: "netValueUsd";
+    pnlUsd: "pnlUsd";
+    totalDebtUsd: "totalDebtUsd";
+    totalValueUsd: "totalValueUsd";
+  }>>;
+  sortDirection: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+  offset: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  borrower: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  kind: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>, z.ZodLiteral<"all">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  underlyingType: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>, z.ZodLiteral<"all">]>>;
+  sortBy: z.ZodOptional<z.ZodEnum<{
+    apy: "apy";
+    borrower: "borrower";
+    chainId: "chainId";
+    healthFactor: "healthFactor";
+    leverage: "leverage";
+    name: "name";
+    netValueUsd: "netValueUsd";
+    pnlUsd: "pnlUsd";
+    totalDebtUsd: "totalDebtUsd";
+    totalValueUsd: "totalValueUsd";
+  }>>;
+  sortDirection: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+  offset: z.ZodOptional<z.ZodNumber>;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+/** {@link AnalyticsPositionPage} */
+declare const analyticsPositionPageSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodType<AnalyticsPosition, unknown, z.core.$ZodTypeInternals<AnalyticsPosition, unknown>>>;
+  total: z.ZodNumber;
+  offset: z.ZodNumber;
+  limit: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * {@link AnalyticsChartQuery}
+ *
+ * The metric list is narrowed to {@link ProtocolChartMetric} here rather than
+ * on the route, so asking the protocol chart for an opportunity metric is
+ * rejected by the one codec both sides share instead of by a check only the
+ * backend runs.
+ **/
+declare const analyticsChartQueryOptionsSchema: z.ZodObject<{
+  metrics: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+    tvlUsd: "tvlUsd";
+  }>>>;
+  range: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1w": "1w";
+    "1y": "1y";
+    max: "max";
+  }>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * {@link AnalyticsChartQuery} as URL query parameters: the metrics comma-joined
+ * like every other chart read, and the chains comma-joined like every other
+ * analytics read.
+ **/
+declare const analyticsChartQueryParamsSchema: z.ZodObject<{
+  metrics: z.ZodString;
+  range: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1w": "1w";
+    "1y": "1y";
+    max: "max";
+  }>;
+  chainIds: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Codec for a protocol-wide chart query. It is shared by the SDK client and
+ * backend controller so both sides interpret every parameter identically.
+ **/
+declare const analyticsChartQuerySchema: z.ZodCodec<z.ZodObject<{
+  metrics: z.ZodString;
+  range: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1w": "1w";
+    "1y": "1y";
+    max: "max";
+  }>;
+  chainIds: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  metrics: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+    tvlUsd: "tvlUsd";
+  }>>>;
+  range: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1w": "1w";
+    "1y": "1y";
+    max: "max";
+  }>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>>;
+//#endregion
+export { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, analyticsChartQueryOptionsSchema, analyticsChartQueryParamsSchema, analyticsChartQuerySchema, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema };