@compass-labs/api-sdk 0.0.16 → 0.0.17

package/src/models/components/uniswapbuyexactlyrequest.ts

@@ -24,11 +24,6 @@ import {
  */
 export type UniswapBuyExactlyRequestAmountOut = number | string;
 
-/**
- * The maximum amount of the token to swap from
- */
-export type UniswapBuyExactlyRequestAmountInMaximum = number | string;
-
 /**
  * Request model for buying exactly an amount of tokens.
  */
@@ -64,9 +59,9 @@ export type UniswapBuyExactlyRequest = {
    */
   amountOut: number | string;
   /**
-   * The maximum amount of the token to swap from
+   * The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed.
    */
-  amountInMaximum: number | string;
+  maxSlippagePercent: number;
   /**
    * Whether to wrap ETH to WETH, only use when swapping WETH into something
    */
@@ -132,65 +127,6 @@ export function uniswapBuyExactlyRequestAmountOutFromJSON(
   );
 }
 
-/** @internal */
-export const UniswapBuyExactlyRequestAmountInMaximum$inboundSchema: z.ZodType<
-  UniswapBuyExactlyRequestAmountInMaximum,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
-
-/** @internal */
-export type UniswapBuyExactlyRequestAmountInMaximum$Outbound = number | string;
-
-/** @internal */
-export const UniswapBuyExactlyRequestAmountInMaximum$outboundSchema: z.ZodType<
-  UniswapBuyExactlyRequestAmountInMaximum$Outbound,
-  z.ZodTypeDef,
-  UniswapBuyExactlyRequestAmountInMaximum
-> = z.union([z.number(), z.string()]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace UniswapBuyExactlyRequestAmountInMaximum$ {
-  /** @deprecated use `UniswapBuyExactlyRequestAmountInMaximum$inboundSchema` instead. */
-  export const inboundSchema =
-    UniswapBuyExactlyRequestAmountInMaximum$inboundSchema;
-  /** @deprecated use `UniswapBuyExactlyRequestAmountInMaximum$outboundSchema` instead. */
-  export const outboundSchema =
-    UniswapBuyExactlyRequestAmountInMaximum$outboundSchema;
-  /** @deprecated use `UniswapBuyExactlyRequestAmountInMaximum$Outbound` instead. */
-  export type Outbound = UniswapBuyExactlyRequestAmountInMaximum$Outbound;
-}
-
-export function uniswapBuyExactlyRequestAmountInMaximumToJSON(
-  uniswapBuyExactlyRequestAmountInMaximum:
-    UniswapBuyExactlyRequestAmountInMaximum,
-): string {
-  return JSON.stringify(
-    UniswapBuyExactlyRequestAmountInMaximum$outboundSchema.parse(
-      uniswapBuyExactlyRequestAmountInMaximum,
-    ),
-  );
-}
-
-export function uniswapBuyExactlyRequestAmountInMaximumFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  UniswapBuyExactlyRequestAmountInMaximum,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      UniswapBuyExactlyRequestAmountInMaximum$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'UniswapBuyExactlyRequestAmountInMaximum' from JSON`,
-  );
-}
-
 /** @internal */
 export const UniswapBuyExactlyRequest$inboundSchema: z.ZodType<
   UniswapBuyExactlyRequest,
@@ -201,7 +137,7 @@ export const UniswapBuyExactlyRequest$inboundSchema: z.ZodType<
   token_out: TokenEnum$inboundSchema,
   fee: FeeEnum$inboundSchema,
   amount_out: z.union([z.number(), z.string()]),
-  amount_in_maximum: z.union([z.number(), z.string()]),
+  max_slippage_percent: z.number(),
   wrap_eth: z.boolean().default(false),
   chain: Chain$inboundSchema,
   sender: z.string(),
@@ -210,7 +146,7 @@ export const UniswapBuyExactlyRequest$inboundSchema: z.ZodType<
     "token_in": "tokenIn",
     "token_out": "tokenOut",
     "amount_out": "amountOut",
-    "amount_in_maximum": "amountInMaximum",
+    "max_slippage_percent": "maxSlippagePercent",
     "wrap_eth": "wrapEth",
   });
 });
@@ -221,7 +157,7 @@ export type UniswapBuyExactlyRequest$Outbound = {
   token_out: string;
   fee: string;
   amount_out: number | string;
-  amount_in_maximum: number | string;
+  max_slippage_percent: number;
   wrap_eth: boolean;
   chain: string;
   sender: string;
@@ -237,7 +173,7 @@ export const UniswapBuyExactlyRequest$outboundSchema: z.ZodType<
   tokenOut: TokenEnum$outboundSchema,
   fee: FeeEnum$outboundSchema,
   amountOut: z.union([z.number(), z.string()]),
-  amountInMaximum: z.union([z.number(), z.string()]),
+  maxSlippagePercent: z.number(),
   wrapEth: z.boolean().default(false),
   chain: Chain$outboundSchema,
   sender: z.string(),
@@ -246,7 +182,7 @@ export const UniswapBuyExactlyRequest$outboundSchema: z.ZodType<
     tokenIn: "token_in",
     tokenOut: "token_out",
     amountOut: "amount_out",
-    amountInMaximum: "amount_in_maximum",
+    maxSlippagePercent: "max_slippage_percent",
     wrapEth: "wrap_eth",
   });
 });

package/src/models/components/uniswapsellexactlyparams.ts

@@ -21,12 +21,7 @@ import {
 /**
  * The amount of the token to swap from
  */
-export type UniswapSellExactlyParamsAmountIn = number | string;
-
-/**
- * The minimum amount of the token to swap to, defaults to 0
- */
-export type UniswapSellExactlyParamsAmountOutMinimum = number | string;
+export type UniswapSellExactlyParamsAmount = number | string;
 
 /**
  * Parameters model for selling exactly an amount of tokens.
@@ -61,11 +56,11 @@ export type UniswapSellExactlyParams = {
   /**
    * The amount of the token to swap from
    */
-  amountIn: number | string;
+  amount: number | string;
   /**
-   * The minimum amount of the token to swap to, defaults to 0
+   * The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed.
    */
-  amountOutMinimum?: number | string | undefined;
+  maxSlippagePercent: number;
   /**
    * Whether to wrap ETH to WETH, only use when swapping WETH into something
    */
@@ -73,111 +68,52 @@ export type UniswapSellExactlyParams = {
 };
 
 /** @internal */
-export const UniswapSellExactlyParamsAmountIn$inboundSchema: z.ZodType<
-  UniswapSellExactlyParamsAmountIn,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
-
-/** @internal */
-export type UniswapSellExactlyParamsAmountIn$Outbound = number | string;
-
-/** @internal */
-export const UniswapSellExactlyParamsAmountIn$outboundSchema: z.ZodType<
-  UniswapSellExactlyParamsAmountIn$Outbound,
-  z.ZodTypeDef,
-  UniswapSellExactlyParamsAmountIn
-> = z.union([z.number(), z.string()]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace UniswapSellExactlyParamsAmountIn$ {
-  /** @deprecated use `UniswapSellExactlyParamsAmountIn$inboundSchema` instead. */
-  export const inboundSchema = UniswapSellExactlyParamsAmountIn$inboundSchema;
-  /** @deprecated use `UniswapSellExactlyParamsAmountIn$outboundSchema` instead. */
-  export const outboundSchema = UniswapSellExactlyParamsAmountIn$outboundSchema;
-  /** @deprecated use `UniswapSellExactlyParamsAmountIn$Outbound` instead. */
-  export type Outbound = UniswapSellExactlyParamsAmountIn$Outbound;
-}
-
-export function uniswapSellExactlyParamsAmountInToJSON(
-  uniswapSellExactlyParamsAmountIn: UniswapSellExactlyParamsAmountIn,
-): string {
-  return JSON.stringify(
-    UniswapSellExactlyParamsAmountIn$outboundSchema.parse(
-      uniswapSellExactlyParamsAmountIn,
-    ),
-  );
-}
-
-export function uniswapSellExactlyParamsAmountInFromJSON(
-  jsonString: string,
-): SafeParseResult<UniswapSellExactlyParamsAmountIn, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UniswapSellExactlyParamsAmountIn$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UniswapSellExactlyParamsAmountIn' from JSON`,
-  );
-}
-
-/** @internal */
-export const UniswapSellExactlyParamsAmountOutMinimum$inboundSchema: z.ZodType<
-  UniswapSellExactlyParamsAmountOutMinimum,
+export const UniswapSellExactlyParamsAmount$inboundSchema: z.ZodType<
+  UniswapSellExactlyParamsAmount,
   z.ZodTypeDef,
   unknown
 > = z.union([z.number(), z.string()]);
 
 /** @internal */
