@compass-labs/api-sdk 2.2.77 → 2.2.78

package/src/funcs/creditCreditUnloop.ts

@@ -0,0 +1,193 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { CompassApiSDKCore } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
+import { CompassAPISDKError } from "../models/errors/compassapisdkerror.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Unwind a leveraged loop
+ *
+ * @remarks
+ * Unwind an Aave or Morpho loop in ONE atomic transaction.
+ *
+ * Repeatedly withdraws collateral, swaps it to the borrow token at a GUARANTEED
+ * minimum output (enforced on-chain), and repays. The floor discipline means a
+ * swap filling anywhere within the slippage tolerance can never break a later
+ * step; any positive surplus stays in the Credit Account as borrow-token dust
+ * (the preview reports the bound as estimated_max_dust).
+ *
+ * Omit target_multiplier for a full close: the debt is cleared exactly —
+ * accrued interest included — and the pair collateral is returned to the Credit
+ * Account. Pass 1 to clear the debt but keep the collateral supplied, or a value
+ * above 1 to delever to that multiplier (it must be below the position's current
+ * multiplier).
+ *
+ * Each withdrawal is sized to keep the position's health factor ≥ 1.02 at that
+ * step, so a position opened very close to the liquidation threshold may need
+ * more than one transaction to fully close — set allow_partial=true to return
+ * the maximum single-transaction progress (preview.fully_unwound=false), then
+ * call unloop again to finish. Very large unwinds relative to pool depth can
+ * still exceed the slippage tolerance through their own cumulative price impact.
+ *
+ * For protocol=MORPHO pass a market_id from /v2/credit/morpho_markets; inspect
+ * open loops via /v2/credit/looped_positions.
+ */
+export function creditCreditUnloop(
+  client: CompassApiSDKCore,
+  request: components.CreditUnloopRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    components.CreditUnloopResponse,
+    | errors.HTTPValidationError
+    | CompassAPISDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: CompassApiSDKCore,
+  request: components.CreditUnloopRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      components.CreditUnloopResponse,
+      | errors.HTTPValidationError
+      | CompassAPISDKError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => components.CreditUnloopRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = pathToFunc("/v2/credit/unloop")();
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "v2_credit_unloop",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    components.CreditUnloopResponse,
+    | errors.HTTPValidationError
+    | CompassAPISDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, components.CreditUnloopResponse$inboundSchema),
+    M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -62,7 +62,7 @@ export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.1",
   sdkVersion: "2.0.0",
-  genVersion: "2.915.0",
+  genVersion: "2.915.1",
   userAgent:
-    "speakeasy-sdk/typescript 2.0.0 2.915.0 0.0.1 @compass-labs/api-sdk",
+    "speakeasy-sdk/typescript 2.0.0 2.915.1 0.0.1 @compass-labs/api-sdk",
 } as const;

package/src/models/components/creditunlooppreview.ts

@@ -0,0 +1,104 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  UnloopLegPreview,
+  UnloopLegPreview$inboundSchema,
+} from "./unlooplegpreview.js";
+
+/**
+ * Projected end state of the unwind, computed on GUARANTEED swap floors.
+ */
+export type CreditUnloopPreview = {
+  /**
+   * Number of swap-bearing unwind iterations bundled (the final collateral sweep leg does not count).
+   */
+  iterations: number;
+  /**
+   * Guaranteed minimum total collateral withdrawn (token units).
+   */
+  totalCollateralWithdrawn: string;
+  /**
+   * Guaranteed minimum total debt repaid (borrow-token units); actual can only be higher (swap fills above the floor repay more).
+   */
+  totalDebtRepaid: string;
+  /**
+   * Pair collateral left supplied after the unwind (token units). On a full close this is 0, except when non-pair Aave debt still needs this collateral as backing — then the final sweep is capped and this reports the residual left supplied.
+   */
+  endingCollateral: string;
+  /**
+   * Projected remaining debt (borrow-token units); 0 on a full close.
+   */
+  endingDebt: string;
+  /**
+   * Projected leverage after the unwind; 1 when the debt is cleared. Never promises more deleverage than is guaranteed.
+   */
+  endingMultiplier: string;
+  /**
+   * Projected end loan-to-value in percent, at the sizing oracle prices; 0 when the debt is cleared.
+   */
+  projectedLtv: string;
+  /**
+   * Projected health factor (Aave account-level / Morpho market-level). Never overstated at the 1.0 boundary.
+   */
+  projectedHealthFactor: string;
+  /**
+   * Upper bound of borrow-token surplus the unwind can leave in the Credit Account — the sum of each swap's quote minus its guaranteed floor plus the full-close overshoot. It accumulates in the Credit Account, is recoverable, and is never lost.
+   */
+  estimatedMaxDust: string;
+  /**
+   * True when the requested target was fully reached in this transaction. False on a partial-progress plan (allow_partial=true) — call unloop again to finish.
+   */
+  fullyUnwound: boolean;
+  /**
+   * Per-iteration breakdown.
+   */
+  legs?: Array<UnloopLegPreview> | undefined;
+};
+
+/** @internal */
+export const CreditUnloopPreview$inboundSchema: z.ZodType<
+  CreditUnloopPreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  iterations: z.number().int(),
+  total_collateral_withdrawn: z.string(),
+  total_debt_repaid: z.string(),
+  ending_collateral: z.string(),
+  ending_debt: z.string(),
+  ending_multiplier: z.string(),
+  projected_ltv: z.string(),
+  projected_health_factor: z.string(),
+  estimated_max_dust: z.string(),
+  fully_unwound: z.boolean(),
+  legs: z.array(UnloopLegPreview$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "total_collateral_withdrawn": "totalCollateralWithdrawn",
+    "total_debt_repaid": "totalDebtRepaid",
+    "ending_collateral": "endingCollateral",
+    "ending_debt": "endingDebt",
+    "ending_multiplier": "endingMultiplier",
+    "projected_ltv": "projectedLtv",
+    "projected_health_factor": "projectedHealthFactor",
+    "estimated_max_dust": "estimatedMaxDust",
+    "fully_unwound": "fullyUnwound",
+  });
+});
+
+export function creditUnloopPreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditUnloopPreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditUnloopPreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditUnloopPreview' from JSON`,
+  );
+}

package/src/models/components/creditunlooprequest.ts