-export type UniswapSellExactlyParamsAmountOutMinimum$Outbound = number | string;
+export type UniswapSellExactlyParamsAmount$Outbound = number | string;
 
 /** @internal */
-export const UniswapSellExactlyParamsAmountOutMinimum$outboundSchema: z.ZodType<
-  UniswapSellExactlyParamsAmountOutMinimum$Outbound,
+export const UniswapSellExactlyParamsAmount$outboundSchema: z.ZodType<
+  UniswapSellExactlyParamsAmount$Outbound,
   z.ZodTypeDef,
-  UniswapSellExactlyParamsAmountOutMinimum
+  UniswapSellExactlyParamsAmount
 > = z.union([z.number(), z.string()]);
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace UniswapSellExactlyParamsAmountOutMinimum$ {
-  /** @deprecated use `UniswapSellExactlyParamsAmountOutMinimum$inboundSchema` instead. */
-  export const inboundSchema =
-    UniswapSellExactlyParamsAmountOutMinimum$inboundSchema;
-  /** @deprecated use `UniswapSellExactlyParamsAmountOutMinimum$outboundSchema` instead. */
-  export const outboundSchema =
-    UniswapSellExactlyParamsAmountOutMinimum$outboundSchema;
-  /** @deprecated use `UniswapSellExactlyParamsAmountOutMinimum$Outbound` instead. */
-  export type Outbound = UniswapSellExactlyParamsAmountOutMinimum$Outbound;
+export namespace UniswapSellExactlyParamsAmount$ {
+  /** @deprecated use `UniswapSellExactlyParamsAmount$inboundSchema` instead. */
+  export const inboundSchema = UniswapSellExactlyParamsAmount$inboundSchema;
+  /** @deprecated use `UniswapSellExactlyParamsAmount$outboundSchema` instead. */
+  export const outboundSchema = UniswapSellExactlyParamsAmount$outboundSchema;
+  /** @deprecated use `UniswapSellExactlyParamsAmount$Outbound` instead. */
+  export type Outbound = UniswapSellExactlyParamsAmount$Outbound;
 }
 
-export function uniswapSellExactlyParamsAmountOutMinimumToJSON(
-  uniswapSellExactlyParamsAmountOutMinimum:
-    UniswapSellExactlyParamsAmountOutMinimum,
+export function uniswapSellExactlyParamsAmountToJSON(
+  uniswapSellExactlyParamsAmount: UniswapSellExactlyParamsAmount,
 ): string {
   return JSON.stringify(
-    UniswapSellExactlyParamsAmountOutMinimum$outboundSchema.parse(
-      uniswapSellExactlyParamsAmountOutMinimum,
+    UniswapSellExactlyParamsAmount$outboundSchema.parse(
+      uniswapSellExactlyParamsAmount,
     ),
   );
 }
 
-export function uniswapSellExactlyParamsAmountOutMinimumFromJSON(
+export function uniswapSellExactlyParamsAmountFromJSON(
   jsonString: string,
-): SafeParseResult<
-  UniswapSellExactlyParamsAmountOutMinimum,
-  SDKValidationError
-> {
+): SafeParseResult<UniswapSellExactlyParamsAmount, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      UniswapSellExactlyParamsAmountOutMinimum$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'UniswapSellExactlyParamsAmountOutMinimum' from JSON`,
+    (x) => UniswapSellExactlyParamsAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UniswapSellExactlyParamsAmount' from JSON`,
   );
 }
 
@@ -190,15 +126,14 @@ export const UniswapSellExactlyParams$inboundSchema: z.ZodType<
   token_in: TokenEnum$inboundSchema,
   token_out: TokenEnum$inboundSchema,
   fee: FeeEnum$inboundSchema,
-  amount_in: z.union([z.number(), z.string()]),
-  amount_out_minimum: z.union([z.number(), z.string()]).optional(),
+  amount: z.union([z.number(), z.string()]),
+  max_slippage_percent: z.number(),
   wrap_eth: z.boolean().default(false),
 }).transform((v) => {
   return remap$(v, {
     "token_in": "tokenIn",
     "token_out": "tokenOut",
-    "amount_in": "amountIn",
-    "amount_out_minimum": "amountOutMinimum",
+    "max_slippage_percent": "maxSlippagePercent",
     "wrap_eth": "wrapEth",
   });
 });