@@ -0,0 +1,169 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { Chain, Chain$outboundSchema } from "./chain.js";
+import {
+  CreditProtocol,
+  CreditProtocol$outboundSchema,
+} from "./creditprotocol.js";
+
+/**
+ * Target leverage after the unwind. Omit (null) for a FULL unwind: the debt is cleared exactly — accrued interest included — and all pair collateral is withdrawn back to the Credit Account. `1` runs the same exact debt close but leaves the collateral supplied (earning). A value greater than 1 delevers the position to that multiplier. Must be below the position's current multiplier.
+ */
+export type TargetMultiplier = number | string;
+
+/**
+ * Per-swap slippage tolerance in percent. Unwind dust is bounded by this per iteration, so tighter slippage means less dust.
+ */
+export type CreditUnloopRequestMaxSlippagePercent = number | string;
+
+/**
+ * Unwind a leveraged loop: repeatedly withdraw collateral, swap it back to
+ *
+ * @remarks
+ * the borrow token at a guaranteed minimum output, and repay — all in ONE
+ * atomic transaction from the Credit Account.
+ */
+export type CreditUnloopRequest = {
+  /**
+   * The address that owns the Credit Account.
+   */
+  owner: string;
+  /**
+   * The chain to use.
+   */
+  chain: Chain;
+  /**
+   * Which lending protocol a credit action targets.
+   *
+   * @remarks
+   *
+   * ``AAVE`` is the default so existing callers (which never send a ``protocol``
+   * field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+   * Euler V2 path, where the market is identified by EVK vault address(es).
+   * ``MORPHO`` identifies Morpho Blue lending markets (bytes32 market id) and is
+   * currently read-only: positions and market discovery only — transaction
+   * builders land with the looping work (COM-7106/7107/7108), so transact
+   * endpoints reject it with a 422.
+   */
+  protocol?: CreditProtocol | undefined;
+  /**
+   * Morpho only: the bytes32 market id (from /v2/credit/morpho_markets). Required when protocol=MORPHO.
+   */
+  marketId?: string | null | undefined;
+  /**
+   * Token supplied as collateral in the loop being unwound. For MORPHO it must be the market's collateral token.
+   */
+  collateralToken: string;
+  /**
+   * Token borrowed in the loop; withdrawn collateral is swapped back to it and used to repay. For MORPHO it must be the market's loan token.
+   */
+  borrowToken: string;
+  /**
+   * Target leverage after the unwind. Omit (null) for a FULL unwind: the debt is cleared exactly — accrued interest included — and all pair collateral is withdrawn back to the Credit Account. `1` runs the same exact debt close but leaves the collateral supplied (earning). A value greater than 1 delevers the position to that multiplier. Must be below the position's current multiplier.
+   */
+  targetMultiplier?: number | string | null | undefined;
+  /**
+   * Per-swap slippage tolerance in percent. Unwind dust is bounded by this per iteration, so tighter slippage means less dust.
+   */
+  maxSlippagePercent?: number | string | undefined;
+  /**
+   * If the target cannot be reached in one transaction (e.g. a position opened very close to the liquidation threshold), return the maximum-progress plan (preview.fully_unwound=false) instead of a 400. A second unloop call, now from a much lower leverage, finishes the job.
+   */
+  allowPartial?: boolean | undefined;
+  /**
+   * If true, returns EIP-712 typed data for gas-sponsored execution instead of an unsigned transaction.
+   */
+  gasSponsorship?: boolean | undefined;
+};
+
+/** @internal */
+export type TargetMultiplier$Outbound = number | string;
+
+/** @internal */
+export const TargetMultiplier$outboundSchema: z.ZodType<
+  TargetMultiplier$Outbound,
+  z.ZodTypeDef,
+  TargetMultiplier
+> = z.union([z.number(), z.string()]);
+
+export function targetMultiplierToJSON(
+  targetMultiplier: TargetMultiplier,
+): string {
+  return JSON.stringify(
+    TargetMultiplier$outboundSchema.parse(targetMultiplier),
+  );
+}
+
+/** @internal */
+export type CreditUnloopRequestMaxSlippagePercent$Outbound = number | string;
+
+/** @internal */
+export const CreditUnloopRequestMaxSlippagePercent$outboundSchema: z.ZodType<
+  CreditUnloopRequestMaxSlippagePercent$Outbound,
+  z.ZodTypeDef,
+  CreditUnloopRequestMaxSlippagePercent
+> = z.union([z.number(), z.string()]);
+
+export function creditUnloopRequestMaxSlippagePercentToJSON(
+  creditUnloopRequestMaxSlippagePercent: CreditUnloopRequestMaxSlippagePercent,
+): string {
+  return JSON.stringify(
+    CreditUnloopRequestMaxSlippagePercent$outboundSchema.parse(
+      creditUnloopRequestMaxSlippagePercent,
+    ),
+  );
+}
+
+/** @internal */
+export type CreditUnloopRequest$Outbound = {
+  owner: string;
+  chain: string;
+  protocol?: string | undefined;
+  market_id?: string | null | undefined;
+  collateral_token: string;
+  borrow_token: string;
+  target_multiplier?: number | string | null | undefined;
+  max_slippage_percent?: number | string | undefined;
+  allow_partial?: boolean | undefined;
+  gas_sponsorship?: boolean | undefined;
+};
+
+/** @internal */
+export const CreditUnloopRequest$outboundSchema: z.ZodType<
+  CreditUnloopRequest$Outbound,
+  z.ZodTypeDef,
+  CreditUnloopRequest
+> = z.object({
+  owner: z.string(),
+  chain: Chain$outboundSchema,
+  protocol: CreditProtocol$outboundSchema.optional(),
+  marketId: z.nullable(z.string()).optional(),
+  collateralToken: z.string(),
+  borrowToken: z.string(),
+  targetMultiplier: z.nullable(z.union([z.number(), z.string()])).optional(),
+  maxSlippagePercent: z.union([z.number(), z.string()]).optional(),
+  allowPartial: z.boolean().optional(),
+  gasSponsorship: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    marketId: "market_id",
+    collateralToken: "collateral_token",
+    borrowToken: "borrow_token",
+    targetMultiplier: "target_multiplier",
+    maxSlippagePercent: "max_slippage_percent",
+    allowPartial: "allow_partial",
+    gasSponsorship: "gas_sponsorship",
+  });
+});
+
+export function creditUnloopRequestToJSON(
+  creditUnloopRequest: CreditUnloopRequest,
+): string {
+  return JSON.stringify(
+    CreditUnloopRequest$outboundSchema.parse(creditUnloopRequest),
+  );
+}