@@ -208,8 +143,8 @@ export type UniswapSellExactlyParams$Outbound = {
   token_in: string;
   token_out: string;
   fee: string;
-  amount_in: number | string;
-  amount_out_minimum?: number | string | undefined;
+  amount: number | string;
+  max_slippage_percent: number;
   wrap_eth: boolean;
 };
 
@@ -222,15 +157,14 @@ export const UniswapSellExactlyParams$outboundSchema: z.ZodType<
   tokenIn: TokenEnum$outboundSchema,
   tokenOut: TokenEnum$outboundSchema,
   fee: FeeEnum$outboundSchema,
-  amountIn: z.union([z.number(), z.string()]),
-  amountOutMinimum: z.union([z.number(), z.string()]).optional(),
+  amount: z.union([z.number(), z.string()]),
+  maxSlippagePercent: z.number(),
   wrapEth: z.boolean().default(false),
 }).transform((v) => {
   return remap$(v, {
     tokenIn: "token_in",
     tokenOut: "token_out",
-    amountIn: "amount_in",
-    amountOutMinimum: "amount_out_minimum",
+    maxSlippagePercent: "max_slippage_percent",
     wrapEth: "wrap_eth",
   });
 });

package/src/models/components/uniswapsellexactlyrequest.ts

@@ -22,12 +22,7 @@ import {
 /**
  * The amount of the token to swap from
  */
-export type UniswapSellExactlyRequestAmountIn = number | string;
-
-/**
- * The minimum amount of the token to swap to, defaults to 0
- */
-export type UniswapSellExactlyRequestAmountOutMinimum = number | string;
+export type UniswapSellExactlyRequestAmount = number | string;
 
 /**
  * Request model for selling exactly an amount of tokens.
@@ -62,11 +57,11 @@ export type UniswapSellExactlyRequest = {
   /**
    * The amount of the token to swap from
    */
-  amountIn: number | string;
+  amount: number | string;
   /**
-   * The minimum amount of the token to swap to, defaults to 0
+   * The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed.
    */
-  amountOutMinimum?: number | string | undefined;
+  maxSlippagePercent: number;
   /**
    * Whether to wrap ETH to WETH, only use when swapping WETH into something
    */
@@ -82,115 +77,52 @@ export type UniswapSellExactlyRequest = {
 };
 
 /** @internal */
-export const UniswapSellExactlyRequestAmountIn$inboundSchema: z.ZodType<
-  UniswapSellExactlyRequestAmountIn,
+export const UniswapSellExactlyRequestAmount$inboundSchema: z.ZodType<
+  UniswapSellExactlyRequestAmount,
   z.ZodTypeDef,
   unknown
 > = z.union([z.number(), z.string()]);
 
 /** @internal */
-export type UniswapSellExactlyRequestAmountIn$Outbound = number | string;
-
-/** @internal */
-export const UniswapSellExactlyRequestAmountIn$outboundSchema: z.ZodType<
-  UniswapSellExactlyRequestAmountIn$Outbound,
-  z.ZodTypeDef,
-  UniswapSellExactlyRequestAmountIn
-> = z.union([z.number(), z.string()]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace UniswapSellExactlyRequestAmountIn$ {
-  /** @deprecated use `UniswapSellExactlyRequestAmountIn$inboundSchema` instead. */
-  export const inboundSchema = UniswapSellExactlyRequestAmountIn$inboundSchema;
-  /** @deprecated use `UniswapSellExactlyRequestAmountIn$outboundSchema` instead. */
-  export const outboundSchema =
-    UniswapSellExactlyRequestAmountIn$outboundSchema;
-  /** @deprecated use `UniswapSellExactlyRequestAmountIn$Outbound` instead. */
-  export type Outbound = UniswapSellExactlyRequestAmountIn$Outbound;
-}
-
-export function uniswapSellExactlyRequestAmountInToJSON(
-  uniswapSellExactlyRequestAmountIn: UniswapSellExactlyRequestAmountIn,
-): string {
-  return JSON.stringify(
-    UniswapSellExactlyRequestAmountIn$outboundSchema.parse(
-      uniswapSellExactlyRequestAmountIn,
-    ),
-  );
-}
-
-export function uniswapSellExactlyRequestAmountInFromJSON(
-  jsonString: string,
-): SafeParseResult<UniswapSellExactlyRequestAmountIn, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UniswapSellExactlyRequestAmountIn$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UniswapSellExactlyRequestAmountIn' from JSON`,
-  );
-}
+export type UniswapSellExactlyRequestAmount$Outbound = number | string;
 
 /** @internal */
-export const UniswapSellExactlyRequestAmountOutMinimum$inboundSchema: z.ZodType<
-  UniswapSellExactlyRequestAmountOutMinimum,
+export const UniswapSellExactlyRequestAmount$outboundSchema: z.ZodType<
+  UniswapSellExactlyRequestAmount$Outbound,
   z.ZodTypeDef,
-  unknown
+  UniswapSellExactlyRequestAmount
 > = z.union([z.number(), z.string()]);
 
-/** @internal */
-export type UniswapSellExactlyRequestAmountOutMinimum$Outbound =
-  | number
-  | string;
-
-/** @internal */
-export const UniswapSellExactlyRequestAmountOutMinimum$outboundSchema:
-  z.ZodType<
-    UniswapSellExactlyRequestAmountOutMinimum$Outbound,
-    z.ZodTypeDef,
-    UniswapSellExactlyRequestAmountOutMinimum
-  > = z.union([z.number(), z.string()]);
-
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace UniswapSellExactlyRequestAmountOutMinimum$ {
-  /** @deprecated use `UniswapSellExactlyRequestAmountOutMinimum$inboundSchema` instead. */
-  export const inboundSchema =
-    UniswapSellExactlyRequestAmountOutMinimum$inboundSchema;
-  /** @deprecated use `UniswapSellExactlyRequestAmountOutMinimum$outboundSchema` instead. */
-  export const outboundSchema =
-    UniswapSellExactlyRequestAmountOutMinimum$outboundSchema;
-  /** @deprecated use `UniswapSellExactlyRequestAmountOutMinimum$Outbound` instead. */
-  export type Outbound = UniswapSellExactlyRequestAmountOutMinimum$Outbound;
+export namespace UniswapSellExactlyRequestAmount$ {
+  /** @deprecated use `UniswapSellExactlyRequestAmount$inboundSchema` instead. */
+  export const inboundSchema = UniswapSellExactlyRequestAmount$inboundSchema;
+  /** @deprecated use `UniswapSellExactlyRequestAmount$outboundSchema` instead. */
+  export const outboundSchema = UniswapSellExactlyRequestAmount$outboundSchema;
+  /** @deprecated use `UniswapSellExactlyRequestAmount$Outbound` instead. */
+  export type Outbound = UniswapSellExactlyRequestAmount$Outbound;
 }
 
-export function uniswapSellExactlyRequestAmountOutMinimumToJSON(
-  uniswapSellExactlyRequestAmountOutMinimum:
-    UniswapSellExactlyRequestAmountOutMinimum,
+export function uniswapSellExactlyRequestAmountToJSON(
+  uniswapSellExactlyRequestAmount: UniswapSellExactlyRequestAmount,
 ): string {
   return JSON.stringify(
-    UniswapSellExactlyRequestAmountOutMinimum$outboundSchema.parse(
-      uniswapSellExactlyRequestAmountOutMinimum,
+    UniswapSellExactlyRequestAmount$outboundSchema.parse(
+      uniswapSellExactlyRequestAmount,
     ),
   );
 }
 
-export function uniswapSellExactlyRequestAmountOutMinimumFromJSON(
+export function uniswapSellExactlyRequestAmountFromJSON(
   jsonString: string,
-): SafeParseResult<
-  UniswapSellExactlyRequestAmountOutMinimum,
-  SDKValidationError
-> {
+): SafeParseResult<UniswapSellExactlyRequestAmount, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      UniswapSellExactlyRequestAmountOutMinimum$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'UniswapSellExactlyRequestAmountOutMinimum' from JSON`,
+    (x) => UniswapSellExactlyRequestAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UniswapSellExactlyRequestAmount' from JSON`,
   );
 }
 
@@ -203,8 +135,8 @@ export const UniswapSellExactlyRequest$inboundSchema: z.ZodType<
   token_in: TokenEnum$inboundSchema,
   token_out: TokenEnum$inboundSchema,
   fee: FeeEnum$inboundSchema,
-  amount_in: z.union([z.number(), z.string()]),
-  amount_out_minimum: z.union([z.number(), z.string()]).optional(),
+  amount: z.union([z.number(), z.string()]),
+  max_slippage_percent: z.number(),
   wrap_eth: z.boolean().default(false),
   chain: Chain$inboundSchema,
   sender: z.string(),
@@ -212,8 +144,7 @@ export const UniswapSellExactlyRequest$inboundSchema: z.ZodType<
   return remap$(v, {
     "token_in": "tokenIn",
     "token_out": "tokenOut",
-    "amount_in": "amountIn",
-    "amount_out_minimum": "amountOutMinimum",
+    "max_slippage_percent": "maxSlippagePercent",
     "wrap_eth": "wrapEth",
   });
 });