package/src/models/components/creditunloopresponse.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  BatchedSafeOperationsResponseOutput,
+  BatchedSafeOperationsResponseOutput$inboundSchema,
+} from "./batchedsafeoperationsresponseoutput.js";
+import {
+  CreditUnloopPreview,
+  CreditUnloopPreview$inboundSchema,
+} from "./creditunlooppreview.js";
+import {
+  UnsignedTransaction,
+  UnsignedTransaction$inboundSchema,
+} from "./unsignedtransaction.js";
+
+/**
+ * The atomic unwind transaction plus its guaranteed-floor preview.
+ */
+export type CreditUnloopResponse = {
+  /**
+   * Unsigned transaction for direct execution by the owner. Present when gas_sponsorship=false.
+   */
+  transaction?: UnsignedTransaction | null | undefined;
+  /**
+   * EIP-712 typed data for gas-sponsored execution. Present when gas_sponsorship=true.
+   */
+  eip712?: BatchedSafeOperationsResponseOutput | null | undefined;
+  /**
+   * Projected end state of the unwind, computed on GUARANTEED swap floors.
+   */
+  preview: CreditUnloopPreview;
+};
+
+/** @internal */
+export const CreditUnloopResponse$inboundSchema: z.ZodType<
+  CreditUnloopResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  transaction: z.nullable(UnsignedTransaction$inboundSchema).optional(),
+  eip_712: z.nullable(BatchedSafeOperationsResponseOutput$inboundSchema)
+    .optional(),
+  preview: CreditUnloopPreview$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "eip_712": "eip712",
+  });
+});
+
+export function creditUnloopResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditUnloopResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditUnloopResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditUnloopResponse' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -115,6 +115,9 @@ export * from "./creditsupplyparams.js";
 export * from "./credittransferrequest.js";
 export * from "./credittransferresponse.js";
 export * from "./credittransfertoaddressparams.js";
+export * from "./creditunlooppreview.js";
+export * from "./creditunlooprequest.js";
+export * from "./creditunloopresponse.js";
 export * from "./credituseroperation.js";
 export * from "./creditwithdrawparams.js";
 export * from "./debtposition.js";
@@ -360,6 +363,7 @@ export * from "./uniswapsellexactlytransactionresponse.js";
 export * from "./uniswapsellquoteinforesponse.js";
 export * from "./uniswapwithdrawliquidityprovisionparams.js";
 export * from "./uniswapwithdrawliquidityprovisionrequest.js";
+export * from "./unlooplegpreview.js";
 export * from "./unsignedmulticalltransaction.js";
 export * from "./unsignedtransaction.js";
 export * from "./unwrapwethparams.js";

package/src/models/components/unlooplegpreview.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * One planned unwind iteration: withdraw [+ swap + repay].
+ */
+export type UnloopLegPreview = {
+  /**
+   * Collateral withdrawn this iteration (token units).
+   */
+  withdrawAmount: string | null;
+  /**
+   * Guaranteed swap output (borrow-token units) — enforced on-chain by the swap's minimum-return. Null on the final collateral sweep leg, which does not swap.
+   */
+  minSwapOut?: string | null | undefined;
+  /**
+   * Debt repaid this iteration (borrow-token units); null on the final collateral sweep leg.
+   */
+  repayAmount?: string | null | undefined;
+  /**
+   * True on the closing leg that clears the remaining debt exactly (Aave clamps to live debt; Morpho repays the remaining shares).
+   */
+  fullRepay?: boolean | undefined;
+};
+
+/** @internal */
+export const UnloopLegPreview$inboundSchema: z.ZodType<
+  UnloopLegPreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  withdraw_amount: z.nullable(z.string()),
+  min_swap_out: z.nullable(z.string()).optional(),
+  repay_amount: z.nullable(z.string()).optional(),
+  full_repay: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "withdraw_amount": "withdrawAmount",
+    "min_swap_out": "minSwapOut",
+    "repay_amount": "repayAmount",
+    "full_repay": "fullRepay",
+  });
+});
+
+export function unloopLegPreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<UnloopLegPreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UnloopLegPreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UnloopLegPreview' from JSON`,
+  );
+}

package/src/sdk/credit.ts

@@ -13,6 +13,7 @@ import { creditCreditMorphoMarkets } from "../funcs/creditCreditMorphoMarkets.js
 import { creditCreditPositions } from "../funcs/creditCreditPositions.js";
 import { creditCreditRepay } from "../funcs/creditCreditRepay.js";
 import { creditCreditTransfer } from "../funcs/creditCreditTransfer.js";
+import { creditCreditUnloop } from "../funcs/creditCreditUnloop.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
@@ -206,6 +207,45 @@ export class Credit extends ClientSDK {
     ));
   }
 
+  /**
+   * Unwind a leveraged loop
+   *
+   * @remarks
+   * Unwind an Aave or Morpho loop in ONE atomic transaction.
+   *
+   * Repeatedly withdraws collateral, swaps it to the borrow token at a GUARANTEED
+   * minimum output (enforced on-chain), and repays. The floor discipline means a
+   * swap filling anywhere within the slippage tolerance can never break a later
+   * step; any positive surplus stays in the Credit Account as borrow-token dust
+   * (the preview reports the bound as estimated_max_dust).
+   *
+   * Omit target_multiplier for a full close: the debt is cleared exactly —
+   * accrued interest included — and the pair collateral is returned to the Credit
+   * Account. Pass 1 to clear the debt but keep the collateral supplied, or a value
+   * above 1 to delever to that multiplier (it must be below the position's current
+   * multiplier).
+   *
+   * Each withdrawal is sized to keep the position's health factor ≥ 1.02 at that
+   * step, so a position opened very close to the liquidation threshold may need
+   * more than one transaction to fully close — set allow_partial=true to return
+   * the maximum single-transaction progress (preview.fully_unwound=false), then
+   * call unloop again to finish. Very large unwinds relative to pool depth can
+   * still exceed the slippage tolerance through their own cumulative price impact.
+   *
+   * For protocol=MORPHO pass a market_id from /v2/credit/morpho_markets; inspect
+   * open loops via /v2/credit/looped_positions.
+   */
+  async creditUnloop(
+    request: components.CreditUnloopRequest,
+    options?: RequestOptions,
+  ): Promise<components.CreditUnloopResponse> {
+    return unwrapAsync(creditCreditUnloop(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Transfer tokens to/from Credit Account
    *

package/examples/node_modules/tsx/dist/package-BhsaYzSJ.cjs

@@ -1 +0,0 @@
-"use strict";var r="4.22.5";exports.version=r;

package/examples/node_modules/tsx/dist/package-REq4Oepp.mjs

@@ -1 +0,0 @@
-var r="4.22.5";export{r as v};