@@ -223,8 +154,8 @@ export type UniswapSellExactlyRequest$Outbound = {
   token_in: string;
   token_out: string;
   fee: string;
-  amount_in: number | string;
-  amount_out_minimum?: number | string | undefined;
+  amount: number | string;
+  max_slippage_percent: number;
   wrap_eth: boolean;
   chain: string;
   sender: string;
@@ -239,8 +170,8 @@ export const UniswapSellExactlyRequest$outboundSchema: z.ZodType<
   tokenIn: TokenEnum$outboundSchema,
   tokenOut: TokenEnum$outboundSchema,
   fee: FeeEnum$outboundSchema,
-  amountIn: z.union([z.number(), z.string()]),
-  amountOutMinimum: z.union([z.number(), z.string()]).optional(),
+  amount: z.union([z.number(), z.string()]),
+  maxSlippagePercent: z.number(),
   wrapEth: z.boolean().default(false),
   chain: Chain$outboundSchema,
   sender: z.string(),
@@ -248,8 +179,7 @@ export const UniswapSellExactlyRequest$outboundSchema: z.ZodType<
   return remap$(v, {
     tokenIn: "token_in",
     tokenOut: "token_out",
-    amountIn: "amount_in",
-    amountOutMinimum: "amount_out_minimum",
+    maxSlippagePercent: "max_slippage_percent",
     wrapEth: "wrap_eth",
   });
 });

package/src/models/components/usageascollateral.ts

@@ -0,0 +1,80 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  Reserve,
+  Reserve$inboundSchema,
+  Reserve$Outbound,
+  Reserve$outboundSchema,
+} from "./reserve.js";
+
+export type UsageAsCollateral = {
+  fromState: string;
+  toState: string;
+  reserve: Reserve;
+};
+
+/** @internal */
+export const UsageAsCollateral$inboundSchema: z.ZodType<
+  UsageAsCollateral,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  fromState: z.string(),
+  toState: z.string(),
+  reserve: Reserve$inboundSchema,
+});
+
+/** @internal */
+export type UsageAsCollateral$Outbound = {
+  fromState: string;
+  toState: string;
+  reserve: Reserve$Outbound;
+};
+
+/** @internal */
+export const UsageAsCollateral$outboundSchema: z.ZodType<
+  UsageAsCollateral$Outbound,
+  z.ZodTypeDef,
+  UsageAsCollateral
+> = z.object({
+  fromState: z.string(),
+  toState: z.string(),
+  reserve: Reserve$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UsageAsCollateral$ {
+  /** @deprecated use `UsageAsCollateral$inboundSchema` instead. */
+  export const inboundSchema = UsageAsCollateral$inboundSchema;
+  /** @deprecated use `UsageAsCollateral$outboundSchema` instead. */
+  export const outboundSchema = UsageAsCollateral$outboundSchema;
+  /** @deprecated use `UsageAsCollateral$Outbound` instead. */
+  export type Outbound = UsageAsCollateral$Outbound;
+}
+
+export function usageAsCollateralToJSON(
+  usageAsCollateral: UsageAsCollateral,
+): string {
+  return JSON.stringify(
+    UsageAsCollateral$outboundSchema.parse(usageAsCollateral),
+  );
+}
+
+export function usageAsCollateralFromJSON(
+  jsonString: string,
+): SafeParseResult<UsageAsCollateral, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsageAsCollateral$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsageAsCollateral' from JSON`,
+  );
+